Stream prices

You sign your ladder and send it over a WebSocket. Biconomy writes it onchain and pays the gas.

Environment	WebSocket	Chains
Staging	`wss://propamm-staging.biconomy.io/v1/ws`	Base Sepolia (84532), mintable test tokens
Production	`wss://propamm.biconomy.io/v1/ws`	Base (8453)

Send your API key in the x-api-key header of the connection request. Without a valid key the server refuses the connection with HTTP 401. One signer per connection. Ladders for several chains can share it.

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

Response	Meaning
`{ "type": "ack" }`	accepted and stored
`{ "type": "error", "code": "...", "message": "..." }`	rejected; your last accepted ladder stays live until it expires

Messages

Type	Mode	Carries	Send
`price-ladder`	Rewrite	sizes and prices for one direction	on every price change
`offsets`	Reprice	sizes, a discount per size, optional drift, for one direction	once, then when the shape changes
`anchor`	Reprice	the reference price of every pair you quote, both directions, under one signature	on every price change
`board-controls`	both	the protections, see Risk and inventory	once, then when the settings change

Rewrite sends the whole ladder on every update. Reprice sends the ladder once, then a single price number on every update.

In Reprice mode each step prices at the anchor minus its discount.

Offsets field	Meaning	Example
`offsetPpm`	discount from the anchor, in parts per million	`1000` = 10 bps
`driftPpmPerSecond`	extra discount per second since the anchor’s `timestampMs`; `0` disables	`10` = 1 bp per second

An anchor message holds one entry per pair, up to 32. Each entry prices both directions of its pair: the direction you sign at price, the reverse at 1e36 / price, rounded down.

Anchor entry field	Meaning	Example
`tokenIn`, `tokenOut`	the direction `price` is quoted for	WETH, USDC
`price`	1e18-scaled `tokenOut` per `tokenIn`	`2000e6` for WETH (18) to USDC (6)
`timestampMs`	unix milliseconds you priced it; drift counts from here; must increase per pair	`Date.now()`
`ttl`	seconds the anchor lives after `timestampMs`, at most 3600	`15`
`skewPpm`	extra discount on the `tokenIn` to `tokenOut` side	`0`
`reverseSkewPpm`	extra discount on the `tokenOut` to `tokenIn` side	`200` = 2 bps

Common fields

Field	Meaning
`mm`	your signing address
`provider`	your provider contract (`price-ladder` and `offsets`)
`tokenIn`, `tokenOut`	the direction; the reverse direction is a separate ladder
`nonce`	increases with every message, see below (`price-ladder`, `offsets`, `board-controls`)
`timestampMs`	unix milliseconds you priced it, at most 30 s ahead and not after `expiresAt`; age fade counts from here (`price-ladder`)
`expiresAt`	unix seconds, at most 1 hour ahead (`price-ladder`, `offsets`, `board-controls`)
`signature`	EIP-712 by `mm`, domain `PropAMMExecutor` version `2`, verifying contract = the executor
`chainId`	the chain the ladder lives on

Unit	Rule	Example
size	cumulative, `tokenIn` smallest units	2 WETH = `2000000000000000000`
price	1e18-scaled `tokenOut` per `tokenIn`, smallest units, decimals folded in	WETH (18) to USDC (6) at 2,000 = `2000 * 1e18 * 10^(6-18)` = `2000e6`

Exact structs and wire formats are in the Message reference.

Nonces and expiry

Message	Ordering key	Typical expiry	Resets taken steps
`price-ladder`	depth `nonce`, shared with `offsets`	`expiresAt` 10 to 30 s ahead	yes
`offsets`	depth `nonce`, shared with `price-ladder`	`expiresAt` up to 1 hour ahead	yes
`anchor`	`timestampMs`, per pair	`ttl` 10 to 30 s	no
`board-controls`	its own `nonce`	`expiresAt` a few minutes ahead; a commit deadline only, the controls then hold until a higher nonce	no

A nonce or timestampMs at or below the last accepted one returns STALE_NONCE. Unix milliseconds work as nonces.

Runnable client

Reprice mode on Base Sepolia: one offsets message for WETH to USDC, then every second one anchor message whose single entry prices both directions of the pair. Replace yourPrice() with your engine’s price in raw units. To quote USDC to WETH as well, sign an offsets message for that direction; the same anchor entry prices it.

import WebSocket from "ws";
import { privateKeyToAccount } from "viem/accounts";

const ENDPOINT = "wss://propamm-staging.biconomy.io/v1/ws";
const CHAIN_ID = 84532;
const EXECUTOR = "0x0000006f9bBA066e4efda2e0CAbE4FF8cf9030aC"; // same address on every chain
const PROVIDER = "0xYourProviderContract";
const TOKEN_IN = "0x8b414aD7005EeFd315aF2A16538885Eae229bab7";  // MockWETH, 18 decimals
const TOKEN_OUT = "0xAbbdbbbd6d56593A9c5656c06cB30D61E4a544Df"; // MockUSDC, 18 decimals

