Maker actions

Two ways to reach the book:

A transfer with msg (mt_transfer_call or a transfer intent) when tokens go in: orders and deposits.
An auth_call intent when nothing goes in: intents.near checks your signature and calls the book’s on_auth with your account as signer_id. The book accepts on_auth only from intents.near.

prune is a plain public method.

The auth_call envelope

{
  "intent": "auth_call",
  "contract_id": "hexbook.near",
  "attached_deposit": "0",
  "min_gas": "100000000000000",
  "msg": "{\"action\":\"<action>\",\"data\":{ ... }}"
}

msg is a JSON string {"action": "<snake_case name>", "data": {...}}; claim_balance has no data. The action runs in its own receipt: a panic reverts the book’s state for that call only, not the other intents of the same payload.

Action	Data	Does
`batch`	`{ token_pair, bump_epoch?, cancel?, place? }`	cancels and places atomically from the internal balance
`cancel_all`	`{ token_pair }`	kills all your orders in a book, O(1)
`close_order`	`{ hash, token_pair }`	closes one order, then claims the whole internal balance
`withdraw`	`{ token_id, amount }`	pays one token out of the internal balance
`claim_balance`	none	pays the whole internal balance out
`set_payout_mode`	`{ mode }`	`internal` or `intents`

Signing (NEP-413)

Intents are signed with NEP-413 by a key that intents.near knows for your account. An implicit account’s own key is known automatically; a named account first registers a key with intents.near add_public_key.

Build the message

{
  "signer_id": "<your account>",
  "deadline": "2026-10-12T12:05:00.000Z",
  "intents": [ { "intent": "auth_call", "contract_id": "hexbook.near", ... } ]
}

message is this object serialized as a JSON string. Keep the deadline short (a few minutes).

Build a versioned nonce

32 bytes, each nonce usable once per account:

nonce = 56 28 f6 c6          // magic prefix
     ++ 00                   // version
     ++ salt                 // 4 bytes: intents.near view current_salt (a hex string)
     ++ u64_le(deadline_ns)  // the nonce's own deadline, nanoseconds
     ++ random(15)

intents.near rejects it when the salt is not a current one, the nonce deadline is earlier than the message deadline, or the nonce deadline has passed. Use the message deadline (or a little later) as the nonce deadline. Legacy random 32-byte nonces are still accepted but deprecated in NEAR Intents.

Hash and sign

payload = borsh_u32(2^31 + 413)                  // tag 2147484061, little-endian
        ++ borsh_string(message)                 // u32 LE length + UTF-8
        ++ nonce                                 // 32 raw bytes
        ++ borsh_string("intents.near")          // recipient
        ++ 0x00                                  // callback_url: None
signature = ed25519_sign(sha256(payload), secret_key)

Wrap the commitment

{
  "standard": "nep413",
  "payload": { "message": "<message>", "nonce": "<base64 nonce>", "recipient": "intents.near" },
  "signature": "ed25519:<base58 signature>",
  "public_key": "ed25519:<base58 public key>"
}

Submit

Gasless: the NEAR Intents solver relay, POST https://solver-relay-v2.chaindefuser.com/rpc with your API key (a JWT from the NEAR Intents Partner Portal) in X-API-Key. The relay runs execute_intents with 300 Tgas.
{ "jsonrpc": "2.0", "id": 1, "method": "publish_intent", "params": [{ "quote_hashes": [], "signed_data": <commitment> }] }
The answer is { "status": "OK" | "FAILED", "reason"?, "intent_hash" }. publish_intents takes several (signed_datas).
Yourself: call intents.near execute_intents({ "signed": [commitment] }) from any NEAR account with the gas you choose (simulate_intents with the same args dry-runs it). See Submitting your own transaction.

Read the outcome

