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

package/lib/esm/cli/commands/escrowCommands.js

@@ -0,0 +1,208 @@
+/**
+ * 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 { readFileSync } from 'node:fs';
+import { address, createKeyPairSignerFromBytes, createSolanaRpc, createSolanaRpcSubscriptions, } from '@solana/kit';
+import bs58 from 'bs58';
+import { ARIO_ANT_ESCROW_PROGRAM_ID } from '../../solana/constants.js';
+import { ANTEscrow } from '../../solana/escrow.js';
+// =========================================
+// Wiring helpers
+// =========================================
+function wsUrlFromRpcUrl(rpcUrl) {
+    return rpcUrl.replace(/^http/, 'ws');
+}
+function escrowProgramIdFrom(options) {
+    return options.escrowProgramId
+        ? address(options.escrowProgramId)
+        : ARIO_ANT_ESCROW_PROGRAM_ID;
+}
+async function readEscrowReader(options) {
+    const rpcUrl = options.rpcUrl ?? 'https://api.mainnet-beta.solana.com';
+    return ANTEscrow.init({
+        rpc: createSolanaRpc(rpcUrl),
+        programId: escrowProgramIdFrom(options),
+    });
+}
+async function writeEscrowFromOptions(options) {
+    let secretKey;
+    if (options.privateKey) {
+        secretKey = bs58.decode(options.privateKey);
+    }
+    else if (options.walletFile) {
+        const raw = readFileSync(options.walletFile, 'utf-8');
+        secretKey = new Uint8Array(JSON.parse(raw));
+    }
+    else {
+        throw new Error('escrow write operations require a signer. Provide --wallet-file <path> or --private-key <base58>');
+    }
+    const signer = await createKeyPairSignerFromBytes(secretKey);
+    const rpcUrl = options.rpcUrl ?? 'https://api.mainnet-beta.solana.com';
+    return ANTEscrow.init({
+        rpc: createSolanaRpc(rpcUrl),
+        rpcSubscriptions: createSolanaRpcSubscriptions(wsUrlFromRpcUrl(rpcUrl)),
+        signer,
+        programId: escrowProgramIdFrom(options),
+    });
+}
+// =========================================
+// Recipient pubkey parsing
+// =========================================
+function base64UrlDecode(s) {
+    // Convert base64url → base64, then decode.
+    let b64 = s.replace(/-/g, '+').replace(/_/g, '/');
+    while (b64.length % 4 !== 0)
+        b64 += '=';
+    return new Uint8Array(Buffer.from(b64, 'base64'));
+}
+/** Load an Arweave RSA-4096 modulus from a JWK file (`.json` with `n` field). */
+function loadArweaveModulusFromJwk(filePath) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const jwk = JSON.parse(raw);
+    if (jwk.kty !== 'RSA' || !jwk.n) {
+        throw new Error(`Not a valid Arweave RSA JWK (missing kty=RSA or n field)`);
+    }
+    const modulus = base64UrlDecode(jwk.n);
+    if (modulus.length !== 512) {
+        throw new Error(`Arweave modulus must be 512 bytes (4096-bit RSA); got ${modulus.length}`);
+    }
+    return modulus;
+}
+/** Parse an Ethereum address (`0xabc...`) into 20 raw bytes. */
+function parseEthereumAddress(hex) {
+    const cleaned = hex.startsWith('0x') ? hex.slice(2) : hex;
+    if (cleaned.length !== 40 || !/^[0-9a-fA-F]+$/.test(cleaned)) {
+        throw new Error(`Ethereum address must be 0x-prefixed 40-char hex; got "${hex}"`);
+    }
+    return Uint8Array.from(Buffer.from(cleaned, 'hex'));
+}
+function recipientFromDepositOptions(o) {
+    if (o.recipientArweave && o.recipientEthereum) {
+        throw new Error('--recipient-arweave and --recipient-ethereum are mutually exclusive');
+    }
+    if (o.recipientArweave) {
+        return {
+            protocol: 'arweave',
+            publicKey: loadArweaveModulusFromJwk(o.recipientArweave),
+        };
+    }
+    if (o.recipientEthereum) {
+        return {
+            protocol: 'ethereum',
+            publicKey: parseEthereumAddress(o.recipientEthereum),
+        };
+    }
+    throw new Error('one of --recipient-arweave or --recipient-ethereum is required');
+}
+function recipientFromUpdateOptions(o) {
+    return recipientFromDepositOptions({
+        recipientArweave: o.newRecipientArweave,
+        recipientEthereum: o.newRecipientEthereum,
+    });
+}
+function antFromOptions(o) {
+    if (!o.ant)
+        throw new Error('--ant <mint> is required');
+    return address(o.ant);
+}
+// =========================================
+// CLI handlers
+// =========================================
+/** `ar.io escrow status --ant <mint>` */
+export async function escrowStatusCLICommand(o) {
+    const escrow = await readEscrowReader(o);
+    const ant = antFromOptions(o);
+    const state = await escrow.get(ant);
+    if (!state) {
+        return { active: false, antMint: ant };
+    }
+    return {
+        active: true,
+        antMint: state.antMint,
+        depositor: state.depositor,
+        recipientProtocol: state.recipientProtocol,
+        recipientPubkeyHex: Buffer.from(state.recipientPubkey).toString('hex'),
+        nonceHex: Buffer.from(state.nonce).toString('hex'),
+        depositSlot: state.depositSlot.toString(),
+        version: state.version,
+    };
+}
+/** `ar.io escrow deposit --ant <mint> --recipient-{arweave|ethereum} ...` */
+export async function escrowDepositCLICommand(o) {
+    const recipient = recipientFromDepositOptions(o);
+    const escrow = await writeEscrowFromOptions(o);
+    const sig = await escrow.deposit({ antMint: antFromOptions(o), recipient });
+    return { signature: sig };
+}
+/** `ar.io escrow cancel --ant <mint>` */
+export async function escrowCancelCLICommand(o) {
+    const escrow = await writeEscrowFromOptions(o);
+    const sig = await escrow.cancel({ antMint: antFromOptions(o) });
+    return { signature: sig };
+}
+/** `ar.io escrow update-recipient --ant <mint> --new-recipient-{arweave|ethereum} ...` */
+export async function escrowUpdateRecipientCLICommand(o) {
+    const newRecipient = recipientFromUpdateOptions(o);
+    const escrow = await writeEscrowFromOptions(o);
+    const sig = await escrow.updateRecipient({
+        antMint: antFromOptions(o),
+        newRecipient,
+    });
+    return { signature: sig };
+}
+/** `ar.io escrow claim-arweave --ant <mint> --signature-file <bin> --claimant <pubkey> [--salt-len 32]` */
+export async function escrowClaimArweaveCLICommand(o) {
+    if (!o.signatureFile)
+        throw new Error('--signature-file <path> is required');
+    if (!o.claimant)
+        throw new Error('--claimant <pubkey> is required');
+    const sigBytes = new Uint8Array(readFileSync(o.signatureFile));
+    if (sigBytes.length !== 512) {
+        throw new Error(`signature file must be 512 bytes; got ${sigBytes.length}`);
+    }
+    const escrow = await writeEscrowFromOptions(o);
+    const sig = await escrow.claimArweave({
+        antMint: antFromOptions(o),
+        claimant: address(o.claimant),
+        signature: sigBytes,
+        saltLen: o.saltLen ? Number(o.saltLen) : 32,
+    });
+    return { signature: sig };
+}
+/** `ar.io escrow claim-ethereum --ant <mint> --signature-file <bin> --claimant <pubkey>` */
+export async function escrowClaimEthereumCLICommand(o) {
+    if (!o.signatureFile)
+        throw new Error('--signature-file <path> is required');
+    if (!o.claimant)
+        throw new Error('--claimant <pubkey> is required');
+    const sigBytes = new Uint8Array(readFileSync(o.signatureFile));
+    if (sigBytes.length !== 65) {
+        throw new Error(`signature file must be 65 bytes (r||s||v); got ${sigBytes.length}`);
+    }
+    const escrow = await writeEscrowFromOptions(o);
+    const sig = await escrow.claimEthereum({
+        antMint: antFromOptions(o),
+        claimant: address(o.claimant),
+        signature: sigBytes,
+    });
+    return { signature: sig };
+}

