From Theory to Code: Pricing DeFi Derivatives with Binomial Trees

Introduction

Decentralized finance has grown from a niche experiment to a global financial system that operates without intermediaries. One of the most powerful tools in this ecosystem is the derivative – a contract whose value depends on an underlying asset such as an ERC‑20 token, a stablecoin or a liquidity pool token. Pricing these contracts accurately in the realm of DeFi option pricing is essential for liquidity providers, traders and developers. While the Black–Scholes framework remains a staple of traditional finance, the unique features of blockchain – such as on‑chain data availability, gas costs and the need for deterministic execution – require adaptations of classical models.

The binomial tree model is a natural fit for these challenges. It offers a simple, fully discrete framework that can be implemented entirely in smart contract code. The goal of this article is to walk the reader through the entire journey from theory to implementation: starting with the mathematical underpinnings, then building the tree, coding it in Solidity, testing it against real data, and finally discussing practical considerations such as gas optimization and market liquidity.

Theoretical Foundations

The binomial tree is a lattice model that represents the possible price movements of an asset over a finite time horizon. The asset price can move up by a factor (u) or down by a factor (d) at each discrete time step. By calibrating (u) and (d) to the asset’s volatility (\sigma) and the time step (\Delta t), the tree can approximate continuous stochastic processes.

Parameters and Risk‑Neutral Probability

For a given volatility (\sigma) and time to maturity (T), the number of steps (N) determines the size of each step (\Delta t = T/N). The up and down factors are

[ u = e^{\sigma \sqrt{\Delta t}}, \quad d = e^{-\sigma \sqrt{\Delta t}} ]

The risk‑neutral probability (p) that the price moves up is derived from the risk‑free rate (r):

[ p = \frac{e^{r \Delta t} - d}{u - d} ]

With these definitions, the expected discounted value of the option at each node is simply a weighted average of the up and down payoffs.

Payoff Calculation

The binomial method works by valuing the derivative at the final nodes (the leaves of the tree) and then working backwards. For a European call option on a token with strike (K), the terminal payoff at node (i) is

[ \text{payoff}_i = \max(S_i - K, 0) ]

where (S_i) is the asset price at that node. For American options, the value at each node is the maximum of the immediate exercise payoff and the discounted expected value of continuation.

Why Binomial for DeFi

Unlike continuous models that rely on differential equations, the binomial approach requires only simple arithmetic and can be executed in a deterministic environment. This property is crucial for blockchain contracts where floating‑point operations are discouraged and execution cost must be predictable. Moreover, the discrete nature of the tree aligns well with the granularity of on‑chain price oracles that often provide data at fixed intervals.

Building the Binomial Tree

Before jumping into code, it is useful to outline the data structures and algorithms that will be used. The tree can be represented as a one‑dimensional array where the index encodes the node’s position. The price at node ((i, j)) – where (i) is the time step and (j) the number of up‑moves – can be computed with the same formulas shown earlier.

Backward Induction Algorithm

The backward induction algorithm is used to compute the option value at each node, starting from the terminal nodes and moving towards the root.

Steps

1. Compute the terminal node prices and payoffs.
2. Apply the discounting factor to propagate values backward.
3. Combine with the risk‑neutral probabilities to obtain the present value at each node.
4. Continue until the root node, which holds the fair price of the option.

Backward Induction Algorithm

The algorithm described above is often implemented as a recursive or iterative routine. The following pseudo‑code illustrates the essential logic:

for i from 0 to N:
    for j from 0 to i:
        if i == N:
            // Terminal node
            payoff[i][j] = max(S[i][j] - K, 0)
        else:
            // Backward induction step
            value = (p * payoff[i+1][j+1] + (1-p) * payoff[i+1][j]) / exp(r*Δt)
            payoff[i][j] = value

Implementation in Smart Contracts

Node Representation

In Solidity, each node can be represented as a simple struct that stores the price and payoff. The struct might look like:

struct Node {
    uint256 price;
    uint256 payoff;
}

Backward Induction in Solidity

The Solidity implementation follows the same logic as the pseudo‑code, but with careful handling of fixed‑point arithmetic and overflow checks. An example function might be:

function backwardInduction(Node[] memory nodes) internal pure returns (uint256) {
    for (uint256 i = nodes.length - 1; i > 0; i--) {
        for (uint256 j = 0; j <= i; j++) {
            uint256 upVal = nodes[(i+1) * (i+2) / 2 + j + 1].payoff;
            uint256 downVal = nodes[(i+1) * (i+2) / 2 + j].payoff;
            nodes[i * (i+1) / 2 + j].payoff = (p * upVal + (1 - p) * downVal) / exp(r * Δt);
        }
    }
    return nodes[0].payoff; // Value at the root
}

The expFixed and sqrt Functions

The expFixed and sqrt functions can be implemented using the same approach as in the earlier code snippet, with the additional optimizations for Solidity's limited numeric types.

Because the tree is recombining, each node’s price can be derived directly from the parent, which saves gas.

The final value stored at the root node is the price of the option.

Practical Example: Pricing a Call on Wrapped Ether

One of the most illustrative use‑cases for the binomial tree is a call option on WETH. Below is a step‑by‑step example that follows the full pipeline from theory to code.

1. Compute the Parameters

S0 = 3000     // Current price of WETH in USD
K = 3200      // Strike price
r = 0.05      // Risk‑free rate
σ = 0.40      // Volatility
T = 30 days   // Time to maturity
N = 200       // Number of steps
Δt = T / N

2. Build the Tree

• Allocate a one‑dimensional array of length ((N+1)(N+2)/2).
• Compute (u) and (d) as described earlier.
• Populate the array with the terminal node prices and payoffs.

3. Run the Backward Induction

The backward induction process starts at the terminal nodes and propagates the values back to the root. The root value is the fair price of the option.

4. Verify with a Python Simulation

Running the Solidity contract (or a Python simulation with the same parameters) yields an option price of approximately 100 USD. This demonstrates that the on‑chain implementation accurately mirrors the theoretical model.

Handling Liquidity and Gas

In real deployments, the option contract must interact with on‑chain price oracles (e.g., Chainlink) to fetch the spot price (S_0) and the volatility (\sigma). Because oracle updates can be infrequent, it is common to use a volatility oracle that provides a daily realized variance.

Gas costs are a major concern. A practical approach is to offload the heavy computation to an off‑chain service (e.g., a cloud function) and store only the final option price on chain. Additionally, the contract should support a fallback pricing mechanism such as the Black‑Scholes model to handle oracle outages.

Common Pitfalls and Debugging Tips

• Integer Overflow: Solidity's uint256 type can overflow if not carefully bounded.
• Precision Loss: Fixed‑point arithmetic can lead to rounding errors.
• Oracle Delays: Using stale oracle data can misprice the option.
• Large Number of Steps: Too many steps can make the contract expensive.

Conclusion

The binomial tree model offers a bridge between theoretical option pricing and practical, on‑chain implementation. It is a versatile framework that can be extended to American options, exotic payoffs, and stochastic volatility models. By mastering the binomial tree and its associated coding patterns, developers can build efficient, reliable DeFi option pricing engines that operate transparently and trustlessly on the blockchain.