Through the relay, poll JSON-RPC get_status with { "intent_hash": "<intent_hash>" } until status is SETTLED (or NOT_FOUND_OR_NOT_VALID: not received, expired or failed). data.hash is the NEAR transaction hash.
Read the transaction’s receipts: NEAR RPC EXPERIMENTAL_tx_status (with the transaction’s signer as sender_account_id) or FastNEAR /v0/transactions by hash (Data sources).
Find the receipt executed by hexbook.near (on_auth for an auth_call, mt_on_transfer for a transfer). Its logs are the result: for a batch, epoch, order_closed and order_created (array data: your new hashes) and place_skipped; see Events.
If that receipt failed, the action reverted (for a batch: nothing was cancelled or placed) even though the intent itself settled and its nonce is spent. Its error message says why.

Submitting your own transaction

NEAR pre-charges a transaction’s attached gas at a pessimistic gas price and refunds what is unused: keep about 0.3 NEAR on the submitting account for a 300 Tgas call (execute_intents or mt_transfer_call).

deposit

A transfer to hexbook.near with msg {"deposit": true} credits the sender’s internal balance; the book keeps the whole amount.

{
  "intent": "transfer",
  "receiver_id": "hexbook.near",
  "tokens": { "nep141:usdt.tether-token.near": "50000000" },
  "msg": "{\"deposit\":true}"
}

The token must be the base or quote of an existing book, otherwise the call panics and is refunded.
Logs deposit {a, tk, v}.

batch

Cancels and places your orders in one book atomically, funded from your internal balance. It never pays out.

{
  "action": "batch",
  "data": {
    "token_pair": { "base": "nep141:qtc.omft.near", "quote": "nep141:usdt.tether-token.near" },
    "bump_epoch": false,
    "cancel": ["3ed65e74…", "ade2a57f…"],
    "place": [
      { "side": "sell", "price": "0.0001390", "amount": "10000000000", "expires_at": "1791764846216108398" },
      { "side": "buy",  "price": "0.0001380", "amount": "1380000",     "expires_at": null }
    ]
  }
}

Field	Default	Meaning
`token_pair`	required	the book
`bump_epoch`	`false`	first increment your epoch in this book: every order you placed before becomes dead
`cancel`	`[]`	hashes of your resting orders in this book, dead ones included, at most 64
`place`	`[]`	new orders, at most 32: `side` (`"sell"`/`"buy"`), `price` (raw price as a JSON string), `amount` (u128 as a JSON string; base for sell, quote for buy), `expires_at` (u64 ns, string or number; `null`/`0` = never)

price and amount must be strings: a JSON number fails to parse and the whole batch panics. Order: bump_epoch → cancel (in order) → place (in order). Cancel refunds can fund the placements of the same batch. Panics (the whole batch reverts):

more than 64 cancels or 32 places;
a cancel hash that is not your resting order in this book;
a placement with price 0, off the tick, below the minimum or unable to buy one base unit, or expires_at not in the future;
not enough internal balance for a placement (sell: base, buy: quote);
logs over 16 KiB (split the batch).

Skips (the placement is dropped, the rest goes on, nothing is debited):

`why`	When
`cross`	a sell at or below the best live bid, or a buy at or above the best live ask: placements are maker-only
`level_full`	the price level already has 500 orders
`owner_cap`	you already have 200 orders in this book
`duplicate`	an order with the same hash already rests: same side, price and maker, created in this block (for example an earlier placement of this batch)

The best live price skips dead orders, scanning at most 128 orders per side; past that, the price reached counts as live.

Dead orders still count: toward the 200-per-owner and 500-per-level limits (owner_cap, level_full) and the 128-order scan. After bump_epoch, cancel_all or a TTL expiry, list your own dead orders in the cancel of your next batch (cancel accepts them and refunds them to your internal balance): see the maker lifecycle. prune is a fallback.

Events. A batch logs epoch (if bumped), then one order_closed (why: "cancel"), one order_created (with x and e when non-zero) and one place_skipped ({m, i, why}, i = index in place), each with a data array, one item per order. See Events. Gas. Each cancel and placement writes the level, the order and your set of orders. Measured on the book receipt in sandbox:

