DEV Community: Tensor Labs

Observation State Made Simple

Tensor Labs — Tue, 13 Jan 2026 07:42:43 +0000

If you ever made any research or play around the source code for Uniswap v3 or Raydium CLMM, you most likely would stumble upon the observation array. To the uninitiated, it looks like a series of random, massive integers.

But in an amazing way these numbers are the feats of financial engineering. they allow a liquidity pool to act as it's very own On-Chain Oracle without requiring an external price such as Chainlink or Pyth Network.

In this article, we would skim through the math that makes Concentrated Liquidity Market Maker (CLMM) observation states work.

The Core Problem: Liquidity Manipulation

In V2 AMMs, the current price is very dangerous, flash loan attack can be used to buy massive amount of Token A, driving price up using that inflated price as collateral to borrow against a lending protocol, and then dumping the token—all in one block.
To fix this, CLMMs make use of Time-Weighted Average Price TWAP to efficiently calculate TWAP on-chain by using the Observation State.

Transforming Price into Ticks

In a CLMM, we don't track the price directly, We track the Ticks. The price(P) and tick (i) are related by:

By taking the logarithm, we get:

Why do we do this? Because math with exponents is hard for computers to average, but math with integers (ticks) is easy. When we move into "Tick Space," we are essentially working in a logarithmic scale where multiplication turns into addition.

The Accumulator Pattern
The Observation State uses an Accumulator. Instead of storing every price change, the contract stores a "running total" of the price-time product.

Whenever a swap happens, the contract updates the tickCumulative:

a (subset of t): The new cumulative value.
i (subset of current): The current active tick.
Delta t: The number of seconds since the last update

Example:

At 12:00:00, the tick is 10 and the cumulative total is 1,000,000.
At 12:00:10, a swap happens. 10 seconds have passed.
New Cumulative: $1,000,000 + (10 \times 10) = 1,000,100$.

Reconstructing the Average

To find the average price between two timestamps t(subset 1) and t(subset 2), a developer just needs to fetch two observations from the state array.The math for the Average Tick ($\bar{i}$) is:

Once you have the average tick, you convert it back to the human-readable

This result is a Geometric Mean. It is mathematically superior for finance because it represents the "true" center of a percentage-based move, making it much harder for a single whale to skew the average with a brief spike.

Liquidity Tracking

The Observation State also tracks secondsPerLiquidityCumulative. This allows protocols to see how much liquidity was active at specific price ranges.

The formula follows the same accumulator logic:

This allows external contracts to verify not just the price, but the depth of the market during a specific window.

Development Tip: Cardinality

By default, most CLMM pools only store one observation (the most recent one). If you are building a lending protocol or a dApp that needs 30-minute price history, you must call the increaseObservationCardinalityNext function.

This "slots" more space in the array, allowing the pool to store more history (e.g., 100 observations instead of 1).

In Summary
The Observation State is a "compressed" history of the pool. By storing the integral of the tick over time, CLMMs provide:

Gas Efficiency: Only one update per block.
Security: High resistance to Flash Loan attacks.
Independence: No need for off-chain oracles.

Building a Simple Email Spam Classifier in Rust with SmartCore

Tensor Labs — Wed, 25 Jun 2025 10:49:25 +0000

Machine learning is often associated with Python, but the Rust ecosystem is quickly catching up! In this article, I’ll walk you through building a simple email spam classifier in Rust using the SmartCore machine learning library. This project is perfect for Rustaceans curious about ML, or anyone looking for a practical, hackable example.

Why Rust for Machine Learning?

Rust is known for its safety, speed, and growing ecosystem. While Python dominates the ML world, Rust offers:

Memory safety without garbage collection
Blazing fast execution
Strong type system for fewer runtime errors
A rapidly expanding set of data and ML libraries

Project Overview

We’ll build a K-Nearest Neighbors (KNN) classifier that predicts whether an email address is spam or real, based on simple features:

The length of the email address
The number of special (non-alphanumeric) characters

Our dataset is a CSV file with two columns: spam and real, each containing example email addresses.

The Dataset

Here’s a sample of our public/spam.csv:

spam,real
winner@spammy.com,john.doe@example.com
cheapmeds@pharmacy.com,info@company.com
bankalert@fraud.com,support@service.com
...

The Code

Below is the full Rust code for the classifier. It reads the CSV, extracts features, trains a KNN model, evaluates accuracy, and lets you check if any email is spam.

Repo -> https://github.com/DevWonder01/rust-ml

