Math for Smart Contracts

Curves, Fixed-Point & PRBMath

Pre-requisite Solidity Math

From middle-school math to reading PRBMath source code

What You Need to Know

• ✓ Basic Solidity: uint256, functions, msg.value
• ✓ What a smart contract is and how to deploy one
• ✗ No calculus needed
• ✗ No prior math library experience needed

Part 1: What Is a Function?

A function is a machine: input → rule → output

function f(uint256 x) pure returns (uint256) {
    return 2 * x + 3;
}

Graphing a Function

A graph plots every (input, output) pair as a dot. Connect the dots → a line or curve.

X-axis = input  |  Y-axis = output  |  Drag m to tilt, b to shift  |  f(x) = m·x + b → in bonding curves: x = supply, y = price

Slope: How Fast Does It Rise?

Straight Lines vs. Curves

A line has constant slope. A curve has changing slope.

— Blue (linear): same rate  |  — Orange (expo): accelerates  |  — Green (log): slows down  |  Each shape = a different economic personality.

Part 2: The Five Curves You'll See in DeFi

Linear: y = mx + b

// Solidity: linear pricing
function price(uint256 supply)
    pure returns (uint256)
{
    // m = 0.5 (as 5e17 in fixed-point)
    // b = 1   (as 1e18 in fixed-point)
    return supply * 5e17 / 1e18 + 1;
    // simplified: supply / 2 + 1
}

Quadratic: y = ax²

Square Root: y = √x

Exponential: y = e^x

Sidebar: What Is e?

You know π ≈ 3.14 (circles). Meet e ≈ 2.718 (growth).

• Imagine $1 in a bank at 100% annual interest
• Compounded once: $1 × 2 = $2.00
• Compounded twice: $1 × 1.5² = $2.25
• Compounded daily: $1 × (1 + 1/365)³⁶⁵ = $2.714...
• Compounded infinitely: $1 × e = $2.71828...

Logarithm: y = ln(x)

All Five Together

• — Linear  |  — Quadratic  |  — Square Root  |  — Exponential  |  — Logarithmic

Part 3: Area Under a Curve

When you buy multiple tokens, each one costs a different price. How do you find the total cost?

Shaded area = total ETH to buy tokens from supply 2 to 8.

Counting Rectangles (The Loop Way)

Curve: P(s) = 0.5s + 1  |  Buy tokens #3 – #7 (5 tokens)

The Shortcut: One Formula

Linear curve → area = trapezoid: Area = (top + bottom) × width / 2

Part 4: Solidity Can't Do Decimals

Quick: what's the result of these Solidity operations?

uint256 a = 7 / 2;    // = ?
uint256 b = 1 / 3;    // = ?
uint256 c = 5 / 10;   // = ?

• 7/2 should be 3.5 → Solidity gives you 3 (truncates toward zero)
• 1/3 should be 0.333... → Solidity gives you 0
• No float, no double, no decimal type exists in Solidity

The Trick: Pretend Integers Are Decimals

What if we agree: "1e18 means 1.0"?

Fixed-Point Arithmetic: The Rules

// 1.5 + 0.3 = 1.8
uint256 a = 15e17; // 1.5
uint256 b = 3e17;  // 0.3
uint256 c = a + b; // 18e17 = 1.8 ✓

// 1.5 × 0.3 = 0.45
uint256 a = 15e17; // 1.5
uint256 b = 3e17;  // 0.3
uint256 c = a * b / 1e18;
// = 45e34 / 1e18 = 45e16 = 0.45 ✓

Fixed-Point: Division Trap

// WRONG: 3.0 / 2.0 = ???
uint256 a = 3e18;  // 3.0
uint256 b = 2e18;  // 2.0
uint256 wrong = a / b;        // = 1  (lost all decimals!)

// RIGHT: multiply FIRST, then divide
uint256 right = a * 1e18 / b; // = 3e36 / 2e18 = 15e17 = 1.5 ✓

Danger: Overflow

// uint256 max = 2^256 - 1 ≈ 1.16 × 10^77

// Multiplying two large fixed-point numbers:
uint256 a = 1000e18; // 1000.0
uint256 b = 1000e18; // 1000.0
// a * b = 1e42 → still fits in uint256 ✓

// But three multiplications chained:
// a * b * c before dividing = 1e63 → might overflow!

