Market Maker
Onboarding.

01 · OrientationArchitecture

The RFQ system is an off‑chain quoting network with on‑chain settlement. You connect to an indexer over WebSocket, receive request broadcasts, sign a quote with secp256k1, and return it. The taker submits the settlement transaction – not you.

Sequence view

Four actors, five messages, one transaction. Each lane is a role; left‑to‑right is time.

Two settlement paths

Since contract 0.1.0‑α.6 there are two settlement entrypoints. The signing primitive and wire shape are identical; the difference is who submits the transaction.

02Quick‑start checklist

Seven steps. Everything below the line is one‑time setup. Check them off as you go – progress is saved to this browser.

03 · SetupOne‑time setup, in detail

Generate a wallet

Standard Ethereum‑compatible secp256k1. Same private key, two address encodings.

from eth_account import Account
import bech32

account      = Account.create()
private_key  = account.key.hex()            # store securely

addr_bytes   = bytes.fromhex(account.address[2:])
inj_address  = bech32.bech32_encode("inj", bech32.convertbits(addr_bytes, 8, 5))

print(f"Private Key: {private_key}")
print(f"INJ Address: {inj_address}")

import { PrivateKey } from "@injectivelabs/sdk-ts";

const privateKey = PrivateKey.generate();
const injAddress = privateKey.toBech32();

console.log(`Private Key: ${privateKey.toHex()}`);
console.log(`INJ Address: ${injAddress}`);

Get whitelisted

Send your inj1… to the Injective team. The contract admin calls register_maker(maker: <your_addr>) to add you to the maker set.

You can confirm yourself at any point by querying list_makers on the contract – see the runbook for the exact cURL.

Grant authz permissions

The RFQ contract settles trades on your behalf using two narrow MsgGrants. The contract cannot move arbitrary funds – only the message types below, and only through its settlement handler.

Canonical grants, and why the working set differs

The complete grant surface the contract can exercise includes messages it rarely uses in practice. Reading the source:

• admin.md enumerates every MsgType the contract is capable of invoking on a granter's behalf.
• settlement.rs and authz.rs verify those grants at execution time.
• orderbook.rs calls MsgBatchUpdateOrders only on the retail side during the merge‑with‑book path.

The canonical list contains MsgWithdraw too, but the working testnet grant set in §05 of the runbook omits it — the current contract path doesn't exercise it, and granting it creates an unused attack surface. If you see unauthorized on a message type not listed in the runbook, cross‑check this paragraph before adding a new grant.

from google.protobuf import any_pb2
from pyinjective.core.broadcaster import MsgBroadcasterWithPk
from pyinjective.core.network  import Network
from pyinjective.proto.cosmos.authz.v1beta1 import authz_pb2, tx_pb2 as authz_tx

network = Network.testnet()

CONTRACT = "inj1qw7jk82hjvf79tnjykux6zacuh9gl0z0wl3ruk"  # testnet α.6

granted = [
    "/injective.exchange.v2.MsgPrivilegedExecuteContract",
    "/cosmos.bank.v1beta1.MsgSend",
]

# Permanent grant: leave expiration unset (expiration: null). msg_grant_generic
# forces a finite expiry that silently lapses and breaks the maker; AuthZ grants
# can be revoked any time, so no-expiry is the safe default.
def make_grant(granter, grantee, msg_type):
    authz = any_pb2.Any(
        type_url = "/cosmos.authz.v1beta1.GenericAuthorization",
        value    = authz_pb2.GenericAuthorization(msg=msg_type).SerializeToString(),
    )
    grant = authz_pb2.Grant()
    grant.authorization.CopyFrom(authz)            # no grant.expiration => never expires
    msg = authz_tx.MsgGrant(granter=granter, grantee=grantee)
    msg.grant.CopyFrom(grant)
    return msg

msgs = [make_grant(YOUR_INJ_ADDRESS, CONTRACT, m) for m in granted]

bc     = MsgBroadcasterWithPk.new_using_gas_heuristics(network=network, private_key=YOUR_PK)
result = await bc.broadcast(msgs)
print(f"TxHash: {result['txResponse']['txhash']}")

Fund your subaccount

Deposit USDC into your Injective exchange subaccount. This is the margin backing every quote you settle. Topping up is a standard MsgDeposit; no RFQ‑specific plumbing.

Testnet faucet