use smartcore::linalg::basic::matrix::DenseMatrix;
use smartcore::neighbors::knn_classifier::KNNClassifier;
use smartcore::metrics::accuracy;
use serde::{Deserialize, Serialize};
use std::error::Error;
use std::fs::File;
use csv::Reader;

#[derive(Deserialize, Serialize, Debug, Clone)]
struct Email {
    spam: String,
    real: String,
}

fn count_special_chars(s: &str) -> usize {
    s.chars().filter(|c| !c.is_alphanumeric()).count()
}

fn process_data() -> Result<(DenseMatrix<f64>, Vec<i32>), Box<dyn Error>> {
    let filename = "public/spam.csv";
    let file = File::open(filename)?;
    let mut rdr = Reader::from_reader(file);

    let mut data: Vec<f64> = Vec::new();
    let mut labels: Vec<i32> = Vec::new();
    let mut rows = 0;

    for result in rdr.records() {
        let record = result?;
        let email: Email = record.deserialize(None)?;
        println!("{:?}", email);

        // Features for spam email
        data.push(email.spam.len() as f64);
        data.push(count_special_chars(&email.spam) as f64);
        labels.push(1);

        // Features for real email
        data.push(email.real.len() as f64);
        data.push(count_special_chars(&email.real) as f64);
        labels.push(0);

        rows += 2;
    }

    let matrix = DenseMatrix::new(rows, 2, data, true);
    println!("{:?}", matrix);
    println!("{:?}", labels);
    Ok((matrix, labels))
}

fn predict_email(knn: &KNNClassifier<f64, DenseMatrix<f64>>, email: &str) -> Result<(), Box<dyn Error>> {
    let features = vec![email.len() as f64, count_special_chars(email) as f64];
    let feature_slice = [&features[..]];
    let prediction = knn.predict(&DenseMatrix::from_2d_array(&feature_slice))?;
    if prediction[0] == 1 {
        println!("{} is predicted as SPAM", email);
    } else {
        println!("{} is predicted as REAL", email);
    }
    Ok(())
}

fn main() -> Result<(), Box<dyn Error>> {
    let (matrix, labels) = process_data()?;

    // Train KNN classifier
    let knn = KNNClassifier::fit(&matrix, &labels, Default::default())?;

    // Predict on the training data
    let predictions = knn.predict(&matrix)?;

    // Calculate accuracy
    let acc = accuracy(&labels, &predictions);
    println!("Accuracy: {}", acc);

    // Example: check if a single email is spam
    let test_email = "winner@gmail.com";
    predict_email(&knn, test_email)?;

    Ok(())
}

How It Works

Feature Engineering:

For each email, we extract two features: the length and the number of special characters.
Model Training:

We use SmartCore’s KNN classifier, training it on all the data.
Prediction:

The model predicts whether a new email address is spam or real based on its features.
Evaluation:

The code prints the model’s accuracy on the training data.

Running the Project

Add dependencies to your Cargo.toml:

   smartcore = "0.3"
   serde = { version = "1.0", features = ["derive"] }
   csv = "1.1"

Place your dataset at public/spam.csv.
Run the project:

   cargo run

What’s Next?

Try more advanced features (e.g., domain analysis, word counts)
Split your data into training and test sets for a more realistic evaluation
Experiment with other algorithms in SmartCore

Final Thoughts

Rust is ready for machine learning experimentation! With libraries like SmartCore, you can build, train, and deploy ML models with the safety and speed Rust is famous for.

Give it a try and let’s grow the Rust ML community together!

Questions or suggestions? Drop a comment below or connect with me!

rustlang #machinelearning #rustml #emailsecurity #opensource

Setting Up Your Ultimate Linux Dev Environment: Rust, Docker & More!

Tensor Labs — Wed, 04 Jun 2025 15:18:31 +0000

Are you a developer working on a Debian-based Linux system (like Ubuntu or Kali Linux) and looking for a streamlined way to set up your development environment with Rust, essential build tools, and Docker? Look no further!
This article walks you through a powerful Bash script that automates the installation of these crucial tools, getting you up and running quickly.
Why Automate Your Dev Environment Setup?
Setting up a new machine or ensuring consistency across multiple development environments can be tedious and error-prone. Automation with a script like this ensures:
Consistency: Every setup is identical, reducing "it works on my machine" issues.
Speed: Install everything in minutes, not hours.
Reliability: Reduces human error during complex installations.
Reproducibility: Easily recreate your environment whenever needed.
The Automation Script Explained
Let's dive into the script and understand what each section does.

