@ar.io/sdk 3.24.0 → 4.0.0-solana.1

package/lib/esm/solana/send.js

@@ -0,0 +1,159 @@
+/**
+ * Shared helpers for building, signing, and sending Solana transactions
+ * with @solana/kit. Used by SolanaARIOWriteable and SolanaANTWriteable.
+ */
+import { address, appendTransactionMessageInstructions, compileTransaction, createTransactionMessage, getBase64EncodedWireTransaction, getSignatureFromTransaction, pipe, sendAndConfirmTransactionFactory, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, } from '@solana/kit';
+const COMPUTE_BUDGET_PROGRAM = address('ComputeBudget111111111111111111111111111111');
+/**
+ * Build a `SetComputeUnitLimit` instruction.
+ *
+ * Layout (per solana-program/compute-budget):
+ *   [0]     u8 = 2  (discriminator for SetComputeUnitLimit)
+ *   [1..5]  u32 LE = units
+ */
+export function setComputeUnitLimitIx(units) {
+    const data = new Uint8Array(5);
+    data[0] = 2;
+    // u32 little-endian
+    data[1] = units & 0xff;
+    data[2] = (units >>> 8) & 0xff;
+    data[3] = (units >>> 16) & 0xff;
+    data[4] = (units >>> 24) & 0xff;
+    return {
+        programAddress: COMPUTE_BUDGET_PROGRAM,
+        accounts: [],
+        data,
+    };
+}
+/**
+ * Build a `SetComputeUnitPrice` instruction.
+ *
+ * Layout (per solana-program/compute-budget):
+ *   [0]     u8 = 3  (discriminator for SetComputeUnitPrice)
+ *   [1..9]  u64 LE = micro-lamports per compute unit
+ *
+ * We always prepend this (alongside `SetComputeUnitLimit`) before sending,
+ * even with a 0 priority fee. Wallets like Phantom will silently *append*
+ * their own compute-budget instructions when the transaction is missing
+ * either, and that mutation invalidates any signatures already attached by
+ * paired keypair signers (e.g. the ANT mint signer in `spawnSolanaANT`),
+ * producing `Transaction did not pass signature verification` on the
+ * validator. Pre-supplying both keeps the wallet from rewriting the
+ * message, so signatures over the original bytes still verify.
+ */
+export function setComputeUnitPriceIx(microLamports) {
+    const lamports = typeof microLamports === 'bigint' ? microLamports : BigInt(microLamports);
+    const data = new Uint8Array(9);
+    data[0] = 3;
+    // u64 little-endian
+    let v = lamports;
+    for (let i = 0; i < 8; i++) {
+        data[1 + i] = Number(v & 0xffn);
+        v >>= 8n;
+    }
+    return {
+        programAddress: COMPUTE_BUDGET_PROGRAM,
+        accounts: [],
+        data,
+    };
+}
+/**
+ * Build, sign, send, and confirm a transaction in one call.
+ *
+ * The caller supplies the core instructions; a compute-unit-limit instruction
+ * is prepended automatically.
+ */
+export async function sendAndConfirm({ rpc, rpcSubscriptions, signer, instructions, commitment = 'confirmed', computeUnitLimit = 400_000, }) {
+    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+    const message = pipe(createTransactionMessage({ version: 0 }), (tx) => setTransactionMessageFeePayerSigner(signer, tx), (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), (tx) => appendTransactionMessageInstructions([
+        setComputeUnitLimitIx(computeUnitLimit),
+        // Always pin the priority fee (even at 0) so wallets like Phantom
+        // don't silently append their own compute-budget instructions and
+        // invalidate paired keypair-signer signatures. See
+        // `setComputeUnitPriceIx` doc comment for the full story.
+        setComputeUnitPriceIx(0n),
+        ...instructions,
+    ], tx));
+    const signedTx = await signTransactionMessageWithSigners(message);
+    const sendAndConfirmFactory = sendAndConfirmTransactionFactory({
+        rpc,
+        rpcSubscriptions,
+    });
+    // Cast narrows the transaction type to what sendAndConfirmFactory expects —
+    // the kit signer pipeline produces a fully-signed transaction with a blockhash
+    // lifetime, but the factory's argument type doesn't quite line up with the
+    // inferred union. The runtime object is correct.
+    try {
+        await sendAndConfirmFactory(signedTx, { commitment });
+    }
+    catch (err) {
+        logSolanaErrorContext(err);
+        await logSimulationDiagnostics(rpc, message, err);
+        throw err;
+    }
+    return getSignatureFromTransaction(signedTx);
+}
+/**
+ * Walk the chain of `cause`s on a thrown `SolanaError` and log each one's
+ * `.context` (kit packs the server-provided `err`, `logs`, `unitsConsumed`,
+ * etc. there). This usually contains the program logs we want without having
+ * to re-simulate.
+ */
+function logSolanaErrorContext(err) {
+    let current = err;
+    let depth = 0;
+    while (current && depth < 10) {
+        const e = current;
+        const ctx = e?.context;
+        if (ctx && typeof ctx === 'object') {
+            // eslint-disable-next-line no-console
+            console.warn(`[solana-send] error[${depth}] ${e.name ?? 'Error'}: ${e.message ?? ''}`, { context: ctx });
+            const logs = ctx.logs;
+            if (Array.isArray(logs) && logs.length > 0) {
+                // eslint-disable-next-line no-console
+                console.warn(`[solana-send] error[${depth}] program logs:\n` + logs.join('\n'));
+            }
+        }
+        current = e?.cause;
+        depth += 1;
+    }
+}
+/**
+ * On send/confirm failure, re-simulate the transaction with sig-verify off so
+ * we can surface program logs + the failed instruction index. Kit's default
+ * `SolanaError` only carries the bare `Custom program error: #N (instruction
+ * #M)` summary; we also log the full simulation result and the wire-format
+ * transaction so the underlying `msg!` lines and account list can be inspected
+ * in the browser console.
+ *
+ * Best-effort and side-effect free aside from console output.
+ */
+async function logSimulationDiagnostics(rpc, message, originalError) {
+    try {
+        const compiled = compileTransaction(message);
+        const wire = getBase64EncodedWireTransaction(compiled);
+        // eslint-disable-next-line no-console
+        console.warn('[solana-send] sendAndConfirm failed; re-running simulateTransaction for diagnostics', { error: originalError });
+        const sim = await rpc
+            .simulateTransaction(wire, {
+            sigVerify: false,
+            replaceRecentBlockhash: true,
+            encoding: 'base64',
+        })
+            .send();
+        // eslint-disable-next-line no-console
+        console.warn('[solana-send] simulateTransaction result:', sim.value);
+        if (sim.value.err) {
+            // eslint-disable-next-line no-console
+            console.warn('[solana-send] simulation err:', sim.value.err);
+        }
+        if (sim.value.logs) {
+            // eslint-disable-next-line no-console
+            console.warn('[solana-send] program logs:\n' + sim.value.logs.join('\n'));
+        }
+    }
+    catch (diagErr) {
+        // eslint-disable-next-line no-console
+        console.warn('[solana-send] failed to collect diagnostics', diagErr);
+    }
+}

