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

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/pruneCommands.js

@@ -0,0 +1,166 @@
+import { assertConfirmationPrompt, requiredStringFromOptions, writeARIOFromOptions, } from '../utils.js';
+function rejectAoBackend(o, command) {
+    if (o.ao) {
+        throw new Error(`${command} is Solana-only — Lua's tick() handles the equivalent on AO. Drop --ao.`);
+    }
+}
+async function getSolanaWriter(o) {
+    const { ario } = await writeARIOFromOptions(o);
+    return ario;
+}
+function parseMaxNames(o) {
+    const raw = o.max;
+    if (raw === undefined) {
+        throw new Error('--max <count> is required (u8 batch size, 1-255)');
+    }
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 1 || n > 255) {
+        throw new Error(`--max must be an integer 1-255 (got ${raw})`);
+    }
+    return n;
+}
+// =========================================
+// ArNS prune
+// =========================================
+export async function pruneExpiredNamesCLICommand(o) {
+    rejectAoBackend(o, 'prune-expired-names');
+    const max = parseMaxNames(o);
+    const ario = await getSolanaWriter(o);
+    // If `--arns-records` wasn't provided, discover them via the readable's
+    // helper. Cap at `max` so we never overshoot the ix's u8 batch parameter.
+    let records = o.arnsRecords ?? [];
+    if (records.length === 0) {
+        const now = Math.floor(Date.now() / 1000);
+        const expired = await ario.getExpiredArnsRecords(now);
+        records = expired.slice(0, max).map((r) => r.pubkey);
+        if (records.length === 0) {
+            return { message: 'No expired ArnsRecords to prune' };
+        }
+    }
+    else {
+        records = records.slice(0, max);
+    }
+    await assertConfirmationPrompt(`Prune ${records.length} expired ArnsRecord(s)?`, o);
+    return ario.pruneExpiredNames({ maxNames: max, arnsRecords: records });
+}
+export async function pruneNameToReturnedCLICommand(o) {
+    rejectAoBackend(o, 'prune-name-to-returned');
+    const name = requiredStringFromOptions(o, 'name');
+    const ario = await getSolanaWriter(o);
+    await assertConfirmationPrompt(`Convert expired lease for "${name}" to a ReturnedName (Dutch auction)?`, o);
+    return ario.pruneNameToReturned({ name });
+}
+export async function pruneReturnedNamesCLICommand(o) {
+    rejectAoBackend(o, 'prune-returned-names');
+    const max = parseMaxNames(o);
+    const ario = await getSolanaWriter(o);
+    let returned = o.returnedNames ?? [];
+    if (returned.length === 0) {
+        const now = Math.floor(Date.now() / 1000);
+        const expired = await ario.getExpiredReturnedNames(now);
+        returned = expired.slice(0, max).map((r) => r.pubkey);
+        if (returned.length === 0) {
+            return { message: 'No expired ReturnedNames to prune' };
+        }
+    }
+    else {
+        returned = returned.slice(0, max);
+    }
+    await assertConfirmationPrompt(`Prune ${returned.length} expired ReturnedName(s)?`, o);
+    return ario.pruneReturnedNames({
+        maxNames: max,
+        returnedNames: returned,
+    });
+}
+export async function pruneExpiredReservationCLICommand(o) {
+    rejectAoBackend(o, 'prune-expired-reservation');
+    const name = requiredStringFromOptions(o, 'name');
+    const ario = await getSolanaWriter(o);
+    await assertConfirmationPrompt(`Close expired reservation for "${name}"?`, o);
+    return ario.pruneExpiredReservation({ name });
+}
+// =========================================
+// Gateway prune
+// =========================================
+export async function pruneGatewayCLICommand(o) {
+    rejectAoBackend(o, 'prune-gateway');
+    const gateway = requiredStringFromOptions(o, 'gateway');
+    const ario = await getSolanaWriter(o);
+    await assertConfirmationPrompt(`Slash + remove deficient gateway ${gateway}?`, o);
+    return ario.pruneGateway({ gateway });
+}
+export async function finalizeGoneCLICommand(o) {
+    rejectAoBackend(o, 'finalize-gone');
+    const gateway = requiredStringFromOptions(o, 'gateway');
+    const ario = await getSolanaWriter(o);
+    await assertConfirmationPrompt(`Finalize-GC departed gateway ${gateway} (reclaim PDA rent)?`, o);
+    return ario.finalizeGone({ gateway });
+}
+// =========================================
+// Rent reclaim
+// =========================================
+export async function closeObservationCLICommand(o) {
+    rejectAoBackend(o, 'close-observation');
+    const epochIndexStr = requiredStringFromOptions(o, 'epochIndex');
+    const observer = requiredStringFromOptions(o, 'observer');
+    const epochIndex = Number(epochIndexStr);
+    if (!Number.isInteger(epochIndex) || epochIndex < 0) {
+        throw new Error(`--epoch-index must be a non-negative integer (got ${epochIndexStr})`);
+    }
+    const ario = await getSolanaWriter(o);
+    await assertConfirmationPrompt(`Close Observation PDA (epoch ${epochIndex}, observer ${observer})?`, o);
+    return ario.closeObservation({ epochIndex, observer });
+}
+export async function closeEmptyDelegationCLICommand(o) {
+    rejectAoBackend(o, 'close-empty-delegation');
+    const gateway = requiredStringFromOptions(o, 'gateway');
+    const delegator = requiredStringFromOptions(o, 'delegator');
+    const ario = await getSolanaWriter(o);
+    await assertConfirmationPrompt(`Close empty Delegation PDA (gateway=${gateway}, delegator=${delegator})?`, o);
+    return ario.closeEmptyDelegation({ gateway, delegator });
+}
+export async function closeDrainedWithdrawalCLICommand(o) {
+    rejectAoBackend(o, 'close-drained-withdrawal');
+    const owner = requiredStringFromOptions(o, 'owner');
+    const withdrawalIdStr = requiredStringFromOptions(o, 'withdrawalId');
+    // Validate before BigInt() — `BigInt('0xff')` and `BigInt('  1  ')` succeed
+    // and `BigInt('abc')` throws an opaque SyntaxError. Restrict to the u64
+    // decimal form the on-chain seed encoder expects so the CLI fails with a
+    // clear message instead of a downstream parser error.
+    if (!/^\d+$/.test(withdrawalIdStr)) {
+        throw new Error(`--withdrawal-id must be a non-negative decimal integer (got "${withdrawalIdStr}")`);
+    }
+    const withdrawalId = BigInt(withdrawalIdStr);
+    const ario = await getSolanaWriter(o);
+    await assertConfirmationPrompt(`Close drained Withdrawal PDA (owner=${owner}, id=${withdrawalIdStr})?`, o);
+    return ario.closeDrainedWithdrawal({ owner, withdrawalId });
+}
+// =========================================
+// Vault + primary-name request
+// =========================================
+export async function releaseVaultCLICommand(o) {
+    rejectAoBackend(o, 'release-vault');
+    // The on-chain handler requires `owner: Signer` — the SDK uses the
+    // configured signer as the owner. The `--owner` flag is accepted as
+    // documentation but ignored unless it matches the signer; fail loud if
+    // it doesn't, so users don't think they can release someone else's vault.
+    const ario = await getSolanaWriter(o);
+    if (o.owner) {
+        const signerAddr = (await writeARIOFromOptions(o)).signerAddress;
+        if (o.owner !== signerAddr) {
+            throw new Error(`release-vault: --owner ${o.owner} does not match signer ${signerAddr}. ` +
+                `release_vault is owner-signed; use the owner's wallet to call it.`);
+        }
+    }
+    const vaultIdStr = requiredStringFromOptions(o, 'vaultId');
+    const vaultId = vaultIdStr;
+    await assertConfirmationPrompt(`Release expired vault id=${vaultIdStr} (transfer tokens back to owner)?`, o);
+    return ario.releaseVault({ vaultId });
+}
+export async function closeExpiredRequestCLICommand(o) {
+    rejectAoBackend(o, 'close-expired-request');
+    const initiator = requiredStringFromOptions(o, 'initiator');
+    const ario = await getSolanaWriter(o);
+    await assertConfirmationPrompt(`Close expired primary-name request from ${initiator}?`, o);
+    return ario.closeExpiredRequest({ initiator });
+}

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