!/bin/bash

This script automates the setup of a comprehensive development environment

on Debian-based Linux systems (like Ubuntu or Kali Linux).

It includes Rust, essential build tools, and Docker with Docker Compose.

Exit immediately if a command exits with a non-zero status.

set -e

echo "Starting development environment setup..."

!/bin/bash: The shebang line, indicating that the script should be executed with Bash.

set -e: A critical command that ensures the script will exit immediately if any command fails. This prevents partial or broken installations.
echo: Used throughout the script to provide clear feedback on the installation progress.

Install Rust Programming Language Rust is a modern systems programming language known for its performance, memory safety, and concurrency. rustup is its official installer and toolchain manager. # --- 1. Install Rust Programming Language --- echo "--- Installing Rust Programming Language ---" # Install rustup and the Rust toolchain curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Update your shell environment for the current session

This ensures cargo and rustc commands are immediately available

source "$HOME/.cargo/env"
echo "Rust installation complete. PATH updated for current session."

This section downloads and runs the rustup script, which installs the Rust compiler (rustc) and its package manager (cargo). The source "$HOME/.cargo/env" command updates your shell's PATH for the current session, making Rust commands immediately available.

Install Essential Build Tools Many software projects, including some Rust crates, rely on underlying C/C++ libraries. build-essential provides the core compilers and utilities needed for this. # --- 2. Install Essential Build Tools --- echo "--- Installing Essential Build Tools ---" # Update package lists sudo apt update

Install build-essential (includes gcc, g++, make)

sudo apt install -y build-essential
echo "Build essential tools installed."

``sudo apt update refreshes your package lists, and sudo apt install -y build-essential installs gcc, g++, make, and other crucial tools required for compiling C/C++ code. The -y flag automatically confirms prompts.

3. Install Additional Development Dependencies

This section includes specific libraries and tools that are often required for various development tasks, especially those involving Perl or secure communication.


bash
# --- 3. Install Additional Development Dependencies (Perl, OpenSSL dev, pkg-config) ---
sudo apt-get install -y \
    perl \
    perl-base \
    perl-modules \
    libssl-dev \
    pkg-config
echo "Additional development dependencies installed."


Here, perl and its base modules are installed. libssl-dev provides development headers for OpenSSL, essential for projects dealing with SSL/TLS encryption. pkg-config helps manage compilation flags for libraries.
4. Install libudev-dev
libudev-dev is a development library for udev, which handles device events in Linux. It's often a dependency for Rust crates that need to interact with hardware, such as USB devices.
# --- 4. Install libudev-dev ---
echo "--- Installing libudev-dev ---"
sudo apt-get install -y libudev-dev
echo "libudev-dev installed."


5. Install Docker
Docker is a game-changer for containerizing applications, ensuring consistent environments from development to production.
# --- 5. Install Docker ---
echo "--- Installing Docker ---"
# Install necessary packages for Docker's repository
sudo apt-get install -y \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

# Add Docker's official GPG key
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "Docker GPG key added."

# Set up the stable Docker repository
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
echo "Docker repository added."

# Update apt package index again after adding the new repository
sudo apt-get update

# Install Docker Engine
sudo apt-get install -y docker-ce docker-ce-cli containerd.io
echo "Docker Engine installed."

# Add user to docker group
sudo usermod -aG docker "$USER"
echo "User '$USER' added to the 'docker' group. IMPORTANT: You must log out and log back in (or reboot) for this change to take effect."


This section adds Docker's official repository and GPG key, then installs the Docker Engine, CLI, and containerd.io. Crucially, it adds your current user to the docker group, allowing you to run Docker commands without sudo (after a re-login).
6. Install Docker Compose
Docker Compose simplifies the management of multi-container Docker applications, allowing you to define your services in a single docker-compose.yml file.
# --- 6. Install Docker Compose ---
echo "--- Installing Docker Compose ---"
# Download Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# Apply executable permissions
sudo chmod +x /usr/local/bin/docker-compose

# Change ownership (optional but good practice)
sudo chown "$USER" /usr/local/bin/docker-compose
echo "Docker Compose downloaded and permissions set."

# Verify Docker Compose installation
echo "Verifying Docker Compose installation:"
docker-compose --version

echo "Development environment setup complete!"
echo "Remember to log out and log back in (or reboot) to apply Docker group changes."