package/lib/esm/cli/commands/gatewayWriteCommands.js

@@ -17,7 +17,7 @@ import prompts from 'prompts';
 import { mARIOToken } from '../../node/index.js';
 import { assertConfirmationPrompt, assertEnoughMARIOBalance, customTagsFromOptions, formatARIOWithCommas, gatewaySettingsFromOptions, redelegateParamsFromOptions, requiredAddressFromOptions, requiredMARIOFromOptions, requiredStringArrayFromOptions, requiredStringFromOptions, requiredTargetAndQuantityFromOptions, stringifyJsonForCLIDisplay, writeARIOFromOptions, } from '../utils.js';
 export async function joinNetwork(options) {
-    const { ario, signerAddress } = writeARIOFromOptions(options);
+    const { ario, signerAddress } = await writeARIOFromOptions(options);
     const mARIOQuantity = requiredMARIOFromOptions(options, 'operatorStake');
     const settings = {
         ...gatewaySettingsFromOptions(options),
@@ -50,7 +50,7 @@ export async function joinNetwork(options) {
     return output;
 }
 export async function updateGatewaySettings(options) {
-    const { ario, signerAddress } = writeARIOFromOptions(options);
+    const { ario, signerAddress } = await writeARIOFromOptions(options);
     const gatewaySettings = gatewaySettingsFromOptions(options);
     if (Object.keys(gatewaySettings).length === 0) {
         // TODO: The contract accepts empty Update-Gateway-Settings actions, but we'll throw in the CLI for now
@@ -66,7 +66,7 @@ export async function updateGatewaySettings(options) {
     return output;
 }
 export async function leaveNetwork(options) {
-    const { ario, signerAddress } = writeARIOFromOptions(options);
+    const { ario, signerAddress } = await writeARIOFromOptions(options);
     if (!options.skipConfirmation) {
         const gateway = await ario.getGateway({ address: signerAddress });
         await assertConfirmationPrompt('Gateway Details:\n\n' +
@@ -74,13 +74,13 @@ export async function leaveNetwork(options) {
             '\n\n' +
             'Are you sure you want to leave the AR.IO network?', options);
     }
-    return writeARIOFromOptions(options).ario.leaveNetwork(customTagsFromOptions(options));
+    return (await writeARIOFromOptions(options)).ario.leaveNetwork(customTagsFromOptions(options));
 }
 export async function saveObservations(o) {
     const failedGateways = requiredStringArrayFromOptions(o, 'failedGateways');
     const reportTxId = requiredStringFromOptions(o, 'transactionId');
     await assertConfirmationPrompt(`You are about to save the following failed gateways to the AR.IO network:\n\n${failedGateways.join('\n')}\n\nTransaction ID: ${reportTxId}\n\nAre you sure?`, o);
-    return writeARIOFromOptions(o).ario.saveObservations({
+    return (await writeARIOFromOptions(o)).ario.saveObservations({
         failedGateways: requiredStringArrayFromOptions(o, 'failedGateways'),
         reportTxId: requiredStringFromOptions(o, 'transactionId'),
     }, customTagsFromOptions(o));
@@ -88,15 +88,30 @@ export async function saveObservations(o) {
 export async function increaseOperatorStake(o) {
     const increaseQty = requiredMARIOFromOptions(o, 'operatorStake');
     await assertConfirmationPrompt(`You are about to increase your operator stake by ${formatARIOWithCommas(increaseQty.toARIO())} ARIO\nAre you sure?`, o);
-    return writeARIOFromOptions(o).ario.increaseOperatorStake({
+    return (await writeARIOFromOptions(o)).ario.increaseOperatorStake({
         increaseQty,
     }, customTagsFromOptions(o));
 }
 export async function decreaseOperatorStake(o) {
+    const { ario, signerAddress } = await writeARIOFromOptions(o);
     const decreaseQty = requiredMARIOFromOptions(o, 'operatorStake');
-    // TODO: Can assert stake is sufficient for action, and new target stake meets contract minimum
+    if (!o.skipConfirmation) {
+        const gateway = await ario.getGateway({ address: signerAddress });
+        if (gateway === undefined) {
+            throw new Error(`No gateway found for address ${signerAddress}. You must be a gateway operator to decrease stake.`);
+        }
+        const settings = await ario.getGatewayRegistrySettings();
+        const currentStake = gateway.operatorStake;
+        const remaining = currentStake - decreaseQty.valueOf();
+        if (remaining < 0) {
+            throw new Error(`Insufficient operator stake. Current: ${formatARIOWithCommas(new mARIOToken(currentStake).toARIO())} ARIO, requested decrease: ${formatARIOWithCommas(decreaseQty.toARIO())} ARIO`);
+        }
+        if (remaining > 0 && remaining < settings.operators.minStake) {
+            throw new Error(`Remaining stake (${formatARIOWithCommas(new mARIOToken(remaining).toARIO())} ARIO) would be below minimum (${formatARIOWithCommas(new mARIOToken(settings.operators.minStake).toARIO())} ARIO). Decrease to exactly 0 (after calling leave-network) or keep above the minimum.`);
+        }
+    }
     await assertConfirmationPrompt(`You are about to decrease your operator stake by ${formatARIOWithCommas(decreaseQty.toARIO())} ARIO\nAre you sure?`, o);
-    return writeARIOFromOptions(o).ario.decreaseOperatorStake({
+    return ario.decreaseOperatorStake({
         decreaseQty,
     }, customTagsFromOptions(o));
 }
@@ -104,7 +119,7 @@ export async function instantWithdrawal(o) {
     const vaultId = requiredStringFromOptions(o, 'vaultId');
     const gatewayAddress = requiredAddressFromOptions(o);
     await assertConfirmationPrompt(`You are about to instantly withdraw from vault ${vaultId} for with gateway address ${gatewayAddress}\nAre you sure?`, o);
-    return writeARIOFromOptions(o).ario.instantWithdrawal({
+    return (await writeARIOFromOptions(o)).ario.instantWithdrawal({
         vaultId,
         gatewayAddress,
     }, customTagsFromOptions(o));
@@ -113,13 +128,13 @@ export async function cancelWithdrawal(o) {
     const vaultId = requiredStringFromOptions(o, 'vaultId');
     const gatewayAddress = requiredAddressFromOptions(o);
     await assertConfirmationPrompt(`You are about to cancel the pending withdrawal from vault ${vaultId} for with gateway address ${gatewayAddress}\nAre you sure?`, o);
-    return writeARIOFromOptions(o).ario.cancelWithdrawal({
+    return (await writeARIOFromOptions(o)).ario.cancelWithdrawal({
         vaultId,
         gatewayAddress,
     }, customTagsFromOptions(o));
 }
 export async function delegateStake(options) {
-    const { ario, signerAddress } = writeARIOFromOptions(options);
+    const { ario, signerAddress } = await writeARIOFromOptions(options);
     const { target, arioQuantity } = requiredTargetAndQuantityFromOptions(options);
     const mARIOQuantity = arioQuantity.toMARIO();
     if (!options.skipConfirmation) {
@@ -134,8 +149,59 @@ export async function delegateStake(options) {
         if (targetGateway.settings.allowDelegatedStaking === false) {
             throw new Error(`Gateway does not allow delegated staking: ${target}`);
         }
-        // TODO: could get allow list and assert doesn't exist or user is on it
-        // TODO: could read from contract to get current delegated stake if there is none, get contract minimum delegated stake. Then see if the new stake value will satisfy minimum delegated stake for both the target gateway settings min delegate stake and contract min delegated amounts
+        // Check allowlist if gateway restricts delegation. `allowDelegatedStaking`
+        // is `boolean | 'allowlist'`; the SDK maps `allowlist_enabled = true` on
+        // Solana to the `'allowlist'` variant (see deserialize.ts).
+        //
+        // `getGatewayDelegateAllowList` returns `PaginationResult<WalletAddress>`,
+        // so we walk pages by cursor — the previous shape (plain `string[]`) was
+        // never the actual return type and made the membership check dead code.
+        //
+        // Note: the on-chain delegate handler also lets you bypass the allowlist
+        // if you already have stake > 0 with this gateway (delegate.rs). We
+        // can't easily check that client-side, so this preflight surfaces the
+        // most common case (new-delegator-not-on-list) but falls through any
+        // unexpected error to let the on-chain check arbitrate.
+        if (targetGateway.settings.allowDelegatedStaking === 'allowlist') {
+            try {
+                let cursor;
+                let onAllowlist = false;
+                let allowlistHasEntries = false;
+                do {
+                    const page = await ario.getGatewayDelegateAllowList({
+                        address: target,
+                        limit: 1_000,
+                        cursor,
+                    });
+                    if (page.items.length > 0)
+                        allowlistHasEntries = true;
+                    if (page.items.includes(signerAddress)) {
+                        onAllowlist = true;
+                        break;
+                    }
+                    cursor = page.nextCursor;
+                } while (cursor);
+                if (allowlistHasEntries && !onAllowlist) {
+                    throw new Error(`You (${signerAddress}) are not on the delegation allowlist for gateway ${target}.`);
+                }
+            }
+            catch (e) {
+                // Re-throw our own "not on allowlist" error; swallow anything else
+                // so the on-chain check can produce the canonical failure.
+                if (e instanceof Error &&
+                    e.message.includes('not on the delegation allowlist')) {
+                    throw e;
+                }
+            }
+        }
+        // Validate minimum delegation amount
+        const settings = await ario.getGatewayRegistrySettings();
+        const contractMinDelegation = settings.delegates.minStake;
+        const gatewayMinDelegation = targetGateway.settings.minDelegatedStake ?? contractMinDelegation;
+        const effectiveMin = Math.max(contractMinDelegation, gatewayMinDelegation);
+        if (mARIOQuantity.valueOf() < effectiveMin) {
+            throw new Error(`Delegation amount (${formatARIOWithCommas(arioQuantity)} ARIO) is below minimum (${formatARIOWithCommas(new mARIOToken(effectiveMin).toARIO())} ARIO).`);
+        }
         const { confirm } = await prompts({
             type: 'confirm',
             name: 'confirm',
@@ -157,13 +223,40 @@ export async function delegateStake(options) {
     return output;
 }
 export async function decreaseDelegateStake(options) {
-    const ario = writeARIOFromOptions(options).ario;
+    const ario = await (await writeARIOFromOptions(options)).ario;
     const { target, arioQuantity } = requiredTargetAndQuantityFromOptions(options);
     const instant = options.instant ?? false;
-    // TODO: Could assert sender is a delegate with enough stake to decrease
-    // TODO: Could assert new target stake meets contract and target gateway minimums
-    // TODO: Could present confirmation prompt with any fee for instant withdrawal (50% of the stake is put back into protocol??)
-    await assertConfirmationPrompt(`Are you sure you'd like to decrease delegated stake of ${formatARIOWithCommas(arioQuantity)} ARIO on gateway ${target}?`, options);
+    if (!options.skipConfirmation) {
+        // Verify the target gateway exists and look up delegation
+        const signerAddr = (await writeARIOFromOptions(options)).signerAddress;
+        const targetGateway = await ario.getGateway({ address: target });
+        if (targetGateway === undefined) {
+            throw new Error(`Gateway not found: ${target}`);
+        }
+        // Find delegation to this gateway
+        const delegations = await ario.getDelegations({ address: signerAddr });
+        const delegation = delegations.items.find((d) => d.gatewayAddress === target && d.type === 'stake');
+        if (!delegation) {
+            throw new Error(`No active delegation found for you on gateway ${target}.`);
+        }
+        if (arioQuantity.toMARIO().valueOf() > delegation.balance) {
+            throw new Error(`Cannot decrease by ${formatARIOWithCommas(arioQuantity)} ARIO — you only have ${formatARIOWithCommas(new mARIOToken(delegation.balance).toARIO())} ARIO delegated.`);
+        }
+        const remaining = delegation.balance - arioQuantity.toMARIO().valueOf();
+        if (remaining > 0) {
+            const registrySettings = await ario.getGatewayRegistrySettings();
+            const contractMin = registrySettings.delegates.minStake;
+            if (remaining < contractMin) {
+                throw new Error(`Remaining delegation (${formatARIOWithCommas(new mARIOToken(remaining).toARIO())} ARIO) would be below minimum (${formatARIOWithCommas(new mARIOToken(contractMin).toARIO())} ARIO). Decrease to exactly 0 or keep above the minimum.`);
+            }
+        }
+    }
+    if (instant) {
+        await assertConfirmationPrompt(`WARNING: Instant withdrawal incurs a penalty.\nAre you sure you'd like to instantly decrease delegated stake of ${formatARIOWithCommas(arioQuantity)} ARIO on gateway ${target}?`, options);
+    }
+    else {
+        await assertConfirmationPrompt(`Are you sure you'd like to decrease delegated stake of ${formatARIOWithCommas(arioQuantity)} ARIO on gateway ${target}?`, options);
+    }
     const result = await ario.decreaseDelegateStake({
         target,
         decreaseQty: arioQuantity.toMARIO(),
@@ -177,11 +270,28 @@ export async function decreaseDelegateStake(options) {
     return output;
 }
 export async function redelegateStake(options) {
-    const ario = writeARIOFromOptions(options).ario;
+    const ario = await (await writeARIOFromOptions(options)).ario;
     const params = redelegateParamsFromOptions(options);
-    // TODO: Could assert target gateway exists
-    // TODO: Could do assertion on source has enough stake to redelegate
-    // TODO: Could do assertions on source/target min delegate stakes are met
+    if (!options.skipConfirmation) {
+        const targetGateway = await ario.getGateway({ address: params.target });
+        if (targetGateway === undefined) {
+            throw new Error(`Target gateway not found: ${params.target}`);
+        }
+        if (targetGateway.settings.allowDelegatedStaking === false) {
+            throw new Error(`Target gateway ${params.target} does not allow delegated staking.`);
+        }
+        const sourceGateway = await ario.getGateway({ address: params.source });
+        if (sourceGateway === undefined) {
+            throw new Error(`Source gateway not found: ${params.source}`);
+        }
+        const signerAddr = (await writeARIOFromOptions(options)).signerAddress;
+        const delegations = await ario.getDelegations({ address: signerAddr });
+        const delegation = delegations.items.find((d) => d.gatewayAddress === params.source && d.type === 'stake');
+        if (!delegation || delegation.balance < params.stakeQty.valueOf()) {
+            const available = delegation?.balance ?? 0;
+            throw new Error(`Insufficient delegated stake on source gateway ${params.source}. Available: ${formatARIOWithCommas(new mARIOToken(available).toARIO())} ARIO, requested: ${formatARIOWithCommas(params.stakeQty.toARIO())} ARIO`);
+        }
+    }
     await assertConfirmationPrompt(`Are you sure you'd like to redelegate stake of ${formatARIOWithCommas(params.stakeQty.toARIO())} ARIO from ${params.source} to ${params.target}?`, options);
     const result = await ario.redelegateStake(params);
     const output = {

package/lib/esm/cli/commands/readCommands.js

@@ -182,8 +182,16 @@ export async function resolveArNSName(o) {
 }
 export async function listAntsForAddress(o) {
     const address = requiredAddressFromOptions(o);
-    const result = await readANTRegistryFromOptions(o).accessControlList({
+    // Both AO and Solana backends expose `accessControlList({ address })`.
+    // Solana is backed by the paginated per-user ACL (ADR-012): a head
+    // `AclConfig` PDA at ["acl_config", user] plus N `AclPage` PDAs at
+    // ["acl_page", user, page_idx_le]. The ario-ant program maintains them
+    // alongside `initialize`, `add_controller`, `remove_controller`,
+    // `transfer_record`, and the marketplace reconcile path.
+    const registry = await readANTRegistryFromOptions(o);
+    const result = await registry.accessControlList({
         address,
     });
-    return result ?? { message: `No ANTs found for address ${address}` };
+    const hasAny = result && (result.Owned.length > 0 || result.Controlled.length > 0);
+    return hasAny ? result : { message: `No ANTs found for address ${address}` };
 }

package/lib/esm/cli/commands/transfer.js

@@ -2,7 +2,7 @@ import { mARIOToken } from '../../types/token.js';
 import { assertEnoughMARIOBalance, assertLockLengthInRange, confirmationPrompt, customTagsFromOptions, formatARIOWithCommas, formatMARIOToARIOWithCommas, requiredMARIOFromOptions, requiredPositiveIntegerFromOptions, requiredStringFromOptions, requiredTargetAndQuantityFromOptions, writeARIOFromOptions, } from '../utils.js';
 export async function transferCLICommand(options) {
     const { target, arioQuantity } = requiredTargetAndQuantityFromOptions(options);
-    const { ario, signerAddress } = writeARIOFromOptions(options);
+    const { ario, signerAddress } = await writeARIOFromOptions(options);
     if (!options.skipConfirmation) {
         await assertEnoughMARIOBalance({
             ario,
@@ -28,7 +28,7 @@ export async function transferCLICommand(options) {
 export async function vaultedTransferCLICommand(o) {
     const mARIOQuantity = requiredMARIOFromOptions(o, 'quantity');
     const recipient = requiredStringFromOptions(o, 'recipient');
-    const { ario, signerAddress } = writeARIOFromOptions(o);
+    const { ario, signerAddress } = await writeARIOFromOptions(o);
     const lockLengthMs = requiredPositiveIntegerFromOptions(o, 'lockLengthMs');
     assertLockLengthInRange(lockLengthMs);
     if (!o.skipConfirmation) {
@@ -56,7 +56,7 @@ export async function vaultedTransferCLICommand(o) {
     return output;
 }
 export async function revokeVaultCLICommand(o) {
-    const { ario, signerAddress } = writeARIOFromOptions(o);
+    const { ario, signerAddress } = await writeARIOFromOptions(o);
     const vaultId = requiredStringFromOptions(o, 'vaultId');
     const recipient = requiredStringFromOptions(o, 'recipient');
     if (!o.skipConfirmation) {
@@ -79,7 +79,7 @@ export async function revokeVaultCLICommand(o) {
 }
 export async function createVaultCLICommand(o) {
     const mARIOQuantity = requiredMARIOFromOptions(o, 'quantity');
-    const { ario, signerAddress } = writeARIOFromOptions(o);
+    const { ario, signerAddress } = await writeARIOFromOptions(o);
     const lockLengthMs = requiredPositiveIntegerFromOptions(o, 'lockLengthMs');
     assertLockLengthInRange(lockLengthMs);
     if (!o.skipConfirmation) {
@@ -105,7 +105,7 @@ export async function createVaultCLICommand(o) {
     return output;
 }
 export async function extendVaultCLICommand(o) {
-    const { ario, signerAddress } = writeARIOFromOptions(o);
+    const { ario, signerAddress } = await writeARIOFromOptions(o);
     const vaultId = requiredStringFromOptions(o, 'vaultId');
     const extendLengthMs = requiredPositiveIntegerFromOptions(o, 'extendLengthMs');
     assertLockLengthInRange(extendLengthMs, false);
@@ -129,7 +129,7 @@ export async function extendVaultCLICommand(o) {
 }
 export async function increaseVaultCLICommand(o) {
     const mARIOQuantity = requiredMARIOFromOptions(o, 'quantity');
-    const { ario, signerAddress } = writeARIOFromOptions(o);
+    const { ario, signerAddress } = await writeARIOFromOptions(o);
     const vaultId = requiredStringFromOptions(o, 'vaultId');
     if (!o.skipConfirmation) {
         const vault = await ario.getVault({ vaultId, address: signerAddress });