@arxiumlabs/sdk 0.9.0 → 0.13.1

package/README.md

@@ -44,10 +44,20 @@ const fee2 = actionFee(params, sender, nonce, payload, { signatureLength: multis
 
 ### Reading the chain
 
-`ArxiumRpc` returns typed responses for status, accounts, stake, assets (`listAssets`, `asset`, `assetByAlias`, `assetHolders`, `assetBalance`), attestors, validators (`validator`, `validatorPower`, `operatorValidators`), block effects, evidence and Merkle proofs. Each method takes a type parameter if you need a different shape.
+The list methods (`listAssets`, `assetHolders`, `attestors`, `evidenceList`) follow the node's `next_cursor` pages (`?limit=&cursor=`) and return the whole list. `ArxiumRpc` returns typed responses for status, accounts, stake, assets (`listAssets`, `asset`, `assetByAlias`, `assetHolders`, `assetBalance`), attestors, validators (`validator`, `validatorPower`, `operatorValidators`), block effects, evidence and Merkle proofs. Each method takes a type parameter if you need a different shape.
+
+`rpc.blockEffects(height)` and `rpc.effects(from, to)` carry `corporate_actions`: one `CorporateActionLine` per snapshot holder of every `DistributeToHolders`, `RedeemHolders` and `SplitAsset` in the block, with the action's `action_index` and `signature`, `asset`, `payout_asset` (distributions only), `holder`, `amount` (`bigint`) and `outcome` (`paid`, `withheld`, `minted`, `forced_back` or `redeemed`). Use these for per-holder payouts, not `asset_balances` diffs: those are end-of-block balances, so they blur a holder that moved twice in the block and show nothing for a withheld holder. Blocks a node wrote before it recorded these lines return an empty list.
+
+They also carry `pledges`: one `PledgeEffect` per collateral pledge the block opened, changed or closed, with its `pledge` id and `record`, the end-of-block `Pledge`, or `null` once it was released or seized. Blocks from before nodes recorded pledges return an empty list.
 
 ### Sending
 
+For pluggable asynchronous Ed25519 signing, use the verified signer/local
+adapter with the existing RPC callback. [Contract, examples and limits](SIGNERS.md)
+describe exact bytes, key matching, mutation protection and uncertain outcomes.
+Keys held in an HSM or AWS KMS sign through `pkcs11Ed25519Signer` or
+`awsKmsEd25519Signer`; see [HSM and KMS backends](SIGNERS.md#hsm-and-kms-backends).
+
 `sendAction` signs at the account's current nonce. The node's nonce doesn't count actions still in the mempool, so one client runs sends for the same sender one after another. Concurrent calls each wait their turn and never collide on a nonce. Two separate processes sending for one sender still need their own coordination. For a multisig or programmable-account sender, pass `sign(message, nonce)` instead of `privateKey` and return the combined witness.
 
 `rpc.sendAction({ privateKey, sender, payload })` signs, submits and waits for the block. If the chain refuses the action it throws `ActionDroppedError`, whose `reason` is the node's exact text. `rpc.assets(address)` returns the account's asset balances with `transfer_eligible` and `eligibility_reason`, so an app can check the sending side before the user signs. Walkthrough: https://arxium.network/docs/sdk-quickstart
@@ -83,7 +93,59 @@ const consent = await signDvpConsent(buyerKey, genesis, seller, order, buyerNonc
 await rpc.sendAction({ privateKey: sellerKey, sender: seller, payload: encodeSettleDvp(order, consent) });
 ```
 
-Settling consumes the counterparty's nonce, so the consent can't be replayed, and any other action the counterparty sends first cancels it. The node refuses the order after height `expiresAt`. A multisig counterparty's members each sign `dvpConsentBytes(…)` and combine them with `multisigSignature`. A programmable-account counterparty is not supported yet.
+Settling consumes the counterparty's nonce, so the consent can't be replayed, and any other action the counterparty sends first cancels it. The node refuses the order after height `expiresAt`. A multisig counterparty's members each sign `dvpConsentBytes(…)` and combine them with `multisigSignature`. A programmable-account counterparty's owners each sign `dvpConsentBytes(…)` and combine them with `assemblePolicySignature("owner", policy, sigs)`; its leg is checked against its own spending limits and recipient allowlist (nodes after v0.15.0).
+
+### Venue settlement
+
+A venue (an off-chain order book) settles trades between parties who each signed an order. Each order names the venue, so only that venue can settle it. The venue sends the action and pays the fee. One `encodeSettleVenue` carries 1 to `MAX_VENUE_TRADES` (32) trades, settled in order, all or nothing. In each trade the maker's give must equal the taker's take, same asset and amount, and the other way round:
+
+```ts
+const sellTerms: VenueOrderTerms = { venue, give: { asset: bondRef }, giveAmount: 10n, take: { asset: cashRef }, takeAmount: 500n, expiresAt: height + 100n };
+const buyTerms: VenueOrderTerms = { venue, give: { asset: cashRef }, giveAmount: 500n, take: { asset: bondRef }, takeAmount: 10n, expiresAt: height + 100n };
+const maker: SignedVenueOrder = { owner: seller, orderId: sellId, terms: sellTerms, signature: await signVenueOrder(sellerKey, genesis, seller, sellId, sellTerms) };   // on the seller's machine
+const taker: SignedVenueOrder = { owner: buyer, orderId: buyId, terms: buyTerms, signature: await signVenueOrder(buyerKey, genesis, buyer, buyId, buyTerms) };        // on the buyer's machine
+await rpc.sendAction({ privateKey: venueKey, sender: venue, payload: encodeSettleVenue([{ maker, taker }]) });
+```
+
+`orderId` is any u64 the owner hasn't used on a live order; pick a random one. Each `(owner, orderId)` settles at most once, there are no partial fills, and the owner's own actions don't touch its orders, so a party can have many live orders. An order may expire at most `MAX_ORDER_LIFETIME` (43,200 blocks, one day) past the height it settles at. The owner kills an order with `encodeCancelVenueOrder(orderId, expiresAt)`, passing the order's own expiry. A multisig or programmable-account owner's members each sign `venueOrderBytes(…)` and combine them as for `dvpConsentBytes(…)`. A programmable owner's leg is checked against its own spending limits and recipient allowlist.
+
+### Collateral pledges
+
+A pledgor puts up `amount` of an asset for a beneficiary against an `exposure`, with a haircut, a valuation agent and a cure period. RWA and token units stay in the pledgor's balance, encumbered: the pledgor can't transfer, burn or deliver them. Native IUM moves into escrow. The beneficiary signs the terms first, at its current nonce, then the pledgor sends them:
+
+```ts
+const terms: PledgeTerms = { beneficiary: bank, valuationAgent: null, asset: { asset: bondRef }, amount: 95n, haircutBps: 1_000, exposure: 50n, unitPrice: PRICE_SCALE, curePeriodBlocks: 10n, maturity: null };
+const consent = await signPledgeConsent(bankKey, genesis, holder, terms, bankNonce);    // on the bank's machine
+await rpc.sendAction({ privateKey: holderKey, sender: holder, payload: encodePledge(terms, consent) });
+const id = await pledgeId(holder, holderNonce);                                          // the nonce the Pledge was sent at
+```
+
+`unitPrice` is a price times `PRICE_SCALE`, so `PRICE_SCALE` is 1.00. `haircutBps: 1_000` values the collateral at 90%. `valuationAgent: null` makes the beneficiary the agent.
+
+| Action | Sent by | Encoder |
+|---|---|---|
+| Mark a new price and exposure | the valuation agent | `encodeMarkPledge(id, unitPrice, exposure)` |
+| Add collateral | the pledgor | `encodeTopUpPledge(id, amount)` |
+| Swap the collateral | the pledgor, with the agent's `signSubstituteConsent(…)` | `encodeSubstitutePledge(id, asset, amount, unitPrice, agentSignature)` |
+| Return collateral | the beneficiary any time; the pledgor in full once exposure is marked `0` | `encodeReleasePledge(id, amount)` |
+| Seize in default | the beneficiary | `encodeSeizePledge(id, full)` |
+
+A mark that values the collateral below the exposure opens a margin call. The pledgor has `curePeriodBlocks` to top up or substitute. After that, or after `maturity + curePeriodBlocks` with exposure still outstanding, the beneficiary may seize everything (`full: true`) or only the units worth the exposure, with the rest returned. `rpc.pledge(id)` returns the record with its `collateral_value`, `shortfall` and `in_default` at the tip. `rpc.accountAssetPledges(address, asset)` lists the pledges on one balance. Native collateral is escrowed, so it isn't listed there.
+
+### WASM modules
+
+Asset modules (`docs/wasm-contracts-plan.md`) run inside the chain's compliance rules. They are off until a governed `SetChainParams` sets `modules_enabled`, so on a chain where it is off both actions are refused.
+
+```ts
+const address = await moduleAddress(deployer, code, salt);            // where it will live
+await rpc.submit(submitBody(deployer, nonce, sig, encodeDeployModule(code, salt)));
+const gas = 100_000n;                                                  // the fee follows this limit, not the gas used; set it from simulateModule's gas_used
+await rpc.submit(submitBody(caller, nonce, sig, encodeCallModule(address, input, gas)));
+await rpc.module(address); await rpc.moduleCode(address); await rpc.moduleState(address, keyHex);
+const dry = await rpc.simulateModule(address, { caller, input, gasLimit: gas });  // { ok, gas_used, return, writes, events, balances } or { ok: false, error }
+```
+
+Only an attested account can deploy. A module holds a regulated asset only if it is attested like any holder, and it pays out only from its own account through the same checks as a transfer (freeze, claims, jurisdiction, caps, locks). Limits per module: 32 KiB of code, 1 KiB per stored value, 16 reads, 16 writes, 16 lookups, 4 transfers per call. A call is priced by its gas limit twice over: execution (one weight per 50 fuel) and the dispute-artifact bytes it could add (15,000 weight per 1,000 fuel, up to a whole block at 64 rows), so a tight limit is cheap and a 1,000,000 limit fills a block. Deploying costs 8 weight per code byte. There is no way to list a module's storage; keep your own index and read it by key.
 
 ### Programmable accounts
 
@@ -139,7 +201,7 @@ arx verify signature
 
 `arx sign` always needs a reachable node. Every signature covers the chain's genesis hash (see Chain binding above), and `sign` reads it from `--rpc` (`GET /genesis-hash`) on every run. `--nonce` only skips the account-nonce lookup. There is no fully offline signing mode: with no node the command exits 1 with the fetch error.
 
-Supported signed actions are `transfer`, `stake`, `unstake`, `join-validator`, `leave-validator`, `register-bls-key`, `authorize-operator`, `revoke-operator`, `grant-attestation`, `revoke-attestation`, `register-asset`, `issue-asset`, `transfer-asset`, `apply-attestor`, `block-attestor`, `propose-add-attestor`, `propose-remove-attestor`, `propose-unblock-attestor`, `vote`, `execute-proposal` and `settle-dvp`, plus the issuer, corporate-action and token commands below. Amount arguments are raw base-unit integers (IUM for ARX, the asset's smallest unit for an asset).
+Supported signed actions are `transfer`, `stake`, `unstake`, `join-validator`, `leave-validator`, `register-bls-key`, `authorize-operator`, `revoke-operator`, `grant-attestation`, `revoke-attestation`, `register-asset`, `issue-asset`, `transfer-asset`, `apply-attestor`, `block-attestor`, `propose-add-attestor`, `propose-remove-attestor`, `propose-unblock-attestor`, `vote`, `execute-proposal`, `settle-dvp`, `venue-settle`, `venue-cancel`, `module-deploy` and `module-call`, plus the issuer, corporate-action and token commands below. Amount arguments are raw base-unit integers (IUM for ARX, the asset's smallest unit for an asset).
 
 ```sh
 arx send apply-attestor "Arxium Bank" <owner>,<owner>,<owner> 2 <evidence-hash> <evidence-uri>   # sender is the 2-of-N multisig; validators vote
@@ -170,6 +232,14 @@ arx send create-token ABC "Abc Token" 6 1000000 - mintable   # <max-supply|-> mi
 arx send mint-token arxasset1... arx1to 100   # transfer-token, burn-token, renounce-mint
 arx dvp-consent arx1seller arxasset1bond... 10 native 500 <expires-at-height> --key buyer.json   # buyer signs; prints the "send" args
 arx send settle-dvp arxasset1bond... 10 arx1buyer native 500 <expires-at-height> <buyer-signature> --key seller.json
+arx venue-order arx1venue arxasset1bond... 10 arxasset1cash... 500 <expires-at-height> --key seller.json > sell.json   # random order id, or --order-id n
+arx send venue-settle trades.json --key venue.json   # [{ "maker": <sell.json>, "taker": <buy.json> }, ...]
+arx send venue-cancel <order-id> <expires-at-height> --key seller.json
+arx send module-deploy <module.wasm> [salt] --key deployer.json
+arx send module-call <module-address> <gas-limit> [input-hex] --key caller.json
+arx query module <address>
+arx query module-state <address> <key-hex>
+arx simulate <module-address> <gas-limit> [input-hex] --key caller.json   # dry run, nothing is sent
 
 arx query assets [arx1address]   # all assets, or one account's balances
 arx query asset arxasset1...

package/SIGNERS.md

@@ -0,0 +1,132 @@
+# Asynchronous signing contract
+
+The SDK already accepts `ArxiumRpc.sendAction({ sign })` for custom witnesses.
+The verified Ed25519 interface plugs into that callback and also signs offline
+actions and DvP consents. It adds no provider, dependency, key storage or network
+request. Existing CryptoKey functions and the generic witness callback remain
+available. RPC now captures the caller's options and payload at invocation,
+including requests waiting in the per-sender queue.
+
+```ts
+import {
+  localEd25519Signer, signActionWithSigner, verifiedSignerCallback,
+  encodeAddress, type ArxiumRpc,
+} from "@arxiumlabs/sdk";
+
+// The public key is from your already verified key file/account configuration.
+async function example(privateKey: CryptoKey, publicKey: Uint8Array,
+                       genesis: Uint8Array, nonce: bigint,
+                       payload: Uint8Array, rpc: ArxiumRpc) {
+  const signer = localEd25519Signer(privateKey, publicKey);
+  const sender = encodeAddress(publicKey);
+  const signature = await signActionWithSigner(signer, publicKey, genesis, sender, nonce, payload);
+  // An explicit send, only when the caller intends a transaction:
+  // await rpc.sendAction({ sender, payload, sign: verifiedSignerCallback(signer, publicKey) });
+  return signature;
+}
+```
+
+`Ed25519Signer` advertises `algorithm: "Ed25519"`, a raw32-byte compressed
+public key and `sign(message): Promise<Uint8Array>` returning a raw64-byte
+signature. The mode is **pure Ed25519 over the exact supplied message**.
+No SDK prehash, double hash, DER/PEM wrapper, Ed25519ph/ctx or provider digest
+mode is implied. A future backend must establish its actual mode/encoding;
+different HSM/KMS products cannot be assumed to support this same operation.
+The local adapter uses the existing WebCrypto Ed25519 primitive and never
+exports private key material. It does not sign a probe at construction.
+
+`signBytesWithSigner` snapshots the message and caller-selected expected key,
+checks the advertised key/algorithm, invokes the provider once with a separate
+buffer, snapshots the returned signature, then verifies it against the original
+message and expected key before returning lowercase hex. The expected key must
+come from trusted account/member configuration, not an unchecked provider claim.
+The callback factory pins key bytes and the method at creation. Provider-side
+mutation cannot change the trusted message; a signature of changed or hashed
+bytes is refused. Each concurrent call owns separate state and buffers.
+
+`signActionWithSigner` uses existing signingBytes: raw32-byte genesis, string
+sender, u64 nonce, existing payload bytes. `signDvpConsentWithSigner` uses
+existing dvpConsentBytes and its separate DvP domain/counterparty nonce. Amounts
+remain bigint/u128 in their existing encoders; these helpers do not reinterpret
+payload fields. Nonces accept exact bigint through u64 max, and safe integer
+Numbers; unsafe values fail under A120. RPC's existing numeric nonce API still
+rejects unsafe Numbers; this does not add full-u64 JSON RPC support.
+
+For multisig/programmable accounts, sender is the stable account, while the
+expected key is the chosen member key. These helpers return one member's raw
+signature. Use existing multisigSignature/assemblePolicySignature tooling to
+assemble a witness. Signature verification does not establish current policy,
+membership, nonce freshness, balances, expiry, authorization or finality. The
+verified callback directly returns a single-key signature; a custom callback
+is still needed to assemble multi-member/policy witnesses before submission.
+
+Provider errors/refusal/uncertain outcomes propagate unchanged. Invalid key,
+mode, response shape or signature raises SignerVerificationError. There is no
+fallback, retry, second signature, provider failover or implicit submission in
+these helpers. They do not offer signing timeout/cancellation. A pending signer
+may finish late; a caller's Promise.race or abandoned wait cannot cancel remote
+work; abandoning an entire RPC send also does not cancel that still-pending
+send or prevent its one originally requested submission. Once a provider promise rejects, a later resolve is ignored and does not
+trigger submission. An explicit RPC send signs/submits once; submission errors
+and the existing post-submit polling timeout propagate without automatic resend.
+RPC timeoutMs begins after submission and does not interrupt signing or cancel a
+transaction. A failed send rejects requests already queued for that sender
+with the same error; they do not sign or submit after the failure. This changes
+the old queue behavior that continued automatically after any error. Once the
+queue unwinds, a new explicit request is possible. Reconcile an ambiguous remote
+signing/submission outcome before any such separately authorized request. Per-sender queuing is local to one RPC
+client, not a chain lock or cross-client nonce reservation.
+
+## HSM and KMS backends
+
+Arxium signs with pure Ed25519. The SDK adds no dependency for either backend:
+you pass in a client you have already configured, and the private key never leaves the device.
+
+| Backend | Key | Mode | Status |
+|---|---|---|---|
+| PKCS#11 v3 (`pkcs11Ed25519Signer`) | `CKK_EC_EDWARDS`, Ed25519 | `CKM_EDDSA`, no parameters | Devnet E2E on SoftHSM 2.7 |
+| AWS KMS (`awsKmsEd25519Signer`) | `ECC_NIST_EDWARDS25519` | `ED25519_SHA_512`, `MessageType: RAW` | Request shape unit-tested, no live KMS run yet |
+| GCP Cloud KMS | `EC_SIGN_ED25519` | PureEdDSA | Software protection level only, not HSM: no adapter |
+| Azure Key Vault / Managed HSM | no Ed25519 | | Not possible |
+
+PKCS#11 tokens with Ed25519 include YubiHSM 2, Thales Luna 7.7+, Utimaco and
+SoftHSM 2.6+. Check your firmware: `CKM_EDDSA` arrived with PKCS#11 3.0.
+
+```ts
+import { KMS } from "@aws-sdk/client-kms";
+const signer = await awsKmsEd25519Signer(new KMS({ region: "eu-west-1" }), "alias/treasury");
+await rpc.sendAction({ sender: encodeAddress(trustedKey), payload, sign: verifiedSignerCallback(signer, trustedKey) });
+```
+
+```ts
+import pkcs11js from "pkcs11js"; // logged-in session; key handles from C_FindObjects
+const signer = pkcs11Ed25519Signer(p11, session, privateKeyHandle, publicKeyHandle);
+```
+
+The adapters work with the verified helpers above. Pin `trustedKey` from your own
+configuration, not from what the backend reports. For multisig, give each member its own
+signer (one HSM, another KMS) and assemble with `multisigSignature`.
+
+Limits:
+- AWS KMS signs RAW messages of at most 4096 bytes (`AWS_KMS_MAX_MESSAGE`). Pure Ed25519
+  cannot be prehashed, so the adapter refuses a larger action before calling KMS.
+  `ED25519_PH_SHA_512` produces signatures the chain does not accept.
+- A PKCS#11 session runs one operation at a time. The adapter's init and sign run
+  back to back synchronously, so calls on one session never interleave.
+
+`scripts/pkcs11-e2e.mjs` generates a non-extractable key on a PKCS#11 token, funds it
+from a devnet key and sends a transfer signed on the token. To run it on SoftHSM:
+
+```sh
+brew install softhsm && softhsm2-util --init-token --free --label arx --pin 1234 --so-pin 5678
+npm run build && npm i --no-save pkcs11js
+PKCS11_LIB=/opt/homebrew/lib/softhsm/libsofthsm2.so PKCS11_PIN=1234 ARX_RPC=… ARX_TOKEN=… ARX_FUND_SEED=… node scripts/pkcs11-e2e.mjs
+```
+
+Evidence: real WebCrypto signatures checked against Rust-generated action and
+DvP vectors; adversarial buffers, wrong key/mode/signature, prehashed input,
+refusal, ambiguous/late completion and concurrent requests; actual RPC/legacy/
+multisig paths use injected synthetic fetch. These are source and synthetic
+integration tests, **not HSM/KMS or production confirmation evidence**. The
+PKCS#11 adapter has run end to end on devnet against SoftHSM. AWS KMS has not
+run against a live key yet.

package/dist/actions.d.ts

@@ -40,6 +40,8 @@ export declare const ACTION_VARIANT: {
     readonly applyAttestor: 41;
     readonly blockAttestor: 42;
     readonly settleDvp: 43;
+    readonly deployModule: 46;
+    readonly callModule: 47;
 };
 /** `ActionPayload::Token(TokenAction)` is variant 39; these are `TokenAction`'s own discriminants, written after it. */
 export declare const TOKEN_ACTION = 39;
@@ -155,11 +157,112 @@ export declare const DVP_DOMAIN = 4294967295;
 /**
  * What the counterparty signs, mirroring `dvp_consent(…).signing_bytes`: the order, bound to the genesis hash and the
  * counterparty's current nonce, which settling consumes. Sending any other action first cancels the consent. A multisig
- * counterparty's members each sign these bytes and combine them with `multisigSignature`.
+ * counterparty's members each sign these bytes and combine them with `multisigSignature`; a programmable account's owners
+ * combine theirs with `assemblePolicySignature("owner", …)`.
  */
 export declare function dvpConsentBytes(genesis: Uint8Array, initiator: string, order: DvpOrder, counterpartyNonce: number | bigint): Uint8Array;
 export declare function signDvpConsent(privateKey: CryptoKey, genesis: Uint8Array, initiator: string, order: DvpOrder, counterpartyNonce: number | bigint): Promise<string>;
 export declare function encodeSettleDvp(order: DvpOrder, counterpartySignature: string): Uint8Array;
+/** `ActionPayload::Collateral(CollateralAction)` is variant 44; these are `CollateralAction`'s own discriminants, written after it. */
+export declare const COLLATERAL_ACTION = 44;
+export declare const COLLATERAL_VARIANT: {
+    readonly pledge: 0;
+    readonly markPledge: 1;
+    readonly topUpPledge: 2;
+    readonly substitutePledge: 3;
+    readonly releasePledge: 4;
+    readonly seizePledge: 5;
+};
+/** `unitPrice` is quote units per base unit of the pledged asset, times this: `PRICE_SCALE` is a price of 1.00. */
+export declare const PRICE_SCALE = 1000000000n;
+/** `PledgeConsent.domain` and `SubstituteConsent.domain`: like `DVP_DOMAIN`, no consent doubles as an action signature. */
+export declare const PLEDGE_DOMAIN = 4294967294;
+export declare const SUBSTITUTE_DOMAIN = 4294967293;
+/**
+ * The sender pledges `amount` of `asset` to `beneficiary` against `exposure`. `valuationAgent: null` makes the beneficiary the
+ * agent, the only account that may `markPledge`. A mark below the exposure opens a margin call the pledgor has
+ * `curePeriodBlocks` to cure; past it, or past `maturity + curePeriodBlocks` while exposure is outstanding, the beneficiary may seize.
+ */
+export type PledgeTerms = {
+    beneficiary: string;
+    valuationAgent: string | null;
+    asset: SpendAsset;
+    amount: bigint;
+    haircutBps: number;
+    exposure: bigint;
+    unitPrice: bigint;
+    curePeriodBlocks: bigint;
+    maturity: bigint | null;
+};
+/** Mirrors `pledge_id`: `sha256("xc-pledge:" ‖ pledgor ‖ ":" ‖ nonce as 8 big-endian bytes)`, where `nonce` is the opening `Pledge`'s. */
+export declare function pledgeId(pledgor: string, nonce: number | bigint): Promise<string>;
+/**
+ * What the beneficiary signs, mirroring `pledge_consent(…).signing_bytes`: the terms, bound to the genesis hash and the
+ * beneficiary's current nonce, which the pledge consumes. Multisig and programmable beneficiaries combine signatures as for `dvpConsentBytes`.
+ */
+export declare function pledgeConsentBytes(genesis: Uint8Array, pledgor: string, terms: PledgeTerms, beneficiaryNonce: number | bigint): Uint8Array;
+export declare function signPledgeConsent(privateKey: CryptoKey, genesis: Uint8Array, pledgor: string, terms: PledgeTerms, beneficiaryNonce: number | bigint): Promise<string>;
+export declare function encodePledge(terms: PledgeTerms, beneficiarySignature: string): Uint8Array;
+/** The valuation agent's new price and exposure: opens a margin call on a shortfall, closes one once covered. Exposure `0` marks the debt repaid. */
+export declare function encodeMarkPledge(pledge: string, unitPrice: bigint, exposure: bigint): Uint8Array;
+/** The pledgor adds `amount` of the pledged asset. */
+export declare function encodeTopUpPledge(pledge: string, amount: bigint): Uint8Array;
+/** What the valuation agent signs for a substitution, mirroring `substitute_consent(…).signing_bytes`, at the agent's nonce (consumed). */
+export declare function substituteConsentBytes(genesis: Uint8Array, agent: string, agentNonce: number | bigint, pledge: string, asset: SpendAsset, amount: bigint, unitPrice: bigint): Uint8Array;
+export declare function signSubstituteConsent(privateKey: CryptoKey, genesis: Uint8Array, agent: string, agentNonce: number | bigint, pledge: string, asset: SpendAsset, amount: bigint, unitPrice: bigint): Promise<string>;
+/** The pledgor swaps the collateral for `amount` of `asset` at `unitPrice`, with the agent's `signSubstituteConsent`. */
+export declare function encodeSubstitutePledge(pledge: string, asset: SpendAsset, amount: bigint, unitPrice: bigint, agentSignature: string): Uint8Array;
+/** `amount` back to the pledgor: the beneficiary at any time, the pledgor in full once the exposure is marked repaid. */
+export declare function encodeReleasePledge(pledge: string, amount: bigint): Uint8Array;
+/** In default only, by the beneficiary: everything (`full`) or the units worth the exposure, the rest returned. Closes the pledge. */
+export declare function encodeSeizePledge(pledge: string, full: boolean): Uint8Array;
+/** `ActionPayload::Venue(VenueAction)` is variant 45; these are `VenueAction`'s own discriminants, written after it. */
+export declare const VENUE_ACTION = 45;
+export declare const VENUE_VARIANT: {
+    readonly settleVenue: 0;
+    readonly cancelVenueOrder: 1;
+};
+/** `VenueOrder.domain`: like `DVP_DOMAIN`, an order signature never doubles as an action or a consent. */
+export declare const VENUE_ORDER_DOMAIN = 4294967292;
+/** Blocks an order may expire ahead of the height it settles at (one day at 2 s blocks). `signVenueOrder` callers should stay within it. */
+export declare const MAX_ORDER_LIFETIME = 43200n;
+/** Trades per `settleVenue`. */
+export declare const MAX_VENUE_TRADES = 32;
+/** One side of a trade: give `giveAmount` of `give` for `takeAmount` of `take`, settled only by `venue`, until `expiresAt`. */
+export type VenueOrderTerms = {
+    venue: string;
+    give: SpendAsset;
+    giveAmount: bigint;
+    take: SpendAsset;
+    takeAmount: bigint;
+    expiresAt: bigint;
+};
+export type SignedVenueOrder = {
+    owner: string;
+    orderId: bigint;
+    terms: VenueOrderTerms;
+    signature: string;
+};
+/**
+ * What an order's owner signs, mirroring `venue_order(…).signing_bytes`: the terms as an action from the owner with
+ * `nonce = orderId`. Each `(owner, orderId)` settles at most once; pick a random u64. Multisig and programmable owners
+ * combine signatures as for `dvpConsentBytes`.
+ */
+export declare function venueOrderBytes(genesis: Uint8Array, owner: string, orderId: number | bigint, terms: VenueOrderTerms): Uint8Array;
+export declare function signVenueOrder(privateKey: CryptoKey, genesis: Uint8Array, owner: string, orderId: number | bigint, terms: VenueOrderTerms): Promise<string>;
+/** The venue (sender, named in every order) settles 1..`MAX_VENUE_TRADES` mirrored trades, all or nothing, and pays the fee. */
+export declare function encodeSettleVenue(trades: {
+    maker: SignedVenueOrder;
+    taker: SignedVenueOrder;
+}[]): Uint8Array;
+/** The owner kills its order. `expiresAt` must be the order's own expiry: the chain forgets the cancel after it. */
+export declare function encodeCancelVenueOrder(orderId: number | bigint, expiresAt: number | bigint): Uint8Array;
+/** Deploys a WASM asset module. Refused unless the chain has `modules_enabled`, and then only for an attested sender. Its address is `moduleAddress(sender, sha256(code), salt)` on the node; read it back from `GET /modules/{address}`. */
+export declare function encodeDeployModule(code: Uint8Array, salt?: number | bigint): Uint8Array;
+/** Calls a module's `call` export. The fee is set by `gasLimit`, not by the gas used, so keep it close to what the call needs. */
+export declare function encodeCallModule(module: string, input: Uint8Array, gasLimit: number | bigint): Uint8Array;
+/** Mirrors `module_address` in `arxd/runtime/src/module.rs`: where a module deployed by `deployer` with this `code` and `salt` lives. */
+export declare function moduleAddress(deployer: string, code: Uint8Array, salt?: number | bigint): Promise<string>;
 /** `GovernanceAction`'s own discriminants (after `SetChainParams` 0, `TreasurySpend` 1, `ResolveDispute` 2, `ReinstateValidator` 3). Only the attestor actions are encodable here. */
 export declare const GOVERNANCE_ACTION: {
     readonly addAttestor: 4;
@@ -186,7 +289,7 @@ export declare function encodeVoteProposal(proposal: number | bigint, approve: b
 export declare function encodeExecuteProposal(proposal: number | bigint): Uint8Array;
 export declare function encodeSetAssetLimits(asset: string, maxHolders: number | null, maxBalancePerHolder?: bigint | null, maxAttestationAge?: bigint | null): Uint8Array;
 /** `{ name, input }` names and shapes match `fixtures/signed-actions.json`: amounts are decimal strings, byte fields are number arrays. */
-export type ActionName = keyof typeof ACTION_VARIANT | keyof typeof TOKEN_VARIANT | keyof typeof POLICY_VARIANT;
+export type ActionName = keyof typeof ACTION_VARIANT | keyof typeof TOKEN_VARIANT | keyof typeof COLLATERAL_VARIANT | keyof typeof VENUE_VARIANT | keyof typeof POLICY_VARIANT;
 export type DecodedPayload = {
     name: ActionName;
     input: Record<string, any>;

package/dist/actions.js

@@ -13,6 +13,7 @@ export const ACTION_VARIANT = {
     verifyClaimProof: 37, setPrivateClaims: 38,
     submitProposal: 30, voteProposal: 31, executeProposal: 32,
     applyAttestor: 41, blockAttestor: 42, settleDvp: 43,
+    deployModule: 46, callModule: 47,
 };
 /** `ActionPayload::Token(TokenAction)` is variant 39; these are `TokenAction`'s own discriminants, written after it. */
 export const TOKEN_ACTION = 39;
@@ -81,28 +82,157 @@ export function encodeApplyAttestor(name, owners, threshold, evidenceHash, evide
 export function encodeBlockAttestor() { return new Writer().varint(ACTION_VARIANT.blockAttestor).bytes(); }
 /** `DvpTerms.domain`: no `ActionPayload` can start with it, so a consent never doubles as an ordinary action signature. */
 export const DVP_DOMAIN = 0xffff_ffff;
+/** Protocol u64 fields must not inherit the generic writer's wider u128 range. */
+function exactU64(value, field) {
+    if (typeof value === "number" && !Number.isSafeInteger(value))
+        throw new RangeError(`${field} must be an exact u64; use bigint above Number.MAX_SAFE_INTEGER`);
+    const integer = BigInt(value);
+    if (integer < 0n || integer > 0xffffffffffffffffn)
+        throw new RangeError(`${field} out of u64 range`);
+    return integer;
+}
 /**
  * What the counterparty signs, mirroring `dvp_consent(…).signing_bytes`: the order, bound to the genesis hash and the
  * counterparty's current nonce, which settling consumes. Sending any other action first cancels the consent. A multisig
- * counterparty's members each sign these bytes and combine them with `multisigSignature`.
+ * counterparty's members each sign these bytes and combine them with `multisigSignature`; a programmable account's owners
+ * combine theirs with `assemblePolicySignature("owner", …)`.
  */
 export function dvpConsentBytes(genesis, initiator, order, counterpartyNonce) {
+    const expiresAt = exactU64(order.expiresAt, "expiresAt");
     const w = new Writer().varint(DVP_DOMAIN).string(initiator);
     writeSpendAsset(w, order.give);
     w.varint(order.giveAmount);
     writeSpendAsset(w, order.take);
-    w.varint(order.takeAmount).varint(order.expiresAt);
+    w.varint(order.takeAmount).varint(expiresAt);
     return signingBytes(genesis, order.counterparty, counterpartyNonce, w.bytes());
 }
 export async function signDvpConsent(privateKey, genesis, initiator, order, counterpartyNonce) { return toHex(new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, asBuffer(dvpConsentBytes(genesis, initiator, order, counterpartyNonce))))); }
 export function encodeSettleDvp(order, counterpartySignature) {
+    const expiresAt = exactU64(order.expiresAt, "expiresAt");
     const w = new Writer().varint(ACTION_VARIANT.settleDvp);
     writeSpendAsset(w, order.give);
     w.varint(order.giveAmount).string(order.counterparty);
     writeSpendAsset(w, order.take);
-    w.varint(order.takeAmount).varint(order.expiresAt).string(counterpartySignature);
+    w.varint(order.takeAmount).varint(expiresAt).string(counterpartySignature);
     return w.bytes();
 }
+/** `ActionPayload::Collateral(CollateralAction)` is variant 44; these are `CollateralAction`'s own discriminants, written after it. */
+export const COLLATERAL_ACTION = 44;
+export const COLLATERAL_VARIANT = { pledge: 0, markPledge: 1, topUpPledge: 2, substitutePledge: 3, releasePledge: 4, seizePledge: 5 };
+/** `unitPrice` is quote units per base unit of the pledged asset, times this: `PRICE_SCALE` is a price of 1.00. */
+export const PRICE_SCALE = 1000000000n;
+/** `PledgeConsent.domain` and `SubstituteConsent.domain`: like `DVP_DOMAIN`, no consent doubles as an action signature. */
+export const PLEDGE_DOMAIN = 0xffff_fffe;
+export const SUBSTITUTE_DOMAIN = 0xffff_fffd;
+function exactU16(value, field) {
+    if (!Number.isInteger(value) || value < 0 || value > 0xffff)
+        throw new RangeError(`${field} out of u16 range`);
+    return value;
+}
+/** Mirrors `pledge_id`: `sha256("xc-pledge:" ‖ pledgor ‖ ":" ‖ nonce as 8 big-endian bytes)`, where `nonce` is the opening `Pledge`'s. */
+export async function pledgeId(pledgor, nonce) {
+    const prefix = new TextEncoder().encode(`xc-pledge:${pledgor}:`), n = exactU64(nonce, "nonce"), input = new Uint8Array(prefix.length + 8);
+    input.set(prefix);
+    new DataView(input.buffer).setBigUint64(prefix.length, n);
+    return `0x${toHex(new Uint8Array(await crypto.subtle.digest("SHA-256", input)))}`;
+}
+/**
+ * What the beneficiary signs, mirroring `pledge_consent(…).signing_bytes`: the terms, bound to the genesis hash and the
+ * beneficiary's current nonce, which the pledge consumes. Multisig and programmable beneficiaries combine signatures as for `dvpConsentBytes`.
+ */
+export function pledgeConsentBytes(genesis, pledgor, terms, beneficiaryNonce) {
+    const w = new Writer().varint(PLEDGE_DOMAIN).string(pledgor).string(terms.valuationAgent ?? terms.beneficiary);
+    writeSpendAsset(w, terms.asset);
+    w.varint(terms.amount).varint(exactU16(terms.haircutBps, "haircutBps")).varint(terms.exposure).varint(terms.unitPrice).varint(exactU64(terms.curePeriodBlocks, "curePeriodBlocks"));
+    w.option(terms.maturity, (ww, m) => ww.varint(exactU64(m, "maturity")));
+    return signingBytes(genesis, terms.beneficiary, beneficiaryNonce, w.bytes());
+}
+export async function signPledgeConsent(privateKey, genesis, pledgor, terms, beneficiaryNonce) { return toHex(new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, asBuffer(pledgeConsentBytes(genesis, pledgor, terms, beneficiaryNonce))))); }
+const collateral = (name) => new Writer().varint(COLLATERAL_ACTION).varint(COLLATERAL_VARIANT[name]);
+export function encodePledge(terms, beneficiarySignature) {
+    const w = collateral("pledge").string(terms.beneficiary).option(terms.valuationAgent, (ww, agent) => ww.string(agent));
+    writeSpendAsset(w, terms.asset);
+    w.varint(terms.amount).varint(exactU16(terms.haircutBps, "haircutBps")).varint(terms.exposure).varint(terms.unitPrice).varint(exactU64(terms.curePeriodBlocks, "curePeriodBlocks"));
+    return w.option(terms.maturity, (ww, m) => ww.varint(exactU64(m, "maturity"))).string(beneficiarySignature).bytes();
+}
+/** The valuation agent's new price and exposure: opens a margin call on a shortfall, closes one once covered. Exposure `0` marks the debt repaid. */
+export function encodeMarkPledge(pledge, unitPrice, exposure) { return collateral("markPledge").string(pledge).varint(unitPrice).varint(exposure).bytes(); }
+/** The pledgor adds `amount` of the pledged asset. */
+export function encodeTopUpPledge(pledge, amount) { return collateral("topUpPledge").string(pledge).varint(amount).bytes(); }
+/** What the valuation agent signs for a substitution, mirroring `substitute_consent(…).signing_bytes`, at the agent's nonce (consumed). */
+export function substituteConsentBytes(genesis, agent, agentNonce, pledge, asset, amount, unitPrice) {
+    const w = new Writer().varint(SUBSTITUTE_DOMAIN).string(pledge);
+    writeSpendAsset(w, asset);
+    return signingBytes(genesis, agent, agentNonce, w.varint(amount).varint(unitPrice).bytes());
+}
+export async function signSubstituteConsent(privateKey, genesis, agent, agentNonce, pledge, asset, amount, unitPrice) { return toHex(new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, asBuffer(substituteConsentBytes(genesis, agent, agentNonce, pledge, asset, amount, unitPrice))))); }
+/** The pledgor swaps the collateral for `amount` of `asset` at `unitPrice`, with the agent's `signSubstituteConsent`. */
+export function encodeSubstitutePledge(pledge, asset, amount, unitPrice, agentSignature) {
+    const w = collateral("substitutePledge").string(pledge);
+    writeSpendAsset(w, asset);
+    return w.varint(amount).varint(unitPrice).string(agentSignature).bytes();
+}
+/** `amount` back to the pledgor: the beneficiary at any time, the pledgor in full once the exposure is marked repaid. */
+export function encodeReleasePledge(pledge, amount) { return collateral("releasePledge").string(pledge).varint(amount).bytes(); }
+/** In default only, by the beneficiary: everything (`full`) or the units worth the exposure, the rest returned. Closes the pledge. */
+export function encodeSeizePledge(pledge, full) { return collateral("seizePledge").string(pledge).bool(full).bytes(); }
+/** `ActionPayload::Venue(VenueAction)` is variant 45; these are `VenueAction`'s own discriminants, written after it. */
+export const VENUE_ACTION = 45;
+export const VENUE_VARIANT = { settleVenue: 0, cancelVenueOrder: 1 };
+/** `VenueOrder.domain`: like `DVP_DOMAIN`, an order signature never doubles as an action or a consent. */
+export const VENUE_ORDER_DOMAIN = 0xffff_fffc;
+/** Blocks an order may expire ahead of the height it settles at (one day at 2 s blocks). `signVenueOrder` callers should stay within it. */
+export const MAX_ORDER_LIFETIME = 43200n;
+/** Trades per `settleVenue`. */
+export const MAX_VENUE_TRADES = 32;
+function writeVenueTerms(w, terms) {
+    const expiresAt = exactU64(terms.expiresAt, "expiresAt");
+    w.varint(VENUE_ORDER_DOMAIN).string(terms.venue);
+    writeSpendAsset(w, terms.give);
+    w.varint(terms.giveAmount);
+    writeSpendAsset(w, terms.take);
+    return w.varint(terms.takeAmount).varint(expiresAt);
+}
+/**
+ * What an order's owner signs, mirroring `venue_order(…).signing_bytes`: the terms as an action from the owner with
+ * `nonce = orderId`. Each `(owner, orderId)` settles at most once; pick a random u64. Multisig and programmable owners
+ * combine signatures as for `dvpConsentBytes`.
+ */
+export function venueOrderBytes(genesis, owner, orderId, terms) {
+    return signingBytes(genesis, owner, exactU64(orderId, "orderId"), writeVenueTerms(new Writer(), terms).bytes());
+}
+export async function signVenueOrder(privateKey, genesis, owner, orderId, terms) { return toHex(new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, asBuffer(venueOrderBytes(genesis, owner, orderId, terms))))); }
+const venue = (name) => new Writer().varint(VENUE_ACTION).varint(VENUE_VARIANT[name]);
+function writeSignedOrder(w, order) {
+    w.string(order.owner).varint(exactU64(order.orderId, "orderId"));
+    return writeVenueTerms(w, order.terms).string(order.signature);
+}
+/** The venue (sender, named in every order) settles 1..`MAX_VENUE_TRADES` mirrored trades, all or nothing, and pays the fee. */
+export function encodeSettleVenue(trades) {
+    if (trades.length < 1 || trades.length > MAX_VENUE_TRADES)
+        throw new RangeError(`a venue settlement carries 1 to ${MAX_VENUE_TRADES} trades`);
+    return venue("settleVenue").vec(trades, (w, t) => { writeSignedOrder(w, t.maker); writeSignedOrder(w, t.taker); }).bytes();
+}
+/** The owner kills its order. `expiresAt` must be the order's own expiry: the chain forgets the cancel after it. */
+export function encodeCancelVenueOrder(orderId, expiresAt) { return venue("cancelVenueOrder").varint(exactU64(orderId, "orderId")).varint(exactU64(expiresAt, "expiresAt")).bytes(); }
+/** Deploys a WASM asset module. Refused unless the chain has `modules_enabled`, and then only for an attested sender. Its address is `moduleAddress(sender, sha256(code), salt)` on the node; read it back from `GET /modules/{address}`. */
+export function encodeDeployModule(code, salt = 0) { return new Writer().varint(ACTION_VARIANT.deployModule).vec(Array.from(code), (w, b) => w.u8(b)).varint(exactU64(salt, "salt")).bytes(); }
+/** Calls a module's `call` export. The fee is set by `gasLimit`, not by the gas used, so keep it close to what the call needs. */
+export function encodeCallModule(module, input, gasLimit) { return new Writer().varint(ACTION_VARIANT.callModule).string(module).vec(Array.from(input), (w, b) => w.u8(b)).varint(exactU64(gasLimit, "gasLimit")).bytes(); }
+/** Mirrors `module_address` in `arxd/runtime/src/module.rs`: where a module deployed by `deployer` with this `code` and `salt` lives. */
+export async function moduleAddress(deployer, code, salt = 0) {
+    const sha = async (bytes) => new Uint8Array(await crypto.subtle.digest("SHA-256", asBuffer(bytes))), text = new TextEncoder();
+    const tail = new Uint8Array(8);
+    new DataView(tail.buffer).setBigUint64(0, exactU64(salt, "salt"));
+    const parts = [text.encode("xc-module:"), text.encode(deployer), text.encode(":"), await sha(code), tail];
+    const preimage = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+    let at = 0;
+    for (const p of parts) {
+        preimage.set(p, at);
+        at += p.length;
+    }
+    return encodeAddress(await sha(preimage));
+}
 /** `GovernanceAction`'s own discriminants (after `SetChainParams` 0, `TreasurySpend` 1, `ResolveDispute` 2, `ReinstateValidator` 3). Only the attestor actions are encodable here. */
 export const GOVERNANCE_ACTION = { addAttestor: 4, removeAttestor: 5, unblockAttestor: 6 };
 /** An active validator opens a vote. `addAttestor` needs the attestor's multisig address and its owners; applicants who are not validators use `encodeApplyAttestor`. A removal blocks that attestor's new grants while it runs. */