package/lib/esm/solana/spawn-ant.js

@@ -0,0 +1,210 @@
+/**
+ * Solana implementation of `ANT.spawn`.
+ *
+ * Mints a fresh Metaplex Core asset (the ANT NFT) AND initializes the
+ * `ario-ant` extended state PDAs (`AntConfig`, `AntControllers`, root `@`
+ * record) in a single atomic transaction.
+ *
+ * This is the Solana counterpart to the legacy AO `spawnANT` flow:
+ * - AO: `ao.spawn({ module, scheduler, ... })` → returns AO process id.
+ * - Solana: mint MPL Core asset + initialize ario-ant PDAs → returns the
+ *   asset's pubkey (which serves as the SDK's stable `processId`).
+ *
+ * For the bulk-import flow used by `migration/import` we use a separate
+ * code path that mints to the migration authority and uses the gated
+ * `import_account` instruction — that's intentional and not what this SDK
+ * helper is for.
+ */
+import { addSignersToTransactionMessage, appendTransactionMessageInstructions, createTransactionMessage, generateKeyPairSigner, getSignatureFromTransaction, pipe, sendAndConfirmTransactionFactory, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, } from '@solana/kit';
+import { SolanaANTRegistryWriteable } from './ant-registry-writeable.js';
+import { ARIO_ANT_PROGRAM_ID } from './constants.js';
+import { getInitializeInstructionAsync } from './generated/ant/instructions/index.js';
+import { getCreateV1Instruction } from './generated/mpl-core/instructions/index.js';
+import { DataState } from './generated/mpl-core/types/index.js';
+import { getAntRecordPDA } from './pda.js';
+import { setComputeUnitLimitIx, setComputeUnitPriceIx } from './send.js';
+/** AR.IO logo Arweave TX — matches the Rust default in `ario_ant::initialize`. */
+export const ARIO_LOGO_TX_ID = 'AnYvLJTWcG9lr2Ll5MwYWZR2o5uTE39WbpYB0zCxwKM';
+/**
+ * Default Arweave transaction id used when an ANT is spawned without an
+ * explicit `transactionId`. Empty string would fail the on-chain
+ * `is_valid_arweave_id` check, so we fall back to the AR.IO logo TX (which is
+ * a real Arweave id and won't trip validation).
+ */
+export const DEFAULT_ANT_TRANSACTION_ID = ARIO_LOGO_TX_ID;
+/**
+ * Public, low-level builder for the `CreateV1` MPL Core instruction with the
+ * AR.IO-standard ANT shape (Attributes plugin pre-installed, Owner authority).
+ *
+ * Delegates to the Codama-generated `getCreateV1Instruction`, but accepts
+ * plain `Address`es (rather than full `TransactionSigner`s) so test fixtures
+ * and devnet validation scripts can byte-pin the wire format without
+ * standing up real keypairs. The signer roles still flow through correctly
+ * because we re-cast under `unknown`.
+ *
+ * Most callers should use `ANT.spawn` / `spawnSolanaANT` instead — that path
+ * also wires up `ario_ant::initialize` so the ANT is fully usable end to end.
+ * Use this raw builder when you need fine-grained control over signing, or
+ * are bundling the mint into a larger compound transaction.
+ *
+ * **Why we always emit an Attributes plugin (even with an empty list):**
+ * `ario_arns::buy_record` and friends CPI into `UpdatePluginV1` to populate
+ * traits at purchase time. If the asset has no Attributes plugin, that CPI
+ * fails. Emitting an empty plugin here keeps every spawned ANT
+ * `purchase`-ready and matches what `migration/import` mints — see ADR-012
+ * and BD-096. Authority is `Owner` so the ANT NFT holder (= asset owner)
+ * can sign their own trait updates.
+ */
+export function buildCreateAntInstruction({ mint, authority, payer, name, uri, attributes = [], }) {
+    // Codama wants TransactionSigners for asset/authority/payer because the
+    // resulting account meta is marked SIGNER. The byte-pinning surface we're
+    // exposing only cares about pubkeys + wire bytes, so we adapt by feeding
+    // it minimal signer-shaped objects.
+    const asSigner = (a) => ({ address: a, signTransactions: () => Promise.resolve([]) });
+    return getCreateV1Instruction({
+        asset: asSigner(mint),
+        authority: asSigner(authority),
+        payer: asSigner(payer),
+        dataState: DataState.AccountState,
+        name,
+        uri,
+        plugins: [
+            {
+                plugin: {
+                    __kind: 'Attributes',
+                    fields: [{ attributeList: attributes }],
+                },
+                authority: { __kind: 'Owner' },
+            },
+        ],
+    });
+}
+/**
+ * Build the `ario_ant::initialize` instruction for a freshly minted asset.
+ */
+async function buildInitializeAntIx({ programId, mint, signer, state, }) {
+    // Codama auto-resolves antConfig + antControllers PDAs. rootRecord uses a
+    // hashed-undername seed Codama can't infer from args, so we derive it here.
+    const [rootRecordPda] = await getAntRecordPDA(mint, '@', programId);
+    return getInitializeInstructionAsync({
+        asset: mint,
+        rootRecord: rootRecordPda,
+        owner: signer,
+        name: state.name,
+        ticker: state.ticker ?? null,
+        target: state.transactionId ?? DEFAULT_ANT_TRANSACTION_ID,
+        targetProtocol: state.targetProtocol ?? null,
+        logo: state.logo ?? '',
+        description: state.description ?? '',
+        keywords: state.keywords ?? [],
+    }, { programAddress: programId });
+}
+/**
+ * Spawn a brand-new ANT on Solana. Returns the asset address, which is the
+ * SDK's stable `processId` for that ANT.
+ */
+export async function spawnSolanaANT(params) {
+    if (!params.state?.name || params.state.name.length === 0) {
+        throw new Error('spawnSolanaANT: state.name is required');
+    }
+    const { rpc, rpcSubscriptions, signer, state, antProgramId = ARIO_ANT_PROGRAM_ID, commitment = 'confirmed', computeUnitLimit = 400_000, } = params;
+    const mintSigner = params.mintSigner ?? (await generateKeyPairSigner());
+    const owner = signer.address;
+    const mint = mintSigner.address;
+    const uri = state.uri ??
+        `ar://${state.logo && state.logo.length > 0 ? state.logo : ARIO_LOGO_TX_ID}`;
+    // Emit the Attributes plugin (Owner authority) at mint time with the
+    // asset-side `ANT Program` entry pre-installed. Two reasons to always
+    // include it:
+    //
+    //   1. ADR-016 / BD-100 — the program managing this asset's per-mint
+    //      state PDAs is named on the asset itself. Writing it here means
+    //      every fresh ANT carries an explicit, queryable program id from
+    //      the moment it's minted; resolvers can read it without a lookup
+    //      against any external registry.
+    //   2. The Attributes plugin must already exist before
+    //      `ario_arns::buy_name` CPIs into `UpdatePluginV1` to populate
+    //      ARNS Name / Type / Undername Limit. Skipping this returns
+    //      MPL Core 0x4 ("Plugin not found") at ArNS purchase time.
+    //
+    // Default value is the canonical `ARIO_ANT_PROGRAM_ID`; passing
+    // `antProgramId` opts into the BYO-ANT (third-party) path.
+    const createIx = getCreateV1Instruction({
+        asset: mintSigner,
+        payer: signer,
+        authority: signer,
+        dataState: DataState.AccountState,
+        name: state.name,
+        uri,
+        plugins: [
+            {
+                plugin: {
+                    __kind: 'Attributes',
+                    fields: [
+                        {
+                            attributeList: [
+                                { key: 'ANT Program', value: antProgramId },
+                            ],
+                        },
+                    ],
+                },
+                authority: { __kind: 'Owner' },
+            },
+        ],
+    });
+    const initIx = await buildInitializeAntIx({
+        programId: antProgramId,
+        mint,
+        signer,
+        state,
+    });
+    // ADR-012 (ACL): bootstrap the new owner's paginated ACL. The
+    // contract's `initialize` handler seeds `ant_controllers = vec![owner]`
+    // (matches the Lua source), so the owner needs entries under both
+    // `Owner` (for "ANTs I own" lookups) and `Controller` (for "ANTs I
+    // can manage" lookups). Bundling here keeps the ACL atomic with the
+    // spawn — by the time the tx confirms, frontends can resolve the
+    // owner's ANT list via the head config + paged accounts.
+    const registry = new SolanaANTRegistryWriteable({
+        rpc,
+        signer,
+        commitment,
+        antProgramId,
+    });
+    const aclIxs = await registry.bootstrapOwnerOnSpawn({
+        owner,
+        asset: mint,
+    });
+    // The create instruction has two signers (mint + authority+payer). Kit picks
+    // them up from the account metadata roles: accounts marked as SIGNER roles
+    // must have a matching `TransactionSigner` attached. We do that by placing
+    // the mint signer on the message alongside the fee payer signer.
+    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+    const message = pipe(createTransactionMessage({ version: 0 }), (tx) => setTransactionMessageFeePayerSigner(signer, tx), (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), (tx) => appendTransactionMessageInstructions([
+        setComputeUnitLimitIx(computeUnitLimit),
+        // Pin the priority fee (at 0) so wallets like Phantom don't
+        // silently append their own compute-budget instructions and
+        // invalidate the paired mint keypair signer's signature. See
+        // `setComputeUnitPriceIx` for the full story.
+        setComputeUnitPriceIx(0n),
+        createIx,
+        initIx,
+        ...aclIxs,
+    ], tx));
+    // Attach the mint signer so kit can satisfy the WRITABLE_SIGNER role on the
+    // mint account. `addSignersToTransactionMessage` walks the message's account
+    // metas and registers each matching signer by address, which is what
+    // `signTransactionMessageWithSigners` then looks up to produce signatures.
+    const withMintSigner = addSignersToTransactionMessage([mintSigner], message);
+    const signedTx = await signTransactionMessageWithSigners(withMintSigner);
+    const sendAndConfirmFactory = sendAndConfirmTransactionFactory({
+        rpc,
+        rpcSubscriptions,
+    });
+    await sendAndConfirmFactory(signedTx, { commitment });
+    return {
+        processId: mint,
+        mint,
+        signature: getSignatureFromTransaction(signedTx),
+    };
+}