const account = privateKeyToAccount(process.env.MM_SIGNER_KEY as `0x${string}`);
const domain = { name: "PropAMMExecutor", version: "2", chainId: CHAIN_ID, verifyingContract: EXECUTOR } as const;
const types = {
  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[]" }],
} as const;

const now = () => BigInt(Math.floor(Date.now() / 1000));
// bigint fields go on the wire as decimal strings; chainId stays a number.
const frame = (o: unknown) => JSON.stringify(o, (_, v) => (typeof v === "bigint" ? v.toString() : v));

function yourPrice(): bigint {
  return 2000n * 10n ** 18n; // 2000 tokenOut per tokenIn, both 18 decimals
}

async function sendOffsets(ws: WebSocket) {
  const message = {
    mm: account.address, provider: PROVIDER, tokenIn: TOKEN_IN, tokenOut: TOKEN_OUT,
    rungs: [
      { size: 1n * 10n ** 18n, offsetPpm: 1000n },  // first 1 tokenIn at 10 bps below the anchor
      { size: 3n * 10n ** 18n, offsetPpm: 2500n },  // next 2 tokenIn at 25 bps below
    ],
    nonce: BigInt(Date.now()),          // depth nonce, shared with price-ladder
    expiresAt: now() + 1800n,           // the shape lives 30 minutes
    driftPpmPerSecond: 10n,             // widen 1 bp per second of anchor age
  };
  const signature = await account.signTypedData({ domain, types, primaryType: "OffsetLadder", message });
  ws.send(frame({ type: "offsets", payload: { ...message, signature, chainId: CHAIN_ID } }));
}

let lastTimestampMs = 0n;

async function sendAnchors(ws: WebSocket) {
  const t = BigInt(Date.now());
  lastTimestampMs = t > lastTimestampMs ? t : lastTimestampMs + 1n; // strictly increasing per pair
  const entries = [
    {
      tokenIn: TOKEN_IN, tokenOut: TOKEN_OUT,
      price: yourPrice(),                  // TOKEN_IN to TOKEN_OUT; the reverse prices at 1e36 / price
      timestampMs: lastTimestampMs,        // drift counts from here
      ttl: 15n,                            // the pair stops quoting 15 s after this if no newer anchor lands
      skewPpm: 0n,                         // extra discount on TOKEN_IN to TOKEN_OUT
      reverseSkewPpm: 0n,                  // extra discount on TOKEN_OUT to TOKEN_IN
    },
    // one entry per further pair you quote, up to 32 per message
  ];
  const message = { mm: account.address, entries };
  const signature = await account.signTypedData({ domain, types, primaryType: "AnchorBatch", message });
  ws.send(frame({ type: "anchor", payload: { ...message, signature, chainId: CHAIN_ID } }));
}

const ws = new WebSocket(ENDPOINT, { headers: { "x-api-key": process.env.PROPAMM_API_KEY as string } });
ws.on("message", (m) => console.log(m.toString()));
ws.on("open", async () => {
  ws.send(JSON.stringify({ type: "subscribe", data: { type: "price-ledger", mm: account.address } }));
  await sendOffsets(ws);                                   // once, then when sizes, offsets or drift change
  setInterval(() => void sendAnchors(ws), 1000);           // every pair's price, every second
});
ws.on("close", () => process.exit(1));                     // let a supervisor restart for a clean reconnect

For Rewrite, sign PriceLadder (levels of { size, price }, timestampMs set to when you priced it, primaryType: "PriceLadder") on every tick and send it as type: "price-ladder". A client that samples a pricing curve into a ladder is in curve-maker-reference.ts. In Rewrite each direction of a pair is a separate ladder.

Common errors

Code	Fix
`INVALID_SIGNATURE`	domain `PropAMMExecutor`, version `2`, the right `chainId`, the executor address
`STALE_NONCE`	nonces must increase per ladder; anchor `timestampMs` must increase per pair
`UPDATE_EXPIRED`	`expiresAt` or an anchor’s `timestampMs / 1000 + ttl` is in the past; check clock skew and units
`UNREGISTERED_MARKET_MAKER`, `UNSUPPORTED_PAIR`, `PROVIDER_MISMATCH`	signer, pair or provider differ from your registration
`NOT_SUBSCRIBED`	send the subscribe frame first
`RATE_LIMITED`	over 300 messages per second on one connection

Full list in the Message reference.

Limits

Limit	Value
Messages per connection	300 per second
Frame size	64 KB
Steps per ladder	20
Entries per `anchor` message	32, one per pair
`expiresAt`	at most 1 hour ahead
Anchor `ttl`	at most 3600 s
Idle timeout	60 s without inbound traffic

Getting Started

Market Makers

Aggregators

Reference

Messages

Common fields

Nonces and expiry

Runnable client

Common errors

Limits

​Connect and subscribe

​Messages

​Common fields

​Nonces and expiry

​Runnable client

​Common errors

​Limits

Connect and subscribe

Messages

Common fields

Nonces and expiry

Runnable client

Common errors

Limits