This final section downloads the Docker Compose binary, makes it executable, and sets its ownership. A verification step confirms the installation.
How to Run the Script
Save the script: Copy the entire script content into a file (e.g., setup_dev_env.sh).
Make it executable: Open your terminal and run:
chmod +x setup_dev_env.sh


Execute the script:
./setup_dev_env.sh

You will be prompted for your sudo password as needed.
Important: After the script finishes, remember to log out and log back in (or reboot your system) to ensure that your user's membership in the docker group takes effect.
Conclusion
With this script, you can quickly set up a powerful and consistent development environment on your Debian-based Linux machine, equipped with Rust, essential build tools, Docker, and Docker Compose. This automation saves time and reduces friction, letting you focus on what matters most: building amazing software!
Happy coding!
#Linux #Ubuntu #KaliLinux #Rust #Docker #DockerCompose #DevSetup #Automation #BashScripting

rust

Tensor Labs — Tue, 26 Nov 2024 09:50:33 +0000

Switching from Chainlink VRF to Pyth Entropy

Tensor Labs — Mon, 25 Nov 2024 18:02:50 +0000

As decentralized applications (dApps) continue to evolve, the demand for robust, transparent, and cost-effective solutions is ever-growing. In the world of prediction markets, derivative sand blockchain gaming, randomness plays a crucial role in determining outcomes that users can trust. Historically, Chainlink’s VRF (Verifiable Random Function) has been the go-to solution for generating secure random numbers on-chain. However, with the rise of innovative alternatives like Pyth Entropy, the landscape is shifting.

We’ll walk through the key differences between both services, discuss the benefits of Pyth Entropy, and provide a detailed look at the Solidity code behind the transition.

Why Randomness Matters in Blockchain Applications

Randomness ensures fairness and unpredictability in dApps, especially in use cases like gaming, lotteries, and prediction markets. Without a trusted source of randomness, dApps risk exposing themselves to manipulation or biases that could undermine user trust.

In a simple Coin Flip Game, randomness determines whether the outcome is heads or tails. Thus, ensuring the randomness source is reliable is critical to maintaining fairness

Chainlink’s VRF

The Chainlink VRF has been the industry standard for generating verifiable random numbers on-chain, it ensures that random numbers used in a smart contract are unpredictable. The randomness is generated off-chain and then verified on-chain, providing both security and transparency.
Key Features of Chainlink VRF Integration:

Subscription Model: Users need to set up and fund a Chainlink subscription.
Verifiable Randomness: Random numbers are generated and verified by the Chainlink network.
Gas Costs: Chainlink VRF involves higher gas fees due to off-chain processing and interaction with the Chainlink oracle network.
Sample Chainlink VRF Solidity Code for Coin Flip.

function playWithVRF(bool face) external payable {
        Bet memory bet = _playWithVRF();
        coinTossBets[bet.id].face = face;

        emit PlaceBet(bet.id, bet.user, face);
    }

    function _playWithVRF() internal returns (Bet memory) {
        uint256 requestId = s_vrfCoordinator.requestRandomWords(
            VRFV2PlusClient.RandomWordsRequest({
                keyHash: keyHash,
                subId: s_subscriptionId,
                requestConfirmations: requestConfirmations,
                callbackGasLimit: callbackGasLimit,
                numWords: numWords,
                // native payment = false, means chainlink will charge user $LINK tokens (cheaper method)
                // native payment = true, means chainlink will charge ETH 
                extraArgs: VRFV2PlusClient._argsToBytes(
                    VRFV2PlusClient.ExtraArgsV1({nativePayment: false})
                )
            })
        );

        Bet memory newBet = Bet(
            false,
            msg.sender,
            requestId,
            block.timestamp,
            false
        );
        _userBets[msg.sender].push(requestId);
        bets[requestId] = newBet;
        return newBet;
    }

    function fulfillRandomWords(
        uint256 _requestId /* requestId */,
        uint256[] calldata randomWords
    ) internal override {
        CoinTossBet storage coinTossBet = coinTossBets[_requestId];
        Bet storage bet = bets[_requestId];
        uint256 roller = randomWords[0] % 2;

        bool[2] memory coinSides = [false, true];
        bool rolledCoinSide = coinSides[roller];
        coinTossBet.rolled = rolledCoinSide;

        if (rolledCoinSide == coinTossBet.face) {
            bet.resolved = true;
            bet.betStatus = true;
            emit Roll(bet.id, bet.user, coinTossBet.face, rolledCoinSide);
        } else {
            bet.resolved = true;
            bet.betStatus = false;
            emit Roll(bet.id, bet.user, coinTossBet.face, rolledCoinSide);
        }

        emit Roll(bet.id, bet.user, coinTossBet.face, rolledCoinSide);
    }

    function getBetData(uint256 id) public view returns (Bet memory betData) {
        Bet storage data = bets[id];
        return data;
    }