// Safe approach: divide between multiplications
uint256 ab = a * b / 1e18;  // 1e42 / 1e18 = 1e24 ✓
uint256 result = ab * c / 1e18; // stays manageable

PRBMath handles this for you internally — that's a big reason to use it.

Part 5: PRBMath — The Library

PRBMath gives you exp, ln, sqrt, pow, mul, div — all in fixed-point.

// How do you compute e^(0.08)?
// You can't. Solidity has no exp().
// You'd need a Taylor series:
// e^x ≈ 1 + x + x²/2 + x³/6 + ...
// Each term needs careful fixed-point
// mul and div with overflow checks.
// 20+ lines of tricky math code.

import {UD60x18, ud, exp}
    from "prb-math/UD60x18.sol";

UD60x18 result = exp(ud(0.08e18));
// result ≈ 1.0833e18
// Done. One line.

UD60x18: The Type

• It's still a uint256 under the hood — just wrapped in a custom type
• The 18 digits = same precision as ERC-20 tokens (ETH has 18 decimals)
• 60 integer bits = up to ~1.15 × 10¹⁸ before the decimal point
• Unsigned = no negative numbers (there's SD59x18 for signed)

// UD60x18 is just a wrapper around uint256
type UD60x18 is uint256;

// The "ud" function wraps a raw uint256 into this type
function ud(uint256 x) pure returns (UD60x18) {
    return UD60x18.wrap(x);
}

// The "unwrap" function gets the raw uint256 back
function unwrap(UD60x18 x) pure returns (uint256) {
    return UD60x18.unwrap(x);
}

Think of UD60x18 as a "labeled box" that says "I'm a fixed-point number — use special math on me".

The Three-Step Pattern

Every PRBMath computation follows the same workflow:

import {UD60x18, ud, unwrap, exp, mul} from "prb-math/UD60x18.sol";

// STEP 1: WRAP — convert raw numbers to fixed-point
UD60x18 base  = ud(0.5e18);   // 0.5 in fixed-point
UD60x18 rate  = ud(0.08e18);  // 0.08 in fixed-point
UD60x18 supply = ud(10e18);   // 10 in fixed-point

// STEP 2: MATH — compute using library functions
UD60x18 exponent = mul(rate, supply);  // 0.08 × 10 = 0.8
UD60x18 growth   = exp(exponent);       // e^0.8 ≈ 2.2255
UD60x18 price    = mul(base, growth);   // 0.5 × 2.2255 ≈ 1.1128

// STEP 3: UNWRAP — get raw uint256 back
uint256 priceWei = unwrap(price);       // ≈ 1_112_749_685_157_800_000

PRBMath Cheat Sheet

Hands-On: Build a Linear Price Function

Let's build price(s) = 0.2 · s + 1 using PRBMath.

import {UD60x18, ud, unwrap, mul} from "prb-math/UD60x18.sol";

contract LinearPrice {
    UD60x18 public immutable slope; // m = 0.2
    UD60x18 public immutable base;  // b = 1.0

    constructor() {
        slope = ud(0.2e18);  // 0.2 in fixed-point
        base  = ud(1e18);    // 1.0 in fixed-point
    }

    function price(uint256 supply) public view returns (uint256) {
        // Step 1: WRAP supply
        UD60x18 s = ud(supply * 1e18);

        // Step 2: MATH — m * s + b
        UD60x18 ms = mul(slope, s);     // 0.2 × supply
        UD60x18 result = ms + base;     // + operator works for UD60x18 addition!

        // Step 3: UNWRAP
        return unwrap(result);
    }
}

// price(0)  → 1.0e18  (= 1.0 ETH)
// price(10) → 3.0e18  (= 3.0 ETH)
// price(20) → 5.0e18  (= 5.0 ETH)

Hands-On: Build an Exponential Price Function

price(s) = 0.5 · e^0.08·s — the "FOMO curve".

import {UD60x18, ud, unwrap, mul, exp} from "prb-math/UD60x18.sol";

contract ExpoPrice {
    UD60x18 public immutable a; // base = 0.5
    UD60x18 public immutable k; // rate = 0.08

    constructor() {
        a = ud(0.5e18);   // 0.5
        k = ud(0.08e18);  // 0.08
    }

    function price(uint256 supply) public view returns (uint256) {
        // 1. WRAP
        UD60x18 s = ud(supply * 1e18);

        // 2. MATH
        UD60x18 ks    = mul(k, s);       // 0.08 × supply
        UD60x18 expKs = exp(ks);          // e^(0.08 × supply)
        UD60x18 result = mul(a, expKs);   // 0.5 × e^(0.08 × supply)

        // 3. UNWRAP
        return unwrap(result);
    }
}

// price(0)  → 0.5e18    (= 0.50 ETH  — cheap!)
// price(10) → 1.1127e18 (= 1.11 ETH)
// price(50) → 27.29e18  (= 27.29 ETH — expensive!)
// price(100)→ 1490.47e18(= 1490 ETH — insane!)

Hands-On: Build a Logarithmic Price Function

price(s) = 2 · ln(s + 1) — the "fair growth" curve.

import {UD60x18, ud, unwrap, mul, ln} from "prb-math/UD60x18.sol";

contract LogPrice {
    UD60x18 public immutable k; // scale = 2.0
    UD60x18 public immutable c; // shift = 1.0 (avoids ln(0))

    constructor() {
        k = ud(2e18);
        c = ud(1e18);
    }

    function price(uint256 supply) public view returns (uint256) {
        // 1. WRAP
        UD60x18 s = ud(supply * 1e18);

        // 2. MATH
        UD60x18 inner = s + c;            // supply + 1 (avoids ln(0)!)
        UD60x18 logVal = ln(inner);        // ln(supply + 1)
        UD60x18 result = mul(k, logVal);   // 2 × ln(supply + 1)

        // 3. UNWRAP
        return unwrap(result);
    }
}

// price(0)  → 0.00e18  (= 0 ETH — free!)
// price(1)  → 1.39e18  (= 1.39 ETH — quick rise)
// price(10) → 4.79e18  (= 4.79 ETH)
// price(100)→ 9.23e18  (= 9.23 ETH — barely moved!)
// price(1000)→13.82e18 (= 13.82 ETH — still gentle)

Common PRBMath Mistakes

Part II: PRBMath Internals

How the Math Actually Works Under the Hood

Now that we know how to USE PRBMath, let's open the hood and read the source code.

What We'll Cover

Part 6: Repo Architecture

PRBMath v4 — github.com/PaulRBerg/prb-math

Two Type Families

type UD60x18 is uint256;
// 1.0 = 1_000_000_000_000_000_000
// stored as a plain uint256

type SD59x18 is int256;
// -1.0 = -1_000_000_000_000_000_000
// uses two's complement

File Structure (v4)

prb-math/
├── src/
│   ├── Common.sol          ← mulDiv, mulDiv18, sqrt (shared)
│   ├── ud60x18/
│   │   ├── Casting.sol     ← wrap(), unwrap(), ud()
│   │   ├── Constants.sol   ← UNIT, MAX, PI, E
│   │   ├── Conversions.sol ← convert(), from UD to SD
│   │   ├── Errors.sol      ← PRBMath_UD60x18_*
│   │   ├── Helpers.sol     ← add, sub (using + -)
│   │   ├── Math.sol        ← mul, div, exp, exp2, ln,
│   │   │                      log2, log10, sqrt, pow, avg
│   │   └── ValueType.sol   ← type UD60x18 is uint256
│   └── sd59x18/            ← (mirrors ud60x18 structure)
└── test/

The UNIT Constant

/// @dev The unit number, which gives the decimal precision of UD60x18.
uint256 constant uUNIT = 1e18;
UD60x18 constant UNIT = UD60x18.wrap(1e18);

Every function in PRBMath revolves around this single idea:

real_value = stored_uint256 / 10¹⁸

Part 7: mul() — Phantom Overflow

The simplest operation reveals the deepest trick.

The Problem with Naive Multiply

// ❌ WRONG — overflows!
function naiveMul(UD60x18 x, UD60x18 y) pure returns (UD60x18) {
    return UD60x18.wrap(
        UD60x18.unwrap(x) * UD60x18.unwrap(y) / 1e18
    );
}

// x = 2.0 → stored as 2e18
// y = 3.0 → stored as 3e18
// x * y = 2e18 * 3e18 = 6e36  ← PHANTOM OVERFLOW!
// 6e36 / 1e18 = 6e18 = 6.0   ← correct answer…
//                              IF it doesn't overflow first

PRBMath's mul() — Actual Source

/// @notice Multiplies two UD60x18 numbers together,
/// returning a new UD60x18 number.
function mul(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
    result = wrap(mulDiv18(unwrap(x), unwrap(y)));
}

Just 1 line! The real work is in mulDiv18.

Part 8: div() — Scale First

Division has the opposite problem of multiplication.

The Problem with Naive Division

// ❌ WRONG — loses ALL precision!
function naiveDiv(UD60x18 x, UD60x18 y) pure returns (UD60x18) {
    return UD60x18.wrap(
        UD60x18.unwrap(x) / UD60x18.unwrap(y)
    );
}

// x = 1.0 → stored as 1e18
// y = 3.0 → stored as 3e18
// x / y = 1e18 / 3e18 = 0     ← integer division truncates!
// Expected: 0.333...e18

PRBMath's div() — Scale First

/// @notice Divides two UD60x18 numbers, returning a UD60x18 number.
function div(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
    result = wrap(mulDiv(unwrap(x), uUNIT, unwrap(y)));
}

Trick: compute (x × 1e18) / y instead of x / y.

Part 9: mulDiv() — The 512-bit Heart

The most important function in PRBMath.

~80 lines of Yul assembly that make everything else possible.

mulDiv — What It Computes

mulDiv(x, y, d) = ⌊(x × y) / d⌋

…without intermediate overflow, even when x × y exceeds uint256!

Based on Remco Bloemen's algorithm & "Hacker's Delight" by Henry S. Warren.

mulDiv — Step 1: 512-bit Product

// Compute the 512-bit product [prod1 prod0]
uint256 prod0;  // low  256 bits of x * y
uint256 prod1;  // high 256 bits of x * y
assembly {
    let mm := mulmod(x, y, not(0))  // x*y mod 2^256
    prod0 := mul(x, y)              // low bits (wraps)
    prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}

mulDiv — Step 2: Fast Path

// Handle cases where product fits in 256 bits
if (prod1 == 0) {
    return prod0 / denominator;
}

The expensive path (below) only runs when values are large enough to actually overflow 256 bits.

mulDiv — Step 3: 512-bit Division

When prod1 > 0, things get interesting:

// Make sure the result is less than 2^256
require(denominator > prod1);

// Subtract 256 bit number from 512 bit number
assembly {
    // Compute remainder using mulmod
    let remainder := mulmod(x, y, denominator)
    // Subtract remainder from 512-bit product
    prod1 := sub(prod1, gt(remainder, prod0))
    prod0 := sub(prod0, remainder)
}

mulDiv — Step 4: Factor Out Powers of 2

// Factor powers of two out of denominator
// Compute largest power of two divisor of denominator.
uint256 twos = denominator & (~denominator + 1);
assembly {
    // Divide denominator by twos
    denominator := div(denominator, twos)
    // Divide [prod1:prod0] by twos
    prod0 := div(prod0, twos)
    // Flip twos such that it is 2^256 / twos.
    // If twos is zero, then it becomes one.
    twos := add(div(sub(0, twos), twos), 1)
}
// Shift bits from prod1 into prod0
prod0 |= prod1 * twos;

mulDiv — Step 5: Modular Inverse

// Compute the modular inverse of denominator mod 2^256
// using Newton-Raphson iteration.
// Start with a seed that is correct for four bits.
uint256 inverse = (3 * denominator) ^ 2;

// Use Newton-Raphson to double precision each step
inverse *= 2 - denominator * inverse; // 8  bits
inverse *= 2 - denominator * inverse; // 16 bits
inverse *= 2 - denominator * inverse; // 32 bits
inverse *= 2 - denominator * inverse; // 64 bits
inverse *= 2 - denominator * inverse; // 128 bits
inverse *= 2 - denominator * inverse; // 256 bits

// Final result
result = prod0 * inverse;

mulDiv — Complete Picture

Part 10: exp() — Computing e^x

The hardest function. No Taylor series — too expensive.

exp() Strategy: Change of Base

PRBMath does not compute e^x directly. Instead:

e^x = 2^{x × log₂(e)}

function exp(UD60x18 x) pure returns (UD60x18 result) {
    // x_192x64 = x * log2(e), scaled to 192.64 format
    // then call exp2()
    result = wrap(exp2(mulDiv18(unwrap(x), uLOG2_E)));
}

exp2() — The Bit Decomposition Trick

To compute 2y, split y into integer + fraction:

2^5.75 = 2⁵ × 2^0.75

// Just a bit shift!
result = 1 << integerPart;
// 2^5 = 32 = 1 << 5
// Cost: 3 gas (SHL opcode)

// 0.75 in binary = 0.110000...
// 2^0.75 = 2^0.5 × 2^0.25
//        = √2   × ⁴√2

exp2() — Actual Code (Simplified)

// The fractional part in 192.64-bit fixed-point
uint256 x = xValue;  // the fractional bits

// For each bit position, multiply by precomputed 2^(1/2^n)
if (x & 0x8000000000000000 > 0)    // bit 63: 2^(1/2)
    result = (result * 0x16A09E667F3BCC909) >> 64;
if (x & 0x4000000000000000 > 0)    // bit 62: 2^(1/4)
    result = (result * 0x1306FE0A31B7152DF) >> 64;
if (x & 0x2000000000000000 > 0)    // bit 61: 2^(1/8)
    result = (result * 0x1172B83C7D517ADCE) >> 64;
if (x & 0x1000000000000000 > 0)    // bit 60: 2^(1/16)
    result = (result * 0x10B5586CF9890F62A) >> 64;
// ... continues for all 64 bits ...
if (x & 0x2 > 0)                   // bit 1: 2^(1/2^63)
    result = (result * 0x10000000000000001) >> 64;
if (x & 0x1 > 0)                   // bit 0: 2^(1/2^64)
    result = (result * 0x10000000000000001) >> 64;

Part 11: ln() — Binary Logarithm

Same trick in reverse: ln(x) = log₂(x) / log₂(e)

ln() → log2() → Bit Extraction

function ln(UD60x18 x) pure returns (UD60x18 result) {
    // ln(x) = log2(x) / log2(e)
    // But we compute: log2(x) * (1/log2(e)) = log2(x) * ln(2)
    unchecked {
        result = wrap(mulDiv(log2(unwrap(x)), uLOG2_E_INV, uUNIT));
    }
}

Just like exp() delegates to exp2(), ln() delegates to log2().

log2() — Integer Part

// n = integer part of log2(x)
// Find the highest set bit using binary search
uint256 n;
if (xUint >= 2**128) { xUint >>= 128; n += 128; }
if (xUint >= 2**64)  { xUint >>= 64;  n += 64;  }
if (xUint >= 2**32)  { xUint >>= 32;  n += 32;  }
if (xUint >= 2**16)  { xUint >>= 16;  n += 16;  }
if (xUint >= 2**8)   { xUint >>= 8;   n += 8;   }
if (xUint >= 2**4)   { xUint >>= 4;   n += 4;   }
if (xUint >= 2**2)   { xUint >>= 2;   n += 2;   }
if (xUint >= 2**1)   { n += 1; }

log2() — Fractional Part

// y = x / 2^n  (normalize to range [1, 2))
// Now compute fractional bits by repeated squaring
int256 resultInt;
// ...after integer part calculation...

// Compute 64 fractional bits, one at a time
y = (y * y) >> 127;        // square and check
if (y >= 2 * UNIT) {       // if ≥ 2.0...
    resultInt |= (1 << 63); // ...set bit 63
    y >>= 1;               // normalize back
}
y = (y * y) >> 127;
if (y >= 2 * UNIT) {
    resultInt |= (1 << 62); // set bit 62
    y >>= 1;
}
// ... repeat for all 64 bits ...

Part 12: sqrt() — Newton's Method

The oldest algorithm in PRBMath — over 3,000 years old.

sqrt() — The Babylonian Method

To find √x, repeatedly improve a guess: g' = (g + x/g) / 2

function sqrt(uint256 x) pure returns (uint256 result) {
    if (x == 0) return 0;

    // Initial guess: closest power of 2 to √x
    // (uses the same binary search as log2)
    result = 1;
    uint256 xAux = x;
    if (xAux >= 2**128) { xAux >>= 128; result <<= 64; }
    if (xAux >= 2**64)  { xAux >>= 64;  result <<= 32; }
    if (xAux >= 2**32)  { xAux >>= 32;  result <<= 16; }
    if (xAux >= 2**16)  { xAux >>= 16;  result <<= 8; }
    if (xAux >= 2**8)   { xAux >>= 8;   result <<= 4; }
    if (xAux >= 2**4)   { xAux >>= 4;   result <<= 2; }
    if (xAux >= 2**2)   { result <<= 1; }

    // Newton-Raphson: 7 iterations (doubles bits each time)
    result = (result + x / result) >> 1; // ~8 bits
    result = (result + x / result) >> 1; // ~16 bits
    result = (result + x / result) >> 1; // ~32 bits
    result = (result + x / result) >> 1; // ~64 bits
    result = (result + x / result) >> 1; // ~128 bits
    result = (result + x / result) >> 1; // ~256 bits
    result = (result + x / result) >> 1; // exact

    // Round down
    if (result > x / result) result = x / result;
}

sqrt() for UD60x18 — Scale Adjustment

/// @notice Calculates the square root of x using the
/// Babylonian method.
function sqrt(UD60x18 x) pure returns (UD60x18 result) {
    uint256 xUint = unwrap(x);
    if (xUint > uMAX_UD60x18 / uUNIT) revert ...;
    // Multiply by UNIT (1e18) for scale adjustment,
    // then take integer sqrt
    result = wrap(prbSqrt(xUint * uUNIT));
}

Part 13: pow() & Gas Costs

Putting it all together.

pow() — Just exp(y × ln(x))

/// @notice Raises x to the power of y.
function pow(UD60x18 x, UD60x18 y)
    pure returns (UD60x18 result)
{
    uint256 xUint = unwrap(x);
    uint256 yUint = unwrap(y);

    if (xUint == 0) return y == ZERO ? UNIT : ZERO;
    if (yUint == uUNIT) return x;

    // x^y = exp(y * ln(x))
    // = exp2(y * log2(x))    ← base-2 version
    result = exp2(mul(y, log2(x)));
}

Gas Cost Summary

Techniques You've Learned

How Everything Connects

  pow(x, y) ──→ exp2( y × log2(x) )
                  │         │
                  ▼         ▼
  exp(x) ───→ exp2()    log2() ◄──── ln(x)
                │           │
          [bit decomp]  [repeated squaring]
                │           │
                ▼           ▼
            mulDiv()    mulDiv()
              │
        [512-bit product]
        [modular inverse]
        [Newton-Raphson]

  mul(x,y) ──→ mulDiv18(x, y)  ──→ mulDiv(x, y, 1e18)
  div(x,y) ──→ mulDiv(x, 1e18, y)
  sqrt(x)  ──→ Newton-Raphson + mulDiv for scale
        

mulDiv() is the foundation. Every function ultimately relies on it.

Code Reading Exercises

Further Reading

• PRBMath source code (v4)
• Remco Bloemen — "Full Mul-Div" — the mulDiv algorithm origin
• Babylonian / Newton's method for square roots
• Henry S. Warren, Hacker's Delight — the bible of bit manipulation
• Uniswap v3 TickMath — uses the same exp/log techniques

Putting It All Together

Exercise: Can You Read This?

import {UD60x18, ud, unwrap, mul, div, exp} from "prb-math/UD60x18.sol";

contract MysteryPrice {
    function getPrice(uint256 supply) external pure returns (uint256) {
        UD60x18 s = ud(supply * 1e18);
        UD60x18 k = ud(0.05e18);
        UD60x18 a = ud(2e18);
        UD60x18 b = ud(1e18);

        UD60x18 expPart = exp(mul(k, s));
        UD60x18 result  = mul(a, expPart) + b;

        return unwrap(result);
    }
}

Questions:

• What formula does this implement? (Hint: 2·e^0.05s + ???)
• What is the price at supply = 0?
• Is the price at supply = 100 higher or lower than 1000 ETH?

Playground: Build Your Own Curve

Drag the sliders to design a curve. What economic personality does it create?

• Set n = 0.5 for √x  |  n = 1 for linear  |  n = 2 for quadratic
• a scales the price  |  b sets a floor price

Formula: P = a · xⁿ + b. This single family covers most DeFi curves.

Resources

• PRBMath GitHub: github.com/PaulRBerger/prb-math
• PRBMath UD60x18 API: Math.sol source
• Fixed-Point Tutorial: Solidity docs
• Desmos Graph Calculator: desmos.com/calculator — practice graphing!
• Next: Workshop 007 — Bonding Curves

Q&A

Quick check — can you answer these?

• Why can't Solidity do 0.5 * 3 natively?
• What does ud(5e18) represent?
• Why do we add + c before calling ln()?
• What's the difference between a linear and exponential curve?