Drop 500 USDC + 2 INJ on a fresh wallet in one call. Paste an inj1… or an 0x… — same key, same cooldown. Once per 24 hours per address. Testnet only.

04 · ProtocolConnecting to MakerStream

Bidirectional WebSocket, gRPC‑web framed, protobuf payloads. The server drops idle connections, so you must ping roughly once per second from the moment you connect.

Protocol

gRPC‑web over WebSocket (subprotocol grpc-ws)

Serialization

Protobuf, binary framed

Framing

[1 byte flags][4 byte length BE][protobuf payload]

Keep‑alive

ping every ~1s – required

Service

injective_rfq_rpc.InjectiveRfqRPC

MM method

MakerStream (bidi)

Testnet URL

wss://rfq.ws.testnet.injective.network/injective_rfq_rpc.InjectiveRfqRPC/MakerStream

Animated ping / pong

Drives an idle connection indefinitely. Start pinging immediately after the socket opens.

Protobuf (maker side)

The canonical .proto is injective-rfq-toolkit/src/rfq_test/proto/injective_rfq_rpc.proto. Your bidi stream uses MakerStream:

service InjectiveRfqRPC {
  // bidi: receive requests, send quotes
  rpc MakerStream (stream MakerStreamStreamingRequest)
    returns (stream MakerStreamResponse);
  // also: TakerStream, Request, StreamRequest, Quote, StreamQuote …
}

What you send – a MakerStreamStreamingRequest with message_type = "ping" or "quote" (the nested RFQQuoteInputType carries the quote). What you receive – a MakerStreamResponse tagged by message_type:

Auth handshake (EIP‑712 v2)

Before the indexer streams RFQ requests it issues a one‑shot challenge against the bech32 you announced in connection metadata. Sign it with EIP‑712 v2 against the same domain separator as SignQuote — same EVM chain ID and same RFQ contract address — then reply with MakerAuth. Until you do, the stream stays open but no request events arrive.

Flow

MakerChallenge · indexer → MM

StreamAuthChallenge typed‑data layout

Final digest: keccak256(0x19 || 0x01 || domainSeparator || keccak256(typeHash ‖ encoded fields above)). Same domain separator as quotes — reuse the helper from §06.

MakerAuth · MM → indexer

Wrap it in MakerStreamStreamingRequest{ message_type:"auth", auth:MakerAuth{…} } and send.

from eth_utils import keccak
from eth_keys  import keys

STREAM_AUTH_CHALLENGE_TYPE = (
    b"StreamAuthChallenge(uint64 evmChainId,address maker,bytes32 nonce,uint64 expiresAt)"
)

def sign_maker_challenge_v2(*, private_key, contract_address, maker_inj,
                            evm_chain_id, nonce_hex, expires_at) -> str:
    nonce = bytes.fromhex(nonce_hex.removeprefix("0x"))
    assert len(nonce) == 32

    msg = b"".join((
        keccak(primitive=STREAM_AUTH_CHALLENGE_TYPE),
        _u(int(evm_chain_id), 8),
        _addr(bech32_to_evm(maker_inj)),
        nonce,                                         # raw bytes — not keccak-hashed
        _u(int(expires_at), 8),
    ))
    digest = keccak(primitive=b"\x19\x01"
        + domain_separator(evm_chain_id, contract_address)
        + keccak(primitive=msg))
    sig = keys.PrivateKey(bytes.fromhex(private_key.removeprefix("0x"))).sign_msg_hash(digest)
    v = sig.v - 27 if sig.v >= 27 else sig.v
    return "0x" + (sig.r.to_bytes(32, "big") + sig.s.to_bytes(32, "big") + bytes([v])).hex()

# Inside the maker stream loop:
if resp.message_type == "challenge":
    sig = sign_maker_challenge_v2(
        private_key=mm_pk, contract_address=CONTRACT,
        maker_inj=maker_addr,
        evm_chain_id=int(resp.challenge.evm_chain_id),
        nonce_hex=resp.challenge.nonce,
        expires_at=int(resp.challenge.expires_at),
    )
    await send_queue.put(MakerStreamStreamingRequest(
        message_type="auth",
        auth={"evm_chain_id": int(resp.challenge.evm_chain_id), "signature": sig},
    ))

import { keccak256, getBytes, toUtf8Bytes, SigningKey, hexlify } from "ethers";

