@arxiumlabs/sdk 0.8.0 → 0.13.1

package/dist/actions.js

@@ -1,6 +1,6 @@
 import { MULTISIG_TAG, decodeAddress, encodeAddress } from "./bech32.js";
 import { Reader, Writer, asBuffer, fromHex, toHex } from "./bincode.js";
-import { ACCOUNT_POLICY_ACTION, POLICY_VARIANT, encodeAccountPolicy, readAccountPolicy } from "./policy.js";
+import { ACCOUNT_POLICY_ACTION, POLICY_VARIANT, encodeAccountPolicy, readAccountPolicy, readSpendAsset, writeSpendAsset } from "./policy.js";
 /** These indices are ActionPayload's positional bincode discriminants. Never derive them. */
 export const ACTION_VARIANT = {
     transfer: 0, joinValidator: 1, leaveValidator: 2, stake: 3, unstake: 4, registerBlsKey: 6,
@@ -12,7 +12,8 @@ export const ACTION_VARIANT = {
     snapshotHolders: 33, distributeToHolders: 34, redeemHolders: 35, splitAsset: 36,
     verifyClaimProof: 37, setPrivateClaims: 38,
     submitProposal: 30, voteProposal: 31, executeProposal: 32,
-    applyAttestor: 41, blockAttestor: 42,
+    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;
@@ -79,6 +80,159 @@ export function encodeRenounceMint(tokenRef) { return token("renounceMint").stri
 export function encodeApplyAttestor(name, owners, threshold, evidenceHash, evidenceUri) { return new Writer().varint(ACTION_VARIANT.applyAttestor).string(name).vec(owners, (w, o) => w.string(o)).u8(threshold).string(evidenceHash).string(evidenceUri).bytes(); }
 /** Emergency stop: the sending attestor can no longer grant new attestations. Only a governance vote lifts it. */
 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`; 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(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(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. */
@@ -94,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);
@@ -136,16 +291,27 @@ export function encodePayload({ name, input }) {
         case "executeProposal": return encodeExecuteProposal(BigInt(input.proposal));
         case "applyAttestor": return encodeApplyAttestor(input.name, input.owners, input.threshold, input.evidenceHash, input.evidenceUri);
         case "blockAttestor": return encodeBlockAttestor();
+        case "settleDvp": return encodeSettleDvp({ give: input.give, giveAmount: BigInt(input.giveAmount), counterparty: input.counterparty, take: input.take, takeAmount: BigInt(input.takeAmount), expiresAt: BigInt(input.expiresAt) }, input.counterpartySignature);
         case "createToken": return encodeCreateToken(input.symbol, input.name, input.decimals, BigInt(input.initialSupply), nullableBig(input.maxSupply), input.mintable);
         case "mintToken": return encodeMintToken(input.token, input.to, BigInt(input.amount));
         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; };
 /**
@@ -161,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() }),
@@ -202,11 +368,31 @@ export function decodePayload(payload) {
         executeProposal: () => ({ proposal: amount() }),
         applyAttestor: () => ({ name: str(), owners: r.vec((rr) => rr.string()), threshold: r.u8(), evidenceHash: str(), evidenceUri: str() }),
         blockAttestor: () => ({}),
+        settleDvp: () => ({ give: readSpendAsset(r), giveAmount: amount(), counterparty: str(), take: readSpendAsset(r), takeAmount: amount(), expiresAt: amount(), counterpartySignature: str() }),
         createToken: () => ({ symbol: str(), name: str(), decimals: r.u8(), initialSupply: amount(), maxSupply: r.option(amount), mintable: r.bool() }),
         mintToken: () => ({ token: str(), to: str(), amount: amount() }),
         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();
@@ -216,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. */

package/dist/cli.js

@@ -3,7 +3,7 @@ import { readFile, writeFile } from "node:fs/promises";
 import { basename } from "node:path";
 import { stdin as input, stderr, stdout } from "node:process";
 import { createPrivateKey, createPublicKey } from "node:crypto";
-import { ArxiumRpc, RpcError, encodeApplyAttestor, encodeBlockAttestor, encodeExecuteProposal, encodeSubmitProposal, encodeVoteProposal, encodeAuthorizeOperator, encodeGrantAttestation, encodeIssueAsset, encodeRegisterAsset, encodeFreezeAsset, encodeSetHolderFrozen, encodeSetAssetLimits, encodeTransferAsset, encodeJoinValidator, encodeLeaveValidator, encodeRegisterBlsKey, encodeRevokeAttestation, encodeRevokeOperator, encodeStake, encodeTransfer, encodeUnstake, generateKey, isKeyFile, signAction, submitBody, unlockKey, verifyKeyFile, verifySignedAction, wrapPkcs8, encodeAddress, toHex, toKeyFile, PKCS8_ED25519_PREFIX, assemblePolicySignature, decodePayload, encodePayload, fromHex, multisigAddress, multisigSignature, signingBytes, asBuffer, ALL_ISSUER_CONTROLS, ISSUER_CONTROLS, bigintReplacer, encodeBurnAsset, encodeIssuerForcedTransfer, encodeRecoverHolder, encodeIssueAssetTo, encodeLockHolderAmount, encodeLockHolderAmountUntil, encodeLockIssuance, encodeTransferIssuer, encodeSetAssetMetadataUri, encodeSetPrivateClaims, encodeSnapshotHolders, encodeDistributeToHolders, encodeRedeemHolders, encodeSplitAsset, encodeCreateToken, encodeMintToken, encodeTransferToken, encodeBurnToken, encodeRenounceMint, } from "./index.js";
+import { ArxiumRpc, RpcError, encodeApplyAttestor, encodeBlockAttestor, encodeExecuteProposal, encodeSubmitProposal, encodeVoteProposal, encodeAuthorizeOperator, encodeGrantAttestation, encodeIssueAsset, encodeRegisterAsset, encodeFreezeAsset, encodeSetHolderFrozen, encodeSetAssetLimits, encodeTransferAsset, encodeJoinValidator, encodeLeaveValidator, encodeRegisterBlsKey, encodeRevokeAttestation, encodeRevokeOperator, encodeStake, encodeTransfer, encodeUnstake, generateKey, isKeyFile, signAction, submitBody, unlockKey, verifyKeyFile, verifySignedAction, wrapPkcs8, encodeAddress, toHex, toKeyFile, PKCS8_ED25519_PREFIX, assemblePolicySignature, decodePayload, encodePayload, fromHex, multisigAddress, multisigSignature, signingBytes, asBuffer, ALL_ISSUER_CONTROLS, ISSUER_CONTROLS, bigintReplacer, encodeBurnAsset, encodeIssuerForcedTransfer, encodeRecoverHolder, encodeIssueAssetTo, encodeLockHolderAmount, encodeLockHolderAmountUntil, encodeLockIssuance, encodeTransferIssuer, encodeSetAssetMetadataUri, encodeSetPrivateClaims, encodeSnapshotHolders, encodeDistributeToHolders, encodeRedeemHolders, encodeSplitAsset, encodeCreateToken, encodeMintToken, encodeTransferToken, encodeBurnToken, encodeRenounceMint, encodeSettleDvp, signDvpConsent, encodeDeployModule, encodeCallModule, encodeSettleVenue, encodeCancelVenueOrder, signVenueOrder, MAX_ORDER_LIFETIME, } from "./index.js";
 class UsageError extends Error {
 }
 function output(value, json) { stdout.write(!json && typeof value === "string" ? `${value}\n` : `${JSON.stringify(value, bigintReplacer, 2)}\n`); }
@@ -123,7 +123,11 @@ const USAGE = {
     "split-asset": "<asset-ref> <snapshot-height> <numerator> <denominator>",
     "create-token": "<symbol> <name> <decimals> <initial-supply> <max-supply|-> mintable|fixed", "mint-token": "<token-ref> <to> <amount>",
     "transfer-token": "<token-ref> <to> <amount>", "burn-token": "<token-ref> <amount>", "renounce-mint": "<token-ref>",
+    "settle-dvp": "<give-asset-ref|native> <give-amount> <counterparty> <take-asset-ref|native> <take-amount> <expires-at-height> <counterparty-signature>",
+    "venue-settle": "<trades.json>", "venue-cancel": "<order-id> <expires-at-height>",
+    "module-deploy": "<module.wasm> [salt]", "module-call": "<module-address> <gas-limit> [input-hex]",
 };
+const spendArg = (value) => value === "native" ? "native" : { asset: value };
 function morePayload(action, args) {
     const usage = USAGE[action] ?? throwUsage(`unsupported action: ${action}`);
     const arg = (i) => args[i] ?? throwUsage(`${action} needs ${usage}`);
@@ -158,6 +162,15 @@ function morePayload(action, args) {
         case "mint-token": return encodeMintToken(arg(0), arg(1), int(2));
         case "transfer-token": return encodeTransferToken(arg(0), arg(1), int(2));
         case "burn-token": return encodeBurnToken(arg(0), int(1));
+        case "settle-dvp": return encodeSettleDvp({ give: spendArg(arg(0)), giveAmount: int(1), counterparty: arg(2), take: spendArg(arg(3)), takeAmount: int(4), expiresAt: int(5) }, arg(6));
+        case "venue-settle": {
+            const raw = JSON.parse(arg(0));
+            const order = (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 });
+            return encodeSettleVenue(raw.map((t) => ({ maker: order(t.maker), taker: order(t.taker) })));
+        }
+        case "venue-cancel": return encodeCancelVenueOrder(int(0), int(1));
+        case "module-deploy": return encodeDeployModule(hexArg(arg(0)), args[1] === undefined ? 0n : int(1));
+        case "module-call": return encodeCallModule(arg(0), args[2] === undefined ? new Uint8Array() : hexArg(args[2]), int(1));
         default: return encodeRenounceMint(arg(0));
     }
 }
@@ -177,7 +190,7 @@ async function main() {
         return;
     }
     if (!command)
-        throwUsage("use: arx keys|sign|submit|send|query|verify");
+        throwUsage("use: arx keys|sign|submit|send|dvp-consent|venue-order|query|verify");
     if (command === "keys") {
         const [operation, ...keyArgs] = rest;
         if (operation === "new") {
@@ -284,8 +297,44 @@ async function main() {
         }
         throwUsage("use: arx multisig address|build|sign|combine|link");
     }
+    // The counterparty's half of a DvP: sign the order at its current nonce. The initiator sends it with `arx send settle-dvp`.
+    if (command === "dvp-consent") {
+        const use = "dvp-consent needs <initiator> <give-asset-ref|native> <give-amount> <take-asset-ref|native> <take-amount> <expires-at-height>", [initiator, give, giveAmount, take, takeAmount, expiresAt] = rest;
+        if (!initiator || !give || !take || ![giveAmount, takeAmount, expiresAt].every((v) => /^\d+$/.test(v ?? "")))
+            throwUsage(use);
+        const { file, privateKey } = await loadKey(globals.key);
+        const nonce = globals.nonce ?? await rpc.account(file.address).then((account) => account.nonce, (error) => { if (error instanceof RpcError && error.status === 404)
+            return 0; throw error; });
+        const order = { give: spendArg(give), giveAmount: BigInt(giveAmount), counterparty: file.address, take: spendArg(take), takeAmount: BigInt(takeAmount), expiresAt: BigInt(expiresAt) };
+        const signature = await signDvpConsent(privateKey, await rpc.genesisHash(), initiator, order, nonce);
+        output({ counterparty: file.address, counterpartyNonce: nonce, signature, send: ["settle-dvp", give, giveAmount, file.address, take, takeAmount, expiresAt, signature] }, true);
+        return;
+    }
+    // One party's order for a venue: sign it with a fresh random id. The venue pairs two of these into `arx send venue-settle`.
+    if (command === "venue-order") {
+        const use = "venue-order needs <venue> <give-asset-ref|native> <give-amount> <take-asset-ref|native> <take-amount> <expires-at-height> [--order-id n]";
+        const idFlag = rest.indexOf("--order-id"), idText = idFlag >= 0 ? rest.splice(idFlag, 2)[1] : undefined;
+        if (idFlag >= 0 && !/^\d+$/.test(idText ?? ""))
+            throwUsage(use);
+        const orderId = idText !== undefined ? BigInt(idText) : new DataView(crypto.getRandomValues(new Uint8Array(8)).buffer).getBigUint64(0);
+        const [venueAddress, give, giveAmount, take, takeAmount, expiresAt] = rest;
+        if (!venueAddress || !give || !take || !/^\d+$/.test(giveAmount ?? "") || !/^\d+$/.test(takeAmount ?? "") || !/^\d+$/.test(expiresAt ?? ""))
+            throwUsage(use);
+        const tip = BigInt((await rpc.status()).tip_height);
+        if (BigInt(expiresAt) > tip + MAX_ORDER_LIFETIME)
+            throwUsage(`expires-at must be within ${MAX_ORDER_LIFETIME} blocks of the tip (${tip})`);
+        const { file, privateKey } = await loadKey(globals.key), genesis = await rpc.genesisHash();
+        const terms = { venue: venueAddress, give: spendArg(give), giveAmount: BigInt(giveAmount), take: spendArg(take), takeAmount: BigInt(takeAmount), expiresAt: BigInt(expiresAt) };
+        output({ owner: file.address, orderId, terms, signature: await signVenueOrder(privateKey, genesis, file.address, orderId, terms) }, true);
+        return;
+    }
     if (command === "sign" || command === "send") {
-        const action = rest[0] ?? throwUsage(`${command} needs an action`), { file, privateKey } = await loadKey(globals.key), encoded = payload(action, rest.slice(1));
+        const action = rest[0] ?? throwUsage(`${command} needs an action`), { file, privateKey } = await loadKey(globals.key), actionArgs = rest.slice(1);
+        if (action === "venue-settle")
+            actionArgs[0] = await readFile(actionArgs[0] ?? throwUsage("venue-settle needs <trades.json>"), "utf8");
+        if (action === "module-deploy")
+            actionArgs[0] = toHex(new Uint8Array(await readFile(actionArgs[0] ?? throwUsage("module-deploy needs <module.wasm>"))));
+        const encoded = payload(action, actionArgs);
         if (command === "sign") {
             const nonce = globals.nonce ?? await rpc.account(file.address).then((account) => account.nonce, (error) => { if (error instanceof RpcError && error.status === 404)
                 return 0; throw error; });
@@ -328,11 +377,22 @@ async function main() {
                                 : operation === "attestor" ? await rpc.attestor(value ?? throwUsage("attestor needs an address"))
                                     : operation === "validator" ? await rpc.validator(value ?? throwUsage("validator needs an address"))
                                         : operation === "stakes" ? await rpc.stakes(value ?? throwUsage("stakes needs an address"))
-                                            : operation === "fee" ? await rpc.actionFee()
-                                                : throwUsage("use: arx query status|account|block|action|validators|validator|finality|search|assets [address]|asset|holders|balance|attestors|attestor|stakes|fee");
+                                            : operation === "module" ? await rpc.module(value ?? throwUsage("module needs an address"))
+                                                : operation === "module-state" ? await rpc.moduleState(value ?? throwUsage("module-state needs <address> <key-hex>"), rest[2] ?? throwUsage("module-state needs <address> <key-hex>"))
+                                                    : operation === "fee" ? await rpc.actionFee()
+                                                        : throwUsage("use: arx query status|account|block|action|validators|validator|finality|search|assets [address]|asset|holders|balance|attestors|attestor|stakes|module|module-state|fee");
         output(result, globals.json);
         return;
     }
+    // Dry-runs a module call as the key's address; no passphrase needed, nothing is signed or sent.
+    if (command === "simulate") {
+        const [module, gas, inputHex] = rest;
+        const caller = (await readKeyFile(globals.key)).address;
+        if (!module || !gas || !/^\d+$/.test(gas))
+            throwUsage("simulate needs <module-address> <gas-limit> [input-hex] and --key");
+        output(await rpc.simulateModule(module, { caller, input: inputHex === undefined ? new Uint8Array() : hexArg(inputHex), gasLimit: BigInt(gas) }), globals.json);
+        return;
+    }
     throwUsage(`unknown command: ${command}`);
 }
 main().catch((error) => { const usage = error instanceof UsageError; stderr.write(`${error instanceof Error ? error.message : String(error)}\n`); process.exitCode = usage ? 2 : 1; });

package/dist/fees.d.ts

@@ -3,6 +3,10 @@ export type FeeParams = {
     actionFee: bigint;
     weightFee: bigint;
 };
+/** Fuel one weight unit pays for (`FUEL_PER_WEIGHT` in `arxd/runtime/src/module.rs`). */
+export declare const FUEL_PER_WEIGHT = 50;
+/** Dispute-artifact pricing for module actions (`BLOCK_PROOF_KEYS`, `PROOF_WEIGHT_PER_KEY`, `MODULE_BASE_KEYS`, `DEPLOY_WEIGHT_PER_CODE_BYTE`, `COST_READ` in metering.rs and `xc_wasm`). */
+export declare const BLOCK_PROOF_KEYS = 64, PROOF_WEIGHT_PER_KEY = 15000, MODULE_BASE_KEYS = 4, DEPLOY_WEIGHT_PER_CODE_BYTE = 7, COST_READ = 1000;
 /** `POLICY_AUTHORIZATION_WEIGHT`: added when a stateful account policy authorizes the action. */
 export declare const POLICY_AUTHORIZATION_WEIGHT = 5000;
 /** A single-key ed25519 signature: 64 bytes as hex. */

package/dist/fees.js

@@ -1,7 +1,7 @@
-import { ACTION_VARIANT, TOKEN_ACTION, TOKEN_VARIANT } from "./actions.js";
+import { ACTION_VARIANT, COLLATERAL_ACTION, COLLATERAL_VARIANT, TOKEN_ACTION, TOKEN_VARIANT, VENUE_ACTION, VENUE_VARIANT } from "./actions.js";
 import { Reader } from "./bincode.js";
 import { ACCOUNT_POLICY_ACTION } from "./policy.js";
-/** `base_weight` in metering.rs, by `ActionPayload` discriminant. Token and account-policy actions are handled below. */
+/** `base_weight` in metering.rs, by `ActionPayload` discriminant. Token, collateral, venue and account-policy actions are handled below. */
 const BASE_WEIGHT = {
     [ACTION_VARIANT.transfer]: 50,
     [ACTION_VARIANT.stake]: 100, [ACTION_VARIANT.unstake]: 100,
@@ -20,10 +20,15 @@ const BASE_WEIGHT = {
     [ACTION_VARIANT.transferIssuer]: 100, [ACTION_VARIANT.setAssetMetadataUri]: 100,
     [ACTION_VARIANT.snapshotHolders]: 2_000, [ACTION_VARIANT.distributeToHolders]: 15_000,
     [ACTION_VARIANT.redeemHolders]: 10_000, [ACTION_VARIANT.splitAsset]: 10_000,
+    [ACTION_VARIANT.settleDvp]: 350,
     [ACTION_VARIANT.submitProposal]: 150, [ACTION_VARIANT.voteProposal]: 150, [ACTION_VARIANT.executeProposal]: 150,
     5 /* SubmitEquivocationEvidence */: 2_000,
     15 /* SubmitExecutionFault */: 500_000,
 };
+/** Fuel one weight unit pays for (`FUEL_PER_WEIGHT` in `arxd/runtime/src/module.rs`). */
+export const FUEL_PER_WEIGHT = 50;
+/** Dispute-artifact pricing for module actions (`BLOCK_PROOF_KEYS`, `PROOF_WEIGHT_PER_KEY`, `MODULE_BASE_KEYS`, `DEPLOY_WEIGHT_PER_CODE_BYTE`, `COST_READ` in metering.rs and `xc_wasm`). */
+export const BLOCK_PROOF_KEYS = 64, PROOF_WEIGHT_PER_KEY = 15_000, MODULE_BASE_KEYS = 4, DEPLOY_WEIGHT_PER_CODE_BYTE = 7, COST_READ = 1_000;
 /** `POLICY_AUTHORIZATION_WEIGHT`: added when a stateful account policy authorizes the action. */
 export const POLICY_AUTHORIZATION_WEIGHT = 5_000;
 /** A single-key ed25519 signature: 64 bytes as hex. */
@@ -36,6 +41,28 @@ function baseWeight(payload) {
         return Number(r.varint()) === TOKEN_VARIANT.createToken ? 150 : 100;
     if (variant === ACCOUNT_POLICY_ACTION)
         return 1_000;
+    if (variant === COLLATERAL_ACTION) {
+        const action = Number(r.varint());
+        return action === COLLATERAL_VARIANT.pledge || action === COLLATERAL_VARIANT.substitutePledge ? 350 : action === COLLATERAL_VARIANT.seizePledge ? 250 : 150;
+    }
+    if (variant === VENUE_ACTION) {
+        // `VENUE_SETTLE_BASE + trades × VENUE_TRADE_WEIGHT` in metering.rs; a cancel is flat.
+        return Number(r.varint()) === VENUE_VARIANT.settleVenue ? 100 + Number(r.varint()) * 800 : 100;
+    }
+    // `2_000 + 7 × code length` in metering.rs: the code rides in a dispute artifact about six times.
+    if (variant === ACTION_VARIANT.deployModule)
+        return 2_000 + r.vec((rr) => rr.u8()).length * DEPLOY_WEIGHT_PER_CODE_BYTE;
+    // The larger of `100 + ceil(gas_limit / FUEL_PER_WEIGHT)` and the proof bytes it could add (rows it could
+    // touch × PROOF_WEIGHT_PER_KEY) in metering.rs: priced by the limit, not by use. A tight limit is cheap.
+    if (variant === ACTION_VARIANT.callModule) {
+        r.string();
+        r.vec((rr) => rr.u8());
+        const gas = r.varint(), ceilDiv = (a, b) => (a + BigInt(b) - 1n) / BigInt(b);
+        const execution = 100n + ceilDiv(gas, FUEL_PER_WEIGHT);
+        const rows = ceilDiv(gas, COST_READ) + BigInt(MODULE_BASE_KEYS), keys = rows < BigInt(BLOCK_PROOF_KEYS) ? rows : BigInt(BLOCK_PROOF_KEYS);
+        const proofs = keys * BigInt(PROOF_WEIGHT_PER_KEY);
+        return Number(execution > proofs ? execution : proofs);
+    }
     const weight = BASE_WEIGHT[variant];
     if (weight === undefined)
         throw new Error(`unknown action variant: ${variant}`);

package/dist/index.d.ts

@@ -6,3 +6,4 @@ export * from "./keys.js";
 export * from "./rpc.js";
 export * from "./policy.js";
 export * from "./fees.js";
+export * from "./signer.js";

package/dist/index.js

@@ -6,3 +6,4 @@ export * from "./keys.js";
 export * from "./rpc.js";
 export * from "./policy.js";
 export * from "./fees.js";
+export * from "./signer.js";

package/dist/policy.d.ts

@@ -1,4 +1,4 @@
-import { Reader } from "./bincode.js";
+import { Reader, Writer } from "./bincode.js";
 export declare const ACCOUNT_POLICY_ACTION = 40;
 export declare const POLICY_VARIANT: {
     readonly setAccountPolicy: 0;
@@ -39,7 +39,11 @@ export type AccountPolicy = {
     } | null;
 };
 export type PolicyMode = "owner" | "session" | "guardian";
+declare function asset(w: Writer, a: SpendAsset): void;
+export { asset as writeSpendAsset };
 export declare function encodeAccountPolicy(name: keyof typeof POLICY_VARIANT, input: Record<string, any>): Uint8Array;
+declare function readAsset(r: Reader): SpendAsset;
+export { readAsset as readSpendAsset };
 export declare function readAccountPolicy(r: Reader): {
     name: keyof typeof POLICY_VARIANT;
     input: Record<string, any>;

package/dist/policy.js

@@ -16,6 +16,7 @@ function asset(w, a) { if (a === "native")
     w.varint(0);
 else
     w.varint(1).string(a.asset); }
+export { asset as writeSpendAsset };
 function recipients(w, list) { if (list.length > 64 || list.some((a, i) => i > 0 && list[i - 1] >= a))
     throw new Error("recipients must be bounded, unique and sorted"); w.vec(list, (ww, a) => ww.string(a)); }
 function session(w, s) { w.raw(key(s.publicKey)).varint(bounded(s.expiresAt, 64)); asset(w, s.asset); w.varint(bounded(s.allowance, 128)); recipients(w, s.recipients); }
@@ -56,6 +57,7 @@ function readThreshold(r) { return { threshold: r.u8(), members: r.vec(readKey)
 function readAsset(r) { const tag = r.varint(); if (tag === 0n)
     return "native"; if (tag === 1n)
     return { asset: r.string() }; throw new Error("unknown spend asset"); }
+export { readAsset as readSpendAsset };
 function readSession(r) { return { publicKey: readKey(r), expiresAt: r.varint().toString(), asset: readAsset(r), allowance: r.varint().toString(), recipients: r.vec(rr => rr.string()) }; }
 export function readAccountPolicy(r) {
     const variant = Number(r.varint()), name = Object.keys(POLICY_VARIANT).find(n => POLICY_VARIANT[n] === variant);