Enter Pyth Entropy: A New Standard for On-Chain Randomness

While Chainlink VRF provides an excellent solution, Pyth Entropy presents several advantages for dApps , particularly in terms of gas efficiency, flexibility, and integration with the existing Pyth Network ecosystem. Pyth Entropy is a randomness generator that ensures decentralized and verifiable randomness on-chain, just like VRF, but offers a more streamlined and cost-efficient model.

*Why Switch to Pyth Entropy?
*

Lower Fees: Pyth Entropy requires fewer resources than Chainlink VRF, leading to lower transaction costs for users.
Direct Integration with Pyth Network: dApps which already uses Pyth for its price feeds, making the integration of Entropy a natural fit.
Scalability: As a dApp expands its product offerings, using a more scalable solution like Pyth Entropy ensures that future random-based features can be easily integrated.
Faster Response Times: Since Pyth Entropy processes directly on-chain, the randomness is returned faster than with off-chain processes.

*Sample Pyth Entropy Solidity Code for Coin Flip:
*

function getProvider() external view returns (address) {
        address p = entropy.getDefaultProvider();
        return p;
    }

    function getFlipFee() public view returns (uint256 fee) {
        fee = entropy.getFee(entropyProvider);
    }

    function entropyCallback(
        uint64 sequenceNumber,
        address,
        bytes32 randomNumber
    ) internal override {
        uint256 _s = uint256(sequenceNumber);
        CoinTossBet storage coinTossBet = coinTossBets[_s];
        Bet storage bet = bets[_s];
        bool rolled = uint256(randomNumber) % 2 == 0;

        coinTossBet.rolled = rolled;

        if (rolled == coinTossBet.face) {
            bet.resolved = true;
            bet.betStatus = true;
            emit Roll(bet.id, bet.user, coinTossBet.face, rolled);
        } else {
            bet.resolved = true;
            bet.betStatus = false;

            emit Roll(bet.id, bet.user, coinTossBet.face, rolled);
        }

        emit Roll(bet.id, bet.user, coinTossBet.face, rolled);
        emit FlipResult(sequenceNumber, uint256(randomNumber) % 2 == 0);
    }

    function getEntropy() internal view override returns (address) {
        return address(entropy);
    }

    function flipWithPyth(
        bool face,
        bytes32 userRandomNumber
    ) external payable {
        address provider = entropy.getDefaultProvider();
        uint256 fee = entropy.getFee(provider);

        if (msg.value < fee) {
            revert CoinFlipErrors.InsufficientFee();
        }

        uint64 sequenceNumber = entropy.requestWithCallback{value: fee}(
            provider,
            userRandomNumber
        );

        uint256 _s = uint256(sequenceNumber);
        emit FlipRequest(sequenceNumber);
        Bet memory newBet = Bet(false, msg.sender, _s, block.timestamp, false);
        _userBets[msg.sender].push(_s);
        bets[_s] = newBet;

        coinTossBets[newBet.id].face = face;

        emit PlaceBet(newBet.id, newBet.user, face);
    }

*The decision to transition from Chainlink VRF to Pyth *

Entropy is more than just a technical upgrade for any dApp. It’s a step toward a more scalable, cost-effective future that aligns with the platform’s goals of transparency and user-centric design.
As Pyth Entropy continues to grow in adoption, we expect to see more projects making the switch, particularly those already embedded in the Pyth ecosystem.
The decision to transition from Chainlink VRF to Pyth Entropy is more than just a technical upgrade for any dApp. It’s a step toward a more scalable, cost-effective future that aligns with the platform’s goals of transparency and user-centric design.
As Pyth Entropy continues to grow in adoption, we expect to see more projects making the switch, particularly those already embedded in the Pyth ecosystem.

To get access to the full Solidity code and hardhat environment use 👇
Repo Link

don’t forget to follow me on
https://x.com/devwonder01
https://github.com/DevWonder01

Pyth
https://docs.pyth.network/entropy — docs

Chainlink
https://vrf.chain.link/ — subscription manager
https://docs.chain.link/vrf — docs