const STREAM_AUTH_CHALLENGE_TYPE =
  "StreamAuthChallenge(uint64 evmChainId,address maker,bytes32 nonce,uint64 expiresAt)";

export function signMakerChallengeV2(args: {
  privateKey: string; contractAddress: string; makerInj: string;
  evmChainId: bigint; nonceHex: string; expiresAt: bigint;
}): string {
  const nonce = getBytes("0x" + args.nonceHex.replace(/^0x/, ""));
  if (nonce.length !== 32) throw new Error("nonce must be 32 bytes");

  const msgHash = getBytes(keccak256(cat(
    s(STREAM_AUTH_CHALLENGE_TYPE),
    u(args.evmChainId, 8),
    a(bech32ToEvm(args.makerInj)),
    nonce,                                            // raw bytes — not keccak-hashed
    u(args.expiresAt, 8),
  )));
  const ds = domainSeparator(args.evmChainId, args.contractAddress);
  const digest = keccak256(cat(getBytes("0x1901"), ds, msgHash));
  const key = new SigningKey("0x" + args.privateKey.replace(/^0x/, ""));
  const sig = key.sign(digest);
  return hexlify(cat(getBytes(sig.r), getBytes(sig.s), new Uint8Array([sig.yParity & 1])));
}

Helpers _u / _addr / bech32_to_evm / domain_separator / cat / s / a / u are the same primitives used in §06. Reuse them — don't redefine.

Reference end‑to‑end: examples/test_settlement.py for WebSocket/gRPC‑web and examples/test_settlement_grpc.py for native gRPC. Reusable MM examples: python WebSocket, python gRPC, go gRPC, typescript gRPC.

05Receiving RFQ requests

A request message looks like this. Everything you need to price, size and reference‑back is here.

{
  "message_type": "request",
  "request": {
    "client_id":       "7d7f8c28-1df6-40d3-bf29-0f9d2c2f3d10",
    "rfq_id":          1770848375348,
    "market_id":       "0x17ef48032cb2…eb00abe6",
    "direction":       "long",
    "margin":          "100",
    "quantity":        "10",
    "worst_price":     "100",
    "request_address": "inj1abc…xyz",
    "expiry":          1770848675348
  }
}

Your job is mechanical: decide your price, build a quote, sign it, return it.

06Building & signing quotes (EIP‑712 v2)

Decide your price

Taker going long → you fill the short side (sell higher). Taker going short → you fill the long side (buy lower). Your quoted maker_margin and maker_quantity may differ from the taker's – that's a partial fill.