package/lib/esm/solana/types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/types/ant.js

@@ -45,11 +45,23 @@ export const IntegerStringSchema = z
     const num = parseInt(val);
     return Number.isInteger(num) && num >= 0;
 }, { message: 'Must be a non negative integer string' });
-export const AntDescriptionSchema = z.string(); // TODO: add specific limits for description ie max length
-export const AntKeywordsSchema = z.array(z.string()); // TODO: add specific limits for keywords ie max amount and max length
+export const AntDescriptionSchema = z.string().max(256, {
+    message: 'ANT description must be at most 256 characters',
+});
+export const AntKeywordsSchema = z
+    .array(z.string().max(32, {
+    message: 'Each keyword must be at most 32 characters',
+}))
+    .max(8, { message: 'ANT can have at most 8 keywords' });
 export const AntRecordSchema = z.object({
-    transactionId: ArweaveTxIdSchema.describe('The Target ID of the undername'),
+    transactionId: z
+        .string()
+        .describe('Content target (Arweave TX ID, IPFS CID, etc.)'),
     ttlSeconds: z.number(),
+    targetProtocol: z
+        .number()
+        .describe('Storage protocol: 0 = Arweave, 1 = IPFS')
+        .default(0),
     priority: z.number().optional(),
     owner: AOAddressSchema.describe('The owner address of the record').optional(),
     displayName: z
@@ -60,13 +72,13 @@ export const AntRecordSchema = z.object({
     logo: ArweaveTxIdSchema.describe('Logo transaction ID for the record').optional(),
     description: z
         .string()
-        .max(512)
-        .describe('Description of the record (max 512 chars)')
+        .max(256)
+        .describe('Description of the record (max 256 chars)')
         .optional(),
     keywords: z
         .array(z.string().max(32))
-        .max(16)
-        .describe('Keywords array (max 16, each max 32 chars)')
+        .max(8)
+        .describe('Keywords array (max 8, each max 32 chars)')
         .optional(),
 });
 export const AntRecordsSchema = z.record(z.string(), AntRecordSchema);

package/lib/esm/types/io.js

@@ -22,7 +22,14 @@ export const intentsUsingYears = [
 export const isValidIntent = (intent) => {
     return validIntents.indexOf(intent) !== -1;
 };
-export const fundFromOptions = ['balance', 'stakes', 'any', 'turbo'];
+export const fundFromOptions = [
+    'balance',
+    'stakes',
+    'withdrawal',
+    'plan',
+    'any',
+    'turbo',
+];
 export const isValidFundFrom = (fundFrom) => {
     return fundFromOptions.indexOf(fundFrom) !== -1;
 };

package/lib/esm/utils/ant.js

@@ -88,6 +88,7 @@ export const convertHyperBeamStateToAoANTState = (initialState) => {
             acc[key] = {
                 transactionId: record.transactionid,
                 ttlSeconds: record.ttlseconds,
+                targetProtocol: 0,
                 ...(record.priority !== undefined
                     ? { priority: record.priority }
                     : {}),

package/lib/esm/utils/ao.js

@@ -367,6 +367,7 @@ export function initANTStateForAddress({ owner, targetId, ttlSeconds = 3600, key
             ['@']: {
                 transactionId: targetId ?? defaultTargetManifestId.toString(),
                 ttlSeconds,
+                targetProtocol: 0,
             },
         },
         logo,

package/lib/esm/version.js

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-export const version = '3.24.0';
+export const version = '4.0.0-solana.1';

package/lib/types/cli/commands/antCommands.d.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { AoANTSetBaseNameRecordParams, AoANTSetUndernameRecordParams } from '../../types/ant.js';
-import { CLIWriteOptionsFromAoAntParams } from '../types.js';
+import { CLIWriteOptionsFromAoAntParams, JsonSerializable } from '../types.js';
 /** @deprecated -- use set-ant-base-name and set-ant-undername */
 export declare function setAntRecordCLICommand(o: CLIWriteOptionsFromAoAntParams<AoANTSetUndernameRecordParams>): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
 export declare function setAntBaseNameCLICommand(o: CLIWriteOptionsFromAoAntParams<AoANTSetBaseNameRecordParams>): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
@@ -24,10 +24,5 @@ export declare function transferRecordOwnershipCLICommand(o: CLIWriteOptionsFrom
     recipient: string;
 }>): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
 export declare function upgradeAntCLICommand(o: CLIWriteOptionsFromAoAntParams<Record<string, unknown>>): Promise<{
-    forkedProcessId: string;
-    reassignedNames: Record<string, import("../../types/common.js").AoMessageResult>;
-    failedReassignedNames: Record<string, {
-        id?: string;
-        error: string;
-    }>;
+    [key: string]: JsonSerializable;
 }>;

package/lib/types/cli/commands/arnsPurchaseCommands.d.ts

@@ -8,3 +8,15 @@ export declare function requestPrimaryNameCLICommand(o: CLIWriteOptionsFromAoPar
     initiator: import("../../types/common.js").WalletAddress;
 }>;
 export declare function setPrimaryNameCLICommand(o: CLIWriteOptionsFromAoParams<AoArNSPurchaseParams>): Promise<import("../../types/common.js").AoMessageResult>;
+/**
+ * Reconcile the on-chain ANT Attributes plugin (`ArNS Name`, `Type`,
+ * `Undername Limit`) with the current `ArnsRecord` state. Permissionless,
+ * Solana-only; AO backend will throw with a clear error.
+ *
+ * Use after a `buy-record` / `reassign-name` where the buyer/recipient was
+ * not the ANT NFT holder (the ANT-side trait CPI gets skipped at runtime
+ * in that case so the plugin stays empty until the actual holder reconciles).
+ */
+export declare function syncAttributesCLICommand(o: CLIWriteOptionsFromAoParams<{
+    name: string;
+}>): Promise<import("../../types/common.js").AoMessageResult>;

package/lib/types/cli/commands/escrowCommands.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * CLI commands for `ario-ant-escrow` — trustless multi-protocol ANT custody.
+ *
+ * Each command instantiates an {@link ANTEscrow} with options-driven RPC +
+ * signer wiring (mirrors the rest of the Solana CLI surface — see
+ * `arnsPurchaseCommands.ts`). All read commands work without a signer; all
+ * write commands require `--wallet-file` or `--private-key`.
+ *
+ * Recipient pubkey loading:
+ * - Arweave: `--recipient-arweave <jwk-file>` reads the JWK JSON, decodes
+ *   the base64url `n` field to 512 raw bytes (RSA-4096 modulus).
+ * - Ethereum: `--recipient-ethereum 0x...` parses the 20-byte hex address.
+ */
+import type { JsonSerializable } from '../types.js';
+interface EscrowGlobalOptions {
+    rpcUrl?: string;
+    walletFile?: string;
+    privateKey?: string;
+    escrowProgramId?: string;
+}
+interface AntMintOptions extends EscrowGlobalOptions {
+    ant?: string;
+}
+interface DepositOptions extends AntMintOptions {
+    recipientArweave?: string;
+    recipientEthereum?: string;
+}
+interface UpdateRecipientOptions extends AntMintOptions {
+    newRecipientArweave?: string;
+    newRecipientEthereum?: string;
+}
+interface ClaimArweaveOptions extends AntMintOptions {
+    signatureFile?: string;
+    saltLen?: string;
+    claimant?: string;
+}
+interface ClaimEthereumOptions extends AntMintOptions {
+    signatureFile?: string;
+    claimant?: string;
+}
+/** `ar.io escrow status --ant <mint>` */
+export declare function escrowStatusCLICommand(o: AntMintOptions): Promise<JsonSerializable>;
+/** `ar.io escrow deposit --ant <mint> --recipient-{arweave|ethereum} ...` */
+export declare function escrowDepositCLICommand(o: DepositOptions): Promise<JsonSerializable>;
+/** `ar.io escrow cancel --ant <mint>` */
+export declare function escrowCancelCLICommand(o: AntMintOptions): Promise<JsonSerializable>;
+/** `ar.io escrow update-recipient --ant <mint> --new-recipient-{arweave|ethereum} ...` */
+export declare function escrowUpdateRecipientCLICommand(o: UpdateRecipientOptions): Promise<JsonSerializable>;
+/** `ar.io escrow claim-arweave --ant <mint> --signature-file <bin> --claimant <pubkey> [--salt-len 32]` */
+export declare function escrowClaimArweaveCLICommand(o: ClaimArweaveOptions): Promise<JsonSerializable>;
+/** `ar.io escrow claim-ethereum --ant <mint> --signature-file <bin> --claimant <pubkey>` */
+export declare function escrowClaimEthereumCLICommand(o: ClaimEthereumOptions): Promise<JsonSerializable>;
+export {};

package/lib/types/cli/commands/readCommands.d.ts

@@ -75,4 +75,6 @@ export declare function resolveArNSName(o: NameCLIOptions): Promise<import("../.
 export declare function listAntsForAddress(o: AddressCLIOptions): Promise<{
     Owned: string[];
     Controlled: string[];
+} | {
+    message: string;
 }>;