@arxiumlabs/sdk 0.8.0 → 0.9.0

package/README.md

@@ -13,7 +13,7 @@ npm install -g @arxiumlabs/sdk   # arx CLI
 
 ## Releasing
 
-Bump `version` here, run the release checks, then push a `sdk-vX.Y.Z` tag. `.github/workflows/sdk.yml` publishes to npm through trusted publishing (no token) with provenance.
+Bump `version` here, run the release checks, then push a `sdk-vX.Y.Z` tag. `.github/workflows/sdk.yml` publishes to npm through trusted publishing (no token). It publishes without a provenance attestation while the repository is private, because npm accepts provenance only from public repositories.
 
 ```sh
 cd Arxium && cargo test -p arxd-runtime writes_typescript_signed_action_fixtures && git diff --exit-code sdk/ts/fixtures
@@ -73,6 +73,18 @@ A co-signer should see what they're signing before they sign it. `decodePayload(
 
 Set the resulting address as an admin role (genesis or `SetAdmin`) or as an asset issuer (`TransferIssuer`). To rotate members, move the role to a new multisig address.
 
+### Atomic DvP (delivery versus payment)
+
+`SettleDvp` swaps two assets between two parties in one action: both legs settle or neither does. Each leg is `"native"` (IUM) or `{ asset }` (an RWA asset, with its full compliance gates, or a token). The counterparty signs the order first, at its current nonce. The initiator then sends it and pays the fee:
+
+```ts
+const order: DvpOrder = { give: { asset: bondRef }, giveAmount: 10n, counterparty: buyer, take: { asset: cashRef }, takeAmount: 500n, expiresAt: height + 100n };
+const consent = await signDvpConsent(buyerKey, genesis, seller, order, buyerNonce);    // on the buyer's machine
+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.
+
 ### Programmable accounts
 
 The SDK exports bounded account-policy codecs and stateful owner/session/guardian witness helpers. `arx multisig build|sign|combine|link` lets each member sign separately, for both immutable and stateful account addresses. To verify a historical action, `verifySignedAction` needs the proven pre-action policy for stateful witnesses, and `arx verify SIGNATURE --policy FILE` accepts that policy. See [the programmable-account guide](../../docs/Programmable_Accounts.md).
@@ -110,7 +122,7 @@ printf '%s' "$SEED_HEX" | arx keys import
 arx keys show --key arxium-devnet-key-abc.json   # no passphrase needed
 
 arx sign transfer arx1recipient 1500000000 --key key.json             # nonce fetched from --rpc
-arx sign transfer arx1recipient 1500000000 --key key.json --nonce 7   # fully offline
+arx sign transfer arx1recipient 1500000000 --key key.json --nonce 7   # skips the nonce lookup; still reads the genesis hash from --rpc
 arx submit signed-action.json
 arx send transfer arx1recipient 1500000000 --key key.json
 
@@ -125,7 +137,9 @@ arx query search arx1address
 arx verify signature
 ```
 
-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` and `execute-proposal`, 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).
+`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).
 
 ```sh
 arx send apply-attestor "Arxium Bank" <owner>,<owner>,<owner> 2 <evidence-hash> <evidence-uri>   # sender is the 2-of-N multisig; validators vote
@@ -154,6 +168,8 @@ arx send redeem-holders arxasset1... <height>
 arx send split-asset arxasset1... <height> 2 1
 arx send create-token ABC "Abc Token" 6 1000000 - mintable   # <max-supply|-> mintable|fixed
 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 query assets [arx1address]   # all assets, or one account's balances
 arx query asset arxasset1...
@@ -175,7 +191,7 @@ public entry point and checks the CLI version; it makes no chain calls.
 
 Publication runs only for an approved `sdk-vX.Y.Z` tag matching package.json.
 The publish job builds its own checkout, checks the packed files and smoke-tests
-the tarball, then publishes that exact tarball with provenance. Existing npm
+the tarball, then publishes that exact tarball (no provenance while the repo is private). Existing npm
 versions cannot be replaced. npm trusted-publisher configuration and release
 authorization are still required; a passing package check is not publication
 or on-chain compatibility proof.

package/dist/actions.d.ts

@@ -1,4 +1,4 @@
-import { POLICY_VARIANT } from "./policy.js";
+import { POLICY_VARIANT, type SpendAsset } from "./policy.js";
 /** These indices are ActionPayload's positional bincode discriminants. Never derive them. */
 export declare const ACTION_VARIANT: {
     readonly transfer: 0;
@@ -39,6 +39,7 @@ export declare const ACTION_VARIANT: {
     readonly executeProposal: 32;
     readonly applyAttestor: 41;
     readonly blockAttestor: 42;
+    readonly settleDvp: 43;
 };
 /** `ActionPayload::Token(TokenAction)` is variant 39; these are `TokenAction`'s own discriminants, written after it. */
 export declare const TOKEN_ACTION = 39;
@@ -137,6 +138,28 @@ export declare function encodeRenounceMint(tokenRef: string): Uint8Array;
 export declare function encodeApplyAttestor(name: string, owners: string[], threshold: number, evidenceHash: string, evidenceUri: string): Uint8Array;
 /** Emergency stop: the sending attestor can no longer grant new attestations. Only a governance vote lifts it. */
 export declare function encodeBlockAttestor(): Uint8Array;
+/**
+ * Atomic delivery-versus-payment. The sender (initiator) delivers `giveAmount` of `give` to `counterparty`, who delivers
+ * `takeAmount` of `take` back, both legs or neither. `"native"` is IUM; `{ asset }` is an RWA asset or a token ref.
+ */
+export type DvpOrder = {
+    give: SpendAsset;
+    giveAmount: bigint;
+    counterparty: string;
+    take: SpendAsset;
+    takeAmount: bigint;
+    expiresAt: bigint;
+};
+/** `DvpTerms.domain`: no `ActionPayload` can start with it, so a consent never doubles as an ordinary action signature. */
+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`.
+ */
+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;
 /** `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;

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,7 @@ 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,
 };
 /** `ActionPayload::Token(TokenAction)` is variant 39; these are `TokenAction`'s own discriminants, written after it. */
 export const TOKEN_ACTION = 39;
@@ -79,6 +79,30 @@ 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;
+/**
+ * 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`.
+ */
+export function dvpConsentBytes(genesis, initiator, order, counterpartyNonce) {
+    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);
+    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 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);
+    return w.bytes();
+}
 /** `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. */
@@ -136,6 +160,7 @@ 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));
@@ -202,6 +227,7 @@ 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() }),

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, } 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,9 @@ 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>",
 };
+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 +160,7 @@ 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));
         default: return encodeRenounceMint(arg(0));
     }
 }
@@ -177,7 +180,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|query|verify");
     if (command === "keys") {
         const [operation, ...keyArgs] = rest;
         if (operation === "new") {
@@ -284,6 +287,19 @@ 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;
+    }
     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));
         if (command === "sign") {

package/dist/fees.js

@@ -20,6 +20,7 @@ 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,

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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arxiumlabs/sdk",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Arxium TypeScript SDK and arx CLI",
   "type": "module",
   "private": false,