Operation	Gas
`batch`, 5 placements	8.4 Tgas
`batch`, 8 placements (maker with up to 200 orders)	13.7 Tgas
`batch`, 32 placements (maker with up to 200 orders)	31–35 Tgas
`cancel_all`	2.7 Tgas
`deposit`	2.6 Tgas
`withdraw` (one token)	3.2 Tgas

Roughly 1 Tgas per operation plus a few Tgas fixed; a full batch fits easily in the relay’s 300 Tgas. Set min_gas with headroom (for example 100 Tgas for a full batch).

cancel_all

Bumps your epoch in one book: O(1), whatever the number of orders. Every order you placed there before is dead at once. Logs epoch {m, b, q, e}.

{"action":"cancel_all","data":{"token_pair":{"base":"nep141:qtc.omft.near","quote":"nep141:usdt.tether-token.near"}}}

The dead orders’ balances come back when they are closed: by a trade (per your payout mode), by a batch cancel or prune (internal balance). Until then they hold their slots: close them in your next batch’s cancel. batch with bump_epoch: true kills everything and posts a fresh ladder in one step; list the old hashes in the same batch’s cancel to free their slots too.

close_order

Closes one of your resting orders, refunds it to your internal balance, then claims your whole internal balance like claim_balance.

{"action":"close_order","data":{"hash":"3ed65e74…","token_pair":{"base":"nep141:qtc.omft.near","quote":"nep141:usdt.tether-token.near"}}}

Panics with Order not found or Only order maker can close the order.
Logs order_closed (why: "cancel") and claim.

close_order pays out your entire internal balance, inventory for future batches included. To cancel without moving funds out, use batch with cancel.

claim_balance

Pays out your whole internal balance, every token in one call, as many tokens as the gas allows (about 22 Tgas each; the rest stays claimable). Logs claim. A payout that fails is credited back (payout_failed).

{"action":"claim_balance"}

withdraw

Pays one token out of your internal balance to your intents.near balance.

{"action":"withdraw","data":{"token_id":"nep141:usdt.tether-token.near","amount":"25000000"}}

amount: null (or omitted) withdraws all of that token.
Panics with Nothing to withdraw, Insufficient internal balance or Not enough gas to withdraw (give it ~35 Tgas).
Logs claim. One mt_transfer; if it fails, the amount is credited back (payout_failed).

set_payout_mode

Where your maker proceeds go; see Payout modes. Logs payout_mode {a, mode}.

{"action":"set_payout_mode","data":{"mode":"internal"}}

mode: "internal" or "intents" (default). Read it with get_payout_mode.

prune

A public method: anyone can close dead orders. No deposit, at most 64 hashes; live and unknown hashes are ignored. Refunds go to the makers’ internal balances. Logs one order_closed with a data array (why: "expired" or "epoch") and returns how many orders it closed.

near contract call-function as-transaction hexbook.near prune json-args '{
  "token_pair": {"base":"nep141:qtc.omft.near","quote":"nep141:usdt.tether-token.near"},
  "hashes": ["3ed65e74…", "ade2a57f…"]
}' prepaid-gas '100 Tgas' attached-deposit '0 NEAR' sign-as <any-account> network-config mainnet sign-with-keychain send

For your own dead orders, listing them in your next batch’s cancel is cheaper and lands with your requote; prune is the fallback (for example when you stop quoting).

A typical maker session

Deposit, set payout mode internal, quote with batch (closing your dead orders in its cancel), cancel_all as the kill switch, then close and withdraw. The full lifecycle is in Build a market maker.

Overview

Contract

Market making

Indexing

The auth_call envelope

Signing (NEP-413)

Submitting your own transaction

deposit

batch

cancel_all

close_order

claim_balance

withdraw

set_payout_mode

prune

A typical maker session

​The auth_call envelope

​Signing (NEP-413)

​Submitting your own transaction

​deposit

​batch

​cancel_all

​close_order

​claim_balance

​withdraw

​set_payout_mode

​prune

​A typical maker session

The auth_call envelope

Signing (NEP-413)

Submitting your own transaction

deposit

batch

cancel_all

close_order

claim_balance

withdraw

set_payout_mode

prune

A typical maker session