@@ -118,6 +248,7 @@ export function encodeVoteProposal(proposal, approve) { return new Writer().vari
 export function encodeExecuteProposal(proposal) { return new Writer().varint(ACTION_VARIANT.executeProposal).varint(BigInt(proposal)).bytes(); }
 export function encodeSetAssetLimits(asset, maxHolders, maxBalancePerHolder = null, maxAttestationAge = null) { return new Writer().varint(ACTION_VARIANT.setAssetLimits).string(asset).option(maxHolders, (w, value) => w.varint(value)).option(maxBalancePerHolder, (w, value) => w.varint(value)).option(maxAttestationAge, (w, value) => w.varint(value)).bytes(); }
 const nullableBig = (value) => value == null ? null : BigInt(value);
+const orderInput = (o) => ({ owner: o.owner, orderId: BigInt(o.orderId), terms: { venue: o.terms.venue, give: o.terms.give, giveAmount: BigInt(o.terms.giveAmount), take: o.terms.take, takeAmount: BigInt(o.terms.takeAmount), expiresAt: BigInt(o.terms.expiresAt) }, signature: o.signature });
 export function encodePayload({ name, input }) {
     if (name in POLICY_VARIANT)
         return encodeAccountPolicy(name, input);
@@ -166,11 +297,21 @@ export function encodePayload({ name, input }) {
         case "transferToken": return encodeTransferToken(input.token, input.to, BigInt(input.amount));
         case "burnToken": return encodeBurnToken(input.token, BigInt(input.amount));
         case "renounceMint": return encodeRenounceMint(input.token);
+        case "pledge": return encodePledge({ beneficiary: input.beneficiary, valuationAgent: input.valuationAgent, asset: input.asset, amount: BigInt(input.amount), haircutBps: input.haircutBps, exposure: BigInt(input.exposure), unitPrice: BigInt(input.unitPrice), curePeriodBlocks: BigInt(input.curePeriodBlocks), maturity: nullableBig(input.maturity) }, input.beneficiarySignature);
+        case "markPledge": return encodeMarkPledge(input.pledge, BigInt(input.unitPrice), BigInt(input.exposure));
+        case "topUpPledge": return encodeTopUpPledge(input.pledge, BigInt(input.amount));
+        case "substitutePledge": return encodeSubstitutePledge(input.pledge, input.asset, BigInt(input.amount), BigInt(input.unitPrice), input.agentSignature);
+        case "releasePledge": return encodeReleasePledge(input.pledge, BigInt(input.amount));
+        case "seizePledge": return encodeSeizePledge(input.pledge, input.full);
+        case "settleVenue": return encodeSettleVenue(input.trades.map((t) => ({ maker: orderInput(t.maker), taker: orderInput(t.taker) })));
+        case "cancelVenueOrder": return encodeCancelVenueOrder(BigInt(input.orderId), BigInt(input.expiresAt));
+        case "deployModule": return encodeDeployModule(Uint8Array.from(input.code), BigInt(input.salt));
+        case "callModule": return encodeCallModule(input.module, Uint8Array.from(input.input), BigInt(input.gasLimit));
         default: throw new Error(`unsupported action: ${name}`);
     }
 }
 const invert = (table) => Object.fromEntries(Object.entries(table).map(([key, value]) => [value, key]));
-const VARIANT_NAME = invert(ACTION_VARIANT), TOKEN_NAME = invert(TOKEN_VARIANT), CLASS_NAME = invert(CLASS), TOPIC_NAME = invert(TOPIC), GOVERNANCE_NAME = invert(GOVERNANCE_ACTION);
+const VARIANT_NAME = invert(ACTION_VARIANT), TOKEN_NAME = invert(TOKEN_VARIANT), COLLATERAL_NAME = invert(COLLATERAL_VARIANT), VENUE_NAME = invert(VENUE_VARIANT), CLASS_NAME = invert(CLASS), TOPIC_NAME = invert(TOPIC), GOVERNANCE_NAME = invert(GOVERNANCE_ACTION);
 const known = (value, what) => { if (value === undefined)
     throw new Error(`unknown ${what}`); return value; };
 /**
@@ -186,7 +327,7 @@ export function decodePayload(payload) {
             throw new Error("payload is not in canonical form");
         return decoded;
     }
-    const name = outer === TOKEN_ACTION ? known(TOKEN_NAME[Number(r.varint())], "token action") : known(VARIANT_NAME[outer], "action variant");
+    const name = outer === TOKEN_ACTION ? known(TOKEN_NAME[Number(r.varint())], "token action") : outer === COLLATERAL_ACTION ? known(COLLATERAL_NAME[Number(r.varint())], "collateral action") : outer === VENUE_ACTION ? known(VENUE_NAME[Number(r.varint())], "venue action") : known(VARIANT_NAME[outer], "action variant");
     const str = () => r.string(), amount = () => r.varint().toString(), bytes = () => r.vec((rr) => rr.u8()), topics = () => r.vec((rr) => known(TOPIC_NAME[Number(rr.varint())], "claim topic"));
     const read = {
         transfer: () => ({ to: str(), amount: amount() }),
@@ -233,6 +374,25 @@ export function decodePayload(payload) {
         transferToken: () => ({ token: str(), to: str(), amount: amount() }),
         burnToken: () => ({ token: str(), amount: amount() }),
         renounceMint: () => ({ token: str() }),
+        pledge: () => ({ beneficiary: str(), valuationAgent: r.option(str), asset: readSpendAsset(r), amount: amount(), haircutBps: Number(r.varint()), exposure: amount(), unitPrice: amount(), curePeriodBlocks: amount(), maturity: r.option(amount), beneficiarySignature: str() }),
+        markPledge: () => ({ pledge: str(), unitPrice: amount(), exposure: amount() }),
+        topUpPledge: () => ({ pledge: str(), amount: amount() }),
+        substitutePledge: () => ({ pledge: str(), asset: readSpendAsset(r), amount: amount(), unitPrice: amount(), agentSignature: str() }),
+        releasePledge: () => ({ pledge: str(), amount: amount() }),
+        seizePledge: () => ({ pledge: str(), full: r.bool() }),
+        settleVenue: () => {
+            const order = () => {
+                const owner = str(), orderId = amount();
+                if (Number(r.varint()) !== VENUE_ORDER_DOMAIN)
+                    throw new Error("not a venue order");
+                const terms = { venue: str(), give: readSpendAsset(r), giveAmount: amount(), take: readSpendAsset(r), takeAmount: amount(), expiresAt: amount() };
+                return { owner, orderId, terms, signature: str() };
+            };
+            return { trades: r.vec(() => ({ maker: order(), taker: order() })) };
+        },
+        cancelVenueOrder: () => ({ orderId: amount(), expiresAt: amount() }),
+        deployModule: () => ({ code: bytes(), salt: amount() }),
+        callModule: () => ({ module: str(), input: bytes(), gasLimit: amount() }),
     };
     const decoded = { name, input: read[name]() };
     r.done();
@@ -242,7 +402,7 @@ export function decodePayload(payload) {
 }
 /** Mirrors `Action::signing_bytes`: the chain's 32-byte genesis hash (`GET /genesis-hash`) binds the signature to one chain, so an action signed for chain A is rejected on chain B. */
 export function signingBytes(genesis, sender, nonce, payload) { if (genesis.length !== 32)
-    throw new Error("genesis hash must be 32 bytes"); return new Writer().raw(genesis).string(sender).varint(nonce).raw(payload).bytes(); }
+    throw new Error("genesis hash must be 32 bytes"); return new Writer().raw(genesis).string(sender).varint(exactU64(nonce, "nonce")).raw(payload).bytes(); }
 export async function signAction(privateKey, genesis, sender, nonce, payload) { return toHex(new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, asBuffer(signingBytes(genesis, sender, nonce, payload))))); }
 export function submitBody(sender, nonce, signature, payload) { return { sender, nonce, signature, payload: Array.from(payload) }; }
 /** M-of-N sender, mirrors `xc_primitives::multisig_address`. Every member signs with plain `signAction(key, genesis, multisigAddress, nonce, payload)`; `multisigSignature` combines exactly `threshold` of them into the action's `signature` field. */