Message reference

struct Level {
    uint256 size;   // cumulative tokenIn volume available up to this level
    uint256 price;  // 1e18-scaled tokenOut per tokenIn for volume landing in this level
}

struct PriceLadder {
    address mm;        // signing address; the board key
    address provider;  // the IMMProvider contract that fills it; signed, so callers cannot swap it
    address tokenIn;
    address tokenOut;
    Level[] levels;    // ascending cumulative sizes, prices non-improving with depth
    uint256 nonce;     // depth nonce, strictly increasing per (mm, tokenIn, tokenOut)
    uint256 timestampMs; // unix milliseconds the maker priced it; the board ages from here
    uint256 expiresAt; // unix seconds
}

struct Rung {
    uint256 size;       // cumulative tokenIn volume available up to this rung
    uint256 offsetPpm;  // discount below the anchor, parts per million
}

struct OffsetLadder {
    address mm;
    address provider;
    address tokenIn;
    address tokenOut;
    Rung[] rungs;               // ascending cumulative sizes, offsets non-decreasing with depth
    uint256 nonce;              // depth nonce, shared with price ladders for the same board
    uint256 expiresAt;          // unix seconds
    uint256 driftPpmPerSecond;  // offset widening per second of anchor age; 0 for none
}

struct AnchorEntry {
    address tokenIn;        // the direction `price` is quoted for
    address tokenOut;
    uint256 price;          // 1e18-scaled tokenOut per tokenIn
    uint256 timestampMs;    // unix milliseconds the maker priced this anchor; strictly increasing per pair
    uint256 ttl;            // seconds the anchor lives after timestampMs
    uint256 skewPpm;        // extra discount on the tokenIn -> tokenOut side, ppm
    uint256 reverseSkewPpm; // extra discount on the tokenOut -> tokenIn side, ppm
}

struct AnchorBatch {
    address mm;             // signing address; the board key for every entry
    AnchorEntry[] entries;  // one per pair
}

struct BoardControls {
    address mm;
    address tokenIn;
    address tokenOut;
    uint256 nonce;                  // controls nonce, its own sequence
    uint256 blockCap;               // most tokenIn one block may fill from this board; 0 for no cap
    uint256 widenPpmPerSqrtSecond;  // extra discount per square root of a second of quote age; 0 for none
    uint256 premiumPpm;             // extra discount inside the premium window; 0 for none
    uint256 premiumBlocks;          // blocks the premium covers after a depth, anchor or controls commit; 0 for none
    uint256 expiresAt;              // unix seconds; the last second this message can be committed
}

PriceLadder(address mm,address provider,address tokenIn,address tokenOut,Level[] levels,uint256 nonce,uint256 timestampMs,uint256 expiresAt)Level(uint256 size,uint256 price)
OffsetLadder(address mm,address provider,address tokenIn,address tokenOut,Rung[] rungs,uint256 nonce,uint256 expiresAt,uint256 driftPpmPerSecond)Rung(uint256 size,uint256 offsetPpm)
AnchorBatch(address mm,AnchorEntry[] entries)AnchorEntry(address tokenIn,address tokenOut,uint256 price,uint256 timestampMs,uint256 ttl,uint256 skewPpm,uint256 reverseSkewPpm)
BoardControls(address mm,address tokenIn,address tokenOut,uint256 nonce,uint256 blockCap,uint256 widenPpmPerSqrtSecond,uint256 premiumPpm,uint256 premiumBlocks,uint256 expiresAt)

const types = {
  Level:        [{ name: "size", type: "uint256" }, { name: "price", type: "uint256" }],
  PriceLadder:  [
    { name: "mm", type: "address" }, { name: "provider", type: "address" },
    { name: "tokenIn", type: "address" }, { name: "tokenOut", type: "address" },
    { name: "levels", type: "Level[]" }, { name: "nonce", type: "uint256" },
    { name: "timestampMs", type: "uint256" }, { name: "expiresAt", type: "uint256" },
  ],
  Rung:         [{ name: "size", type: "uint256" }, { name: "offsetPpm", type: "uint256" }],
  OffsetLadder: [
    { name: "mm", type: "address" }, { name: "provider", type: "address" },
    { name: "tokenIn", type: "address" }, { name: "tokenOut", type: "address" },
    { name: "rungs", type: "Rung[]" }, { name: "nonce", type: "uint256" },
    { name: "expiresAt", type: "uint256" }, { name: "driftPpmPerSecond", type: "uint256" },
  ],
  AnchorEntry:  [
    { name: "tokenIn", type: "address" }, { name: "tokenOut", type: "address" },
    { name: "price", type: "uint256" }, { name: "timestampMs", type: "uint256" },
    { name: "ttl", type: "uint256" }, { name: "skewPpm", type: "uint256" },
    { name: "reverseSkewPpm", type: "uint256" },
  ],
  AnchorBatch:  [{ name: "mm", type: "address" }, { name: "entries", type: "AnchorEntry[]" }],
  BoardControls: [
    { name: "mm", type: "address" }, { name: "tokenIn", type: "address" },
    { name: "tokenOut", type: "address" }, { name: "nonce", type: "uint256" },
    { name: "blockCap", type: "uint256" }, { name: "widenPpmPerSqrtSecond", type: "uint256" },
    { name: "premiumPpm", type: "uint256" }, { name: "premiumBlocks", type: "uint256" },
    { name: "expiresAt", type: "uint256" },
  ],
} as const;
const domain = { name: "PropAMMExecutor", version: "2", chainId, verifyingContract: executor };

anchor = entry.price on the signed direction, 1e36 / entry.price (rounded down) on the reverse
skew   = skewPpm on the signed direction, reverseSkewPpm on the reverse
age    = block.timestamp - timestampMs / 1000, in whole seconds
price  = anchor * (1e6 - offsetPpm - driftPpmPerSecond * age - skew) / 1e6, floored

{ "type": "subscribe", "data": { "type": "price-ledger", "mm": "0x1111111111111111111111111111111111111111" } }