What v2 binds (and what it doesn't)

v2 is EIP‑712 typed‑data. Two pieces compose into the digest:

• Domain separator — pins your signature to a specific chain + contract: { name: "RFQ", version: "1", chainId: <EVM chainId>, verifyingContract: <bech32→evm> }. Wire fields chain_id and contract_address are now informational — the domain separator is what binds them. The quote wire chain_id is still the Cosmos chain ID (injective-888 testnet, injective-1 mainnet), not 1439 or 1776.
• Message hash — a hand‑rolled SignQuote(...) type hash plus 16 fields, each encoded as a 32‑byte word. The first message field is evmChainId; it must match the domain chainId and the quote wire field evm_chain_id.

EVM chain ID is 1439 on testnet and 1776 on mainnet. Pull it from your environment config — don't hardcode.

SignQuote typed‑data layout

Final digest: keccak256(0x19 || 0x01 || domainSeparator || keccak256(typeHash ‖ encoded fields above)). Sign that with secp256k1 raw — no eth_sign, no personal_sign, no JSON canonicalisation.

Canonicalize every decimal before signing

One helper, applied to every decimal field — price, taker_margin, taker_quantity, maker_margin, maker_quantity, min_fill_quantity, trigger_price. Quantize to the market tick, strip trailing zeros, never emit scientific notation. The whole‑integer case (BTC perp, tick 1) is the one partners hit most often: a price computed with f"{mark:.1f}" or str(float(…)) carries a trailing .0 that the indexer rejects with not in canonical decimal form.

from decimal import Decimal, ROUND_DOWN

def to_canonical(x, tick) -> str:
    """Quantize x to the market tick and emit the indexer-canonical string."""
    return format(
        Decimal(str(x)).quantize(Decimal(str(tick)), rounding=ROUND_DOWN).normalize(),
        "f",   # plain notation, never scientific
    )

# 4.50     → "4.5"     (any market with a fractional tick)
# 76462.0  → "76462"   (BTC perp, tick "1")
# 110.00   → "110"     (INJ perp, tick "0.01")

import { Decimal } from "decimal.js"; // or your decimal lib of choice

export function toCanonical(x: string | number, tick: string): string {
  // Quantize down to the tick, then drop trailing zeros and the dangling "."
  const q = new Decimal(x).toDecimalPlaces(new Decimal(tick).decimalPlaces(), Decimal.ROUND_DOWN);
  const s = q.toFixed();                        // plain notation, no exponent
  return s.includes(".") ? s.replace(/0+$/, "").replace(/\.$/, "") : s;
}

// "4.50"     → "4.5"     (any market with a fractional tick)
// "76462.0"  → "76462"   (BTC perp, tick "1")
// "110.00"   → "110"     (INJ perp, tick "0.01")

Sign

# Recommended: use the helper that ships with injective-rfq-toolkit.
# It mirrors the indexer's `service/rfq/signature/eip712.go` byte-for-byte.
from rfq_test.crypto.eip712 import sign_quote_v2

sig = sign_quote_v2(
    private_key                  = MM_PRIVATE_KEY,
    evm_chain_id                 = 1439,                              # testnet (mainnet=1776)
    verifying_contract_bech32    = CONTRACT_ADDRESS,                # bech32; bound via domain
    market_id                    = market_id,
    rfq_id                       = int(rfq_id),
    taker                        = taker_address,
    direction                    = "long",
    taker_margin                 = "100",
    taker_quantity               = "10",
    maker                        = mm_address,
    maker_margin                 = "100",
    maker_quantity               = "10",
    price                        = "4.5",                              # tick‑quantized
    expiry_ms                    = int(time.time() * 1000) + 2_000,
    maker_subaccount_nonce       = 0,
    min_fill_quantity            = None,                              # sent as "0" in the digest
)

# sig is already "0x"-prefixed; sign_mode="v2" is required on the wire.
# The helper derives bindingKind from taker; don't pass binding_kind or nonce here.
await mm_ws.send_quote({..., "signature": sig, "sign_mode": "v2", "evm_chain_id": 1439})

// Standalone v2 signer — port of the indexer's eip712.go
import { keccak256, getBytes, toUtf8Bytes, SigningKey, hexlify } from "ethers";
import { bech32 } from "bech32";

const DOMAIN_TYPE = "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)";
const SIGN_QUOTE_TYPE =
  "SignQuote(uint64 evmChainId,string marketId,uint64 rfqId,address taker,uint8 takerDirection," +
  "string takerMargin,string takerQuantity,address maker,uint32 makerSubaccountNonce," +
  "string makerQuantity,string makerMargin,string price,uint8 expiryKind," +
  "uint64 expiryValue,string minFillQuantity,uint8 bindingKind)";

// 5-bit bech32 → 8-bit bytes (the canonical EVM form of an inj1… address)
function bech32ToEvm(addr: string): Uint8Array {
  const { prefix, words } = bech32.decode(addr);
  if (prefix !== "inj") throw new Error(`bad hrp ${prefix}`);
  return new Uint8Array(bech32.fromWords(words));
}
const u   = (n: bigint, w: number) => { const b = new Uint8Array(32); for (let i = w; i > 0; i--) { b[32 - (w - i + 1)] = Number(n & 0xffn); n >>= 8n; } return b; };
const s   = (x: string) => getBytes(keccak256(toUtf8Bytes(x)));
const a   = (b20: Uint8Array) => { const o = new Uint8Array(32); o.set(b20, 12); return o; };
const cat = (...xs: Uint8Array[]) => { const n = xs.reduce((t, x) => t + x.length, 0); const o = new Uint8Array(n); let p = 0; for (const x of xs) { o.set(x, p); p += x.length; } return o; };

function domainSeparator(evmChainId: bigint, contractBech32: string): Uint8Array {
  return getBytes(keccak256(cat(
    s(DOMAIN_TYPE), s("RFQ"), s("1"), u(evmChainId, 8), a(bech32ToEvm(contractBech32))
  )));
}

function signQuoteV2(q: SignQuoteInput, pkHex: string): string {
  const directionByte = q.direction === "long" ? 0n : 1n;
  const mfq = q.minFillQuantity ?? "0";
  const [expiryKind, expiryValue] = q.expiryHeight !== undefined
    ? [1n, BigInt(q.expiryHeight)] : [0n, BigInt(q.expiryMs!)];
  const msgHash = getBytes(keccak256(cat(
    s(SIGN_QUOTE_TYPE),
    u(BigInt(q.evmChainId), 8),
    s(q.marketId),                     u(BigInt(q.rfqId), 8),
    a(bech32ToEvm(q.taker)),           u(directionByte, 1),
    s(q.takerMargin),                  s(q.takerQuantity),
    a(bech32ToEvm(q.maker)),           u(BigInt(q.makerSubaccountNonce), 4),
    s(q.makerQuantity),                s(q.makerMargin),
    s(q.price),
    u(expiryKind, 1),                 u(expiryValue, 8),
    s(mfq),                            u(1n, 1),                                  // bindingKind = 1 (taker-specific)
  )));
  const ds = domainSeparator(BigInt(q.evmChainId), q.contractAddress);
  const digest = keccak256(cat(getBytes("0x1901"), ds, msgHash));
  const key  = new SigningKey("0x" + pkHex.replace(/^0x/, ""));
  const sig = key.sign(digest);
  return hexlify(cat(getBytes(sig.r), getBytes(sig.s), new Uint8Array([sig.yParity & 1]))); // 0x-prefixed r ‖ s ‖ v, v=0/1
}

Then on the wire the quote carries sign_mode: "v2" and evm_chain_id alongside the signature:

{
  "chain_id":               "injective-888", // Cosmos chain ID; mainnet="injective-1" (never 1439/1776)
  "contract_address":       "inj1qw7jk82hjvf79tnjykux6zacuh9gl0z0wl3ruk",
  "market_id":              "0x...",
  "rfq_id":                 1770848375348,
  "taker_direction":        "long",
  "margin":                 "10",         // must equal makerMargin you signed
  "quantity":               "10",         // must equal makerQuantity you signed
  "price":                  "4.5",        // must equal price you signed (byte-for-byte)
  "expiry":                 { "timestamp": 1770848395000 },
  "maker":                  "inj1def…maker",
  "taker":                  "inj1abc…taker",
  "signature":              "0x...",      // 65 bytes, r||s||v
  "maker_subaccount_nonce": 0,
  "sign_mode":              "v2",         // REQUIRED
  "evm_chain_id":           1439          // REQUIRED when sign_mode="v2" (1439 testnet, 1776 mainnet)
}

07Sending quotes

Wrap the signed payload in a MakerStreamStreamingRequest with message_type = "quote". Any field covered by the signature must match exactly, or the contract rejects it at settlement.

Quote ACK

Quote and settlement updates

Subscribe to both quote_update and settlement_update events on MakerStream. quote_ack.status="success" only means the indexer accepted and routed a valid quote; it is not a taker fill or decline signal. There is intentionally no separate "not accepted" event. If no quote_update or settlement_update arrives before the maker-set expiry, treat the quote as not accepted by the taker. Makers choose the quote expiry themselves, so local quote state should expire on that timestamp or height. If the taker accepts and settlement is attempted, the maker receives settlement_update with the trade result or failure. Log and key local quote state by taker address plus rfq_id; rfq_id alone is not globally unique. Also log executed_quantity, executed_margin, and settlement quotes for every live maker run.

08 · AdvancedSigned intents & TP/SL

Since contract 0.1.0‑alpha.6 the RFQ system supports signed taker intents — trades that fire when a mark‑price trigger crosses, submitted by a relayer, not the taker. TP/SL (take‑profit / stop‑loss) is the first user of this path.

Two quote bindings

The contract accepts two kinds of binding. Both end in the same MsgPrivilegedExecuteContract:

Three participation modes for an MM

A. Pre‑post blind quotes

Identical signing structure to a live quote, but with a wildcard taker (or an allow‑list) and a wider quantity band. Full reference in the contract's execute::post_blind_quote doc. Any matching retail AcceptQuote can consume them without a live RFQ cycle.

B. Live response on trigger

The relayer fires an RFQ the moment the trigger crosses. You behave exactly as §04–§07 of this document; the relayer, not the taker, submits AcceptSignedIntent.

C. “Do nothing”

TP/SL is opt‑in. If the taker is exiting and another MM has blind‑quote coverage at an acceptable price, the protocol settles without you. You are never obligated to participate in a signed‑intent event, and not responding has no reputational cost.

Working signing code (tpsl_blind.py, cancel.py, verification steps) lives in the E2E Testnet Runbook, §08.

Failure modes

09Reference & troubleshooting

Testnet chain reference

Chain ID

injective-888

Contract

inj1qw7jk82hjvf79tnjykux6zacuh9gl0z0wl3ruk

Contract version

0.1.0‑α.6

Mainnet contract

inj12stwq95jet57edcu4a65r48r46s9rzrs938n8k takes effect June 3

USDC (ERC‑20 denom)

erc20:0x0C382e685bbeeFE5d3d9C29e29E341fEE8E84C5d

Market: INJ/USDC PERP

0xdc70164d7120529c3cd84278c98df4151210c0447a65a2aab03459cf328de41e

Market: BTC/USDC PERP

0xfd704649cf3a516c0c145ab0111717c44640d8dbe52a462ae35cadf2f6df1515

Market: LINK/USDC PERP

0xdbb9bb072015238096f6e821ee9aab7affd741f8662a71acc14ac30ee6b687a5

Market: ETH/USDC PERP

0x135de28700392fb1c17d40d5170a74f30055a4ad522feddafec42fbbbb780897

Explorer

https://testnet.explorer.injective.network

Reference implementations

Config sample

chain:
  chain_id: injective-888
  grpc_endpoint: testnet.sentry.chain.grpc.injective.network:443
  lcd_endpoint: https://testnet.sentry.lcd.injective.network
contract:
  address: inj1qw7jk82hjvf79tnjykux6zacuh9gl0z0wl3ruk
  version: 0.1.0-alpha.6
indexer:
  ws_endpoint: wss://rfq.ws.testnet.injective.network
  grpc_web_endpoint: https://rfq.grpc-web.testnet.injective.network
  grpc_endpoint: rfq.grpc.testnet.injective.network:443
markets:
  - id: "0xdc70164d7120529c3cd84278c98df4151210c0447a65a2aab03459cf328de41e"
    symbol: INJ/USDC PERP
  - id: "0xfd704649cf3a516c0c145ab0111717c44640d8dbe52a462ae35cadf2f6df1515"
    symbol: BTC/USDC PERP
  - id: "0xdbb9bb072015238096f6e821ee9aab7affd741f8662a71acc14ac30ee6b687a5"
    symbol: LINK/USDC PERP
  - id: "0x135de28700392fb1c17d40d5170a74f30055a4ad522feddafec42fbbbb780897"
    symbol: ETH/USDC PERP
tokens:
  usdc: erc20:0x0C382e685bbeeFE5d3d9C29e29E341fEE8E84C5d

Troubleshooting matrix

FAQ

Tx per trade?

No. You sign quotes off‑chain. The taker submits AcceptQuote; the contract verifies your signature.

Quote expires early?

Live MM quotes are 2s. The contract checks expiry > block_time at settlement; nothing else enforces a floor. Taker collection can be ~500ms, so keep clocks synced and avoid slow network calls after receiving the RFQ. Blind / TP‑SL quotes live minutes–hours.

Partial fills?

Yes – set maker_quantity / maker_margin to your intended amounts. Unfilled remainder follows the taker's unfilled_action.

Reduce‑only quotes?

Pass margin: "0" on the RFQ. With no capital committed, the only valid fill is one that closes or shrinks existing exposure — the protocol can't open new size against zero margin. No separate flag needed.

No response penalty?

None. No quotes → no trade. Your response‑rate does affect standing, however.

How do positions settle?

As synthetic positions on the Injective exchange module between your subaccount and the taker's. Real margin, PnL, liquidation.

Connection drops?

Confirm ping cadence (~1s), the grpc-ws subprotocol, and reconnect with exponential backoff.

Quotes not reaching takers – checklist

1. Whitelisted? Query list_makers (see runbook §4).
2. Authz granted? See §03 / runbook §5.
3. Signature verifies? Check field order and that id/e are JSON numbers/objects, not strings.
4. Quote expired? Verify expiry and clock sync.

Competition window

After a request is sent, the indexer waits for quotes before delivering to the taker. Testnet ~30–45s; mainnet ~2–10s. Best price wins – lowest for long, highest for short.