@ar.io/sdk 4.0.0-solana.8 → 4.0.0

package/lib/esm/solana/send.js

@@ -1,3 +1,18 @@
+/**
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 /**
  * Shared helpers for building, signing, and sending Solana transactions
  * with @solana/kit. Used by SolanaARIOWriteable and SolanaANTWriteable.
@@ -8,17 +23,18 @@
  * favor of the official package. See `sendAndConfirm` below for why we always
  * pin BOTH instructions (even with a 0 priority fee).
  */
+import { ADDRESS_LOOKUP_TABLE_PROGRAM_ADDRESS, getCloseLookupTableInstruction, getCreateLookupTableInstructionAsync, getDeactivateLookupTableInstruction, getExtendLookupTableInstruction, } from '@solana-program/address-lookup-table';
 import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, } from '@solana-program/compute-budget';
-import { appendTransactionMessageInstructions, compileTransaction, createTransactionMessage, getBase64EncodedWireTransaction, getSignatureFromTransaction, pipe, sendAndConfirmTransactionFactory, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, } from '@solana/kit';
+import { appendTransactionMessageInstructions, compileTransaction, compressTransactionMessageUsingAddressLookupTables, createTransactionMessage, getAddressDecoder, getBase64EncodedWireTransaction, getSignatureFromTransaction, pipe, sendAndConfirmTransactionFactory, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, } from '@solana/kit';
 /**
  * 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, }) {
+export async function sendAndConfirm({ rpc, rpcSubscriptions, signer, instructions, commitment = 'confirmed', computeUnitLimit = 400_000, addressLookupTables, }) {
     const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
-    const message = pipe(createTransactionMessage({ version: 0 }), (tx) => setTransactionMessageFeePayerSigner(signer, tx), (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), (tx) => appendTransactionMessageInstructions([
+    const baseMessage = pipe(createTransactionMessage({ version: 0 }), (tx) => setTransactionMessageFeePayerSigner(signer, tx), (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), (tx) => appendTransactionMessageInstructions([
         getSetComputeUnitLimitInstruction({ units: computeUnitLimit }),
         // Always pin the priority fee (even at 0) so wallets like Phantom
         // don't silently *append* their own compute-budget instructions
@@ -32,6 +48,10 @@ export async function sendAndConfirm({ rpc, rpcSubscriptions, signer, instructio
         getSetComputeUnitPriceInstruction({ microLamports: 0n }),
         ...instructions,
     ], tx));
+    // Compress against any supplied lookup tables (v0). No-op when none given.
+    const message = addressLookupTables
+        ? compressTransactionMessageUsingAddressLookupTables(baseMessage, addressLookupTables)
+        : baseMessage;
     const signedTx = await signTransactionMessageWithSigners(message);
     const sendAndConfirmFactory = sendAndConfirmTransactionFactory({
         rpc,
@@ -115,3 +135,238 @@ async function logSimulationDiagnostics(rpc, message, originalError) {
         console.warn('[solana-send] failed to collect diagnostics', diagErr);
     }
 }
+/**
+ * Submit `instruction` in a v0 transaction whose `lookupAddresses` (read-only
+ * accounts) are served from a freshly-created, ephemeral Address Lookup Table,
+ * so an instruction touching far more accounts than fit inline (e.g.
+ * `prescribe_epoch` with ≤50 observer PDAs + NameRegistry, ~2 KB of keys) still
+ * fits Solana's 1232-byte transaction-size limit.
+ *
+ * Three confirmed steps: create the table, extend it with the addresses (in
+ * ≤20-address batches to stay within the extend tx size), then send
+ * `instruction` compressed against the table. The sequential confirmations
+ * satisfy the rule that appended addresses are only usable the slot AFTER they
+ * are added. `signer` is the table's authority + payer; the table's (tiny) rent
+ * is left allocated — a future cleanup pass can deactivate + close it.
+ */
+export async function sendWithEphemeralLookupTable({ rpc, rpcSubscriptions, signer, instruction, lookupAddresses, commitment = 'confirmed', computeUnitLimit = 1_000_000, }) {
+    const recentSlot = await rpc.getSlot({ commitment: 'finalized' }).send();
+    const createIx = await getCreateLookupTableInstructionAsync({
+        authority: signer.address,
+        payer: signer,
+        recentSlot,
+    });
+    const tableAddress = createIx.accounts[0].address;
+    // Create the (empty) table.
+    await sendAndConfirm({
+        rpc,
+        rpcSubscriptions,
+        signer,
+        instructions: [createIx],
+        commitment,
+        computeUnitLimit: 60_000,
+    });
+    // Fill it, ≤20 addresses per extend tx.
+    const BATCH = 20;
+    for (let i = 0; i < lookupAddresses.length; i += BATCH) {
+        const extendIx = getExtendLookupTableInstruction({
+            address: tableAddress,
+            authority: signer,
+            payer: signer,
+            addresses: lookupAddresses.slice(i, i + BATCH),
+        });
+        await sendAndConfirm({
+            rpc,
+            rpcSubscriptions,
+            signer,
+            instructions: [extendIx],
+            commitment,
+            computeUnitLimit: 60_000,
+        });
+    }
+    // Wait until the table holds every address AND one slot has elapsed since —
+    // addresses appended to a lookup table are only usable the slot AFTER they're
+    // added, and the validator that processes the prescribe must already see
+    // them. Skipping this yields "address table lookup uses an invalid index".
+    await waitForLookupTableActive(rpc, tableAddress, lookupAddresses.length);
+    // Send the real instruction, compressed against the now-active table.
+    return sendAndConfirm({
+        rpc,
+        rpcSubscriptions,
+        signer,
+        instructions: [instruction],
+        commitment,
+        computeUnitLimit,
+        addressLookupTables: { [tableAddress]: lookupAddresses },
+    });
+}
+/**
+ * Poll until an Address Lookup Table holds at least `expectedCount` addresses
+ * AND at least one slot has elapsed since they all landed. Lookup-table entries
+ * are only usable the slot AFTER they are appended, and the leader processing
+ * the consuming tx must already see them — otherwise the runtime rejects the tx
+ * with "address table lookup uses an invalid index". ALT account layout is a
+ * 56-byte metadata header followed by 32-byte addresses.
+ */
+async function waitForLookupTableActive(rpc, table, expectedCount, maxWaitMs = 30_000) {
+    const META = 56;
+    const start = Date.now();
+    let slotAllPresent = null;
+    while (Date.now() - start < maxWaitMs) {
+        const acc = await rpc.getAccountInfo(table, { encoding: 'base64' }).send();
+        const slot = acc.context.slot;
+        if (acc.value) {
+            const len = Buffer.from(acc.value.data[0], 'base64').length;
+            const count = len >= META ? Math.floor((len - META) / 32) : 0;
+            if (count >= expectedCount) {
+                if (slotAllPresent === null) {
+                    slotAllPresent = slot;
+                }
+                else if (slot > slotAllPresent) {
+                    return; // all addresses present + a slot has elapsed → warm
+                }
+            }
+        }
+        await new Promise((r) => setTimeout(r, 800));
+    }
+    throw new Error(`lookup table ${table} not active (≥${expectedCount} addresses + 1 slot) within ${maxWaitMs}ms`);
+}
+/**
+ * Reclaim rent from the ephemeral Address Lookup Tables `signer` created for
+ * prescribe (see {@link sendWithEphemeralLookupTable}). Each prescribe leaves a
+ * single-use table allocated (~0.0126 SOL of rent); reclaiming needs a
+ * deactivate → ~513-slot cooldown → close sequence, so it can't run inline — a
+ * throttled permissionless cleanup pass (cranker / observer) calls this.
+ *
+ * Discovery is RPC-portable. `getProgramAccounts` on the Address Lookup Table
+ * program is rejected by Agave RPCs (`Invalid param: WrongSize`, on public
+ * devnet/mainnet-beta and dedicated providers alike — the ALT program can't be
+ * enumerated), so instead we read the signer's own transaction history
+ * (`getSignaturesForAddress` + `getTransaction`) and collect the tables it
+ * referenced via `message.addressTableLookups` — a prescribe ALT is used in
+ * exactly one transaction.
+ *
+ * Safety fingerprint: a candidate is only touched when EVERY one of its entries
+ * is owned by a program in `allowedEntryOwners` (the GAR + ArNS programs — i.e.
+ * observer Gateway PDAs + the ArNS NameRegistry). That composition uniquely
+ * identifies a prescribe ephemeral, so the pass never deactivates/closes an
+ * unrelated table even if `signer` is also used to author Address Lookup Tables
+ * for other purposes.
+ *
+ * DEACTIVATES still-active matches (starts the cooldown) and CLOSES deactivated
+ * matches past the cooldown (refunding rent to `signer`). At most `maxTables`
+ * submissions per call; scans at most `scanLimit` recent signatures. Best-effort:
+ * per-table failures are skipped and retried on the next pass.
+ */
+export async function reclaimLookupTablesForSigner({ rpc, rpcSubscriptions, signer, allowedEntryOwners, commitment = 'confirmed', maxTables = 10, scanLimit = 500, }) {
+    const ALT_META = 56; // metadata header before the 32-byte address array
+    const ACTIVE = 0xffffffffffffffffn; // u64::MAX = not yet deactivated
+    const COOLDOWN_SLOTS = 513n; // deactivation_slot must age out of SlotHashes
+    const allowed = new Set(allowedEntryOwners);
+    const addressDecoder = getAddressDecoder();
+    // getTransaction only honours 'confirmed' | 'finalized'.
+    const historyCommitment = commitment === 'finalized' ? 'finalized' : 'confirmed';
+    // --- Discover candidate tables from the signer's transaction history -------
+    const sigs = await rpc
+        .getSignaturesForAddress(signer.address, { limit: scanLimit })
+        .send();
+    const candidates = new Set();
+    for (const { signature } of sigs) {
+        // A little headroom over maxTables so already-closed candidates don't
+        // starve the budget; the rest get picked up next pass.
+        if (candidates.size >= maxTables * 3)
+            break;
+        const tx = await rpc
+            .getTransaction(signature, {
+            encoding: 'json',
+            maxSupportedTransactionVersion: 0,
+            commitment: historyCommitment,
+        })
+            .send();
+        const lookups = tx?.transaction?.message?.addressTableLookups ?? [];
+        for (const l of lookups)
+            candidates.add(l.accountKey);
+    }
+    // --- Reclaim ----------------------------------------------------------------
+    const currentSlot = await rpc.getSlot().send();
+    let deactivated = 0;
+    let closed = 0;
+    for (const table of candidates) {
+        if (deactivated + closed >= maxTables)
+            break;
+        const address = table;
+        try {
+            const info = await rpc
+                .getAccountInfo(address, { encoding: 'base64' })
+                .send();
+            const value = info.value;
+            if (!value)
+                continue; // already closed
+            if (value.owner !==
+                ADDRESS_LOOKUP_TABLE_PROGRAM_ADDRESS) {
+                continue;
+            }
+            const data = Buffer.from(value.data[0], 'base64');
+            if (data.length < ALT_META)
+                continue;
+            const deactivationSlot = data.readBigUInt64LE(4);
+            // Fingerprint: every entry must be owned by an allowed program. A prescribe
+            // ALT is exclusively observer Gateway PDAs (GAR) + the NameRegistry (ArNS).
+            const entries = [];
+            for (let off = ALT_META; off + 32 <= data.length; off += 32) {
+                entries.push(addressDecoder.decode(data.subarray(off, off + 32)));
+            }
+            if (entries.length === 0)
+                continue;
+            const owners = await rpc
+                .getMultipleAccounts(entries, {
+                encoding: 'base64',
+                dataSlice: { offset: 0, length: 0 },
+            })
+                .send();
+            const allOwned = owners.value.every((a) => a != null && allowed.has(a.owner));
+            if (!allOwned)
+                continue; // not a prescribe ephemeral — leave it alone
+            if (deactivationSlot === ACTIVE) {
+                await sendAndConfirm({
+                    rpc,
+                    rpcSubscriptions,
+                    signer,
+                    commitment,
+                    computeUnitLimit: 30_000,
+                    instructions: [
+                        getDeactivateLookupTableInstruction({ address, authority: signer }),
+                    ],
+                });
+                deactivated += 1;
+            }
+            else if (currentSlot > deactivationSlot + COOLDOWN_SLOTS) {
+                await sendAndConfirm({
+                    rpc,
+                    rpcSubscriptions,
+                    signer,
+                    commitment,
+                    computeUnitLimit: 30_000,
+                    instructions: [
+                        getCloseLookupTableInstruction({
+                            address,
+                            authority: signer,
+                            recipient: signer.address,
+                        }),
+                    ],
+                });
+                closed += 1;
+            }
+        }
+        catch {
+            // best-effort: a racing close / not-yet-cooled table just gets retried
+            // on the next cleanup pass.
+        }
+    }
+    return {
+        deactivated,
+        closed,
+        candidates: candidates.size,
+        scannedSignatures: sigs.length,
+    };
+}

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

@@ -1,3 +1,18 @@
+/**
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 /**
  * Solana implementation of `ANT.spawn`.
  *
@@ -17,11 +32,10 @@
  */
 import { addSignersToTransactionMessage, appendTransactionMessageInstructions, createTransactionMessage, generateKeyPairSigner, getSignatureFromTransaction, pipe, sendAndConfirmTransactionFactory, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, signTransactionMessageWithSigners, } from '@solana/kit';
 import { getInitializeInstructionAsync } from '@ar.io/solana-contracts/ant';
+import { DataState, getCreateV1Instruction, } from '@ar.io/solana-contracts/mpl-core';
 import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, } from '@solana-program/compute-budget';
 import { SolanaANTRegistryWriteable } from './ant-registry-writeable.js';
 import { ARIO_ANT_PROGRAM_ID } from './constants.js';
-import { getCreateV1Instruction } from './generated/mpl-core/instructions/index.js';
-import { DataState } from './generated/mpl-core/types/index.js';
 import { getAntRecordPDA } from './pda.js';
 /** AR.IO logo Arweave TX — matches the Rust default in `ario_ant::initialize`. */
 export const ARIO_LOGO_TX_ID = 'AnYvLJTWcG9lr2Ll5MwYWZR2o5uTE39WbpYB0zCxwKM';

package/lib/esm/types/ant.js

@@ -34,8 +34,8 @@ export const ArweaveTxIdSchema = z
     .refine((val) => ARWEAVE_TX_REGEX.test(val), {
     message: 'Must be an Arweave Transaction ID',
 });
-export const AOAddressSchema = z.string({
-    description: 'AO Address',
+export const WalletAddressSchema = z.string({
+    description: 'Wallet address (Solana base58 pubkey)',
 });
 export const IntegerStringSchema = z
     .string({
@@ -63,7 +63,7 @@ export const AntRecordSchema = z.object({
         .describe('Storage protocol: 0 = Arweave, 1 = IPFS')
         .default(0),
     priority: z.number().optional(),
-    owner: AOAddressSchema.describe('The owner address of the record').optional(),
+    owner: WalletAddressSchema.describe('The owner address of the record').optional(),
     displayName: z
         .string()
         .max(61)
@@ -82,8 +82,8 @@ export const AntRecordSchema = z.object({
         .optional(),
 });
 export const AntRecordsSchema = z.record(z.string(), AntRecordSchema);
-export const AntControllersSchema = z.array(AOAddressSchema.describe('Controller address'));
-export const AntBalancesSchema = z.record(AOAddressSchema.describe('Holder address'), z.number());
+export const AntControllersSchema = z.array(WalletAddressSchema.describe('Controller address'));
+export const AntBalancesSchema = z.record(WalletAddressSchema.describe('Holder address'), z.number());
 export const AntStateSchema = z.object({
     Name: z.string().describe('The name of the ANT.'),
     Ticker: z.string().describe('The ticker symbol for the ANT.'),
@@ -93,7 +93,7 @@ export const AntStateSchema = z.object({
         .number()
         .describe('The number of decimal places to use for the ANT. Defaults to 0 if not set representing whole numbers.')
         .min(0, { message: 'Denomination must be a non-negative number' }),
-    Owner: AOAddressSchema.describe('The Owners address.'),
+    Owner: WalletAddressSchema.describe('The Owners address.'),
     Controllers: AntControllersSchema.describe('Controllers of the ANT who have administrative privileges.'),
     Records: AntRecordsSchema.describe('Records associated with the ANT.'),
     Balances: AntBalancesSchema.describe('Balance details for each address holding the ANT.'),
@@ -111,7 +111,7 @@ export const SpawnANTStateSchema = z.object({
     ticker: z.string().describe('The ticker symbol for the ANT.'),
     description: z.string().describe('The description for the ANT.'),
     keywords: AntKeywordsSchema.describe('The keywords for the ANT.'),
-    owner: AOAddressSchema.describe('The Owners address.'),
+    owner: WalletAddressSchema.describe('The Owners address.'),
     controllers: AntControllersSchema.describe('Controllers of the ANT who have administrative privileges.'),
     records: AntRecordsSchema.describe('Records associated with the ANT.'),
     balances: AntBalancesSchema.describe('Balance details for each address holding the ANT.'),
@@ -171,6 +171,6 @@ export const AntInfoSchema = z.object({
  * @param state {object}
  * @returns {boolean}
  */
-export function isAoANTState(state) {
+export function isANTState(state) {
     return AntStateSchema.safeParse(state).success;
 }

package/lib/esm/types/io.js

@@ -1,4 +1,3 @@
-import { validateArweaveId } from '../utils/arweave.js';
 export const isDistributedEpochData = (data) => {
     return data.distributedTimestamp !== undefined;
 };
@@ -34,15 +33,6 @@ export const isValidFundFrom = (fundFrom) => {
     return fundFromOptions.indexOf(fundFrom) !== -1;
 };
 // Type-guard functions
-export function isProcessConfiguration(config) {
-    return config !== undefined && 'process' in config;
-}
-export function isProcessIdConfiguration(config) {
-    return (config !== undefined &&
-        'processId' in config &&
-        typeof config.processId === 'string' &&
-        validateArweaveId(config.processId) === true);
-}
 export function isLeasedArNSRecord(record) {
     return record.type === 'lease';
 }

package/lib/esm/utils/ant.js

@@ -37,67 +37,3 @@ export const sortANTRecords = (antRecords) => {
     // now that they are sorted, add the index to each record - this is their position in the sorted list and is used to enforce undername limits
     return Object.fromEntries(sortedEntries.map(([a, aRecord], index) => [a, { ...aRecord, index }]));
 };
-/**
- * @deprecated - this is no longer necessary because HyperBeam now uses the AoANTState type
- */
-export const isHyperBeamANTState = (state) => {
-    return ('name' in state &&
-        'ticker' in state &&
-        'description' in state &&
-        'keywords' in state &&
-        'denomination' in state &&
-        'owner' in state &&
-        'controllers' in state &&
-        'records' in state &&
-        'balances' in state &&
-        'logo' in state &&
-        'totalsupply' in state &&
-        'initialized' in state);
-};
-/**
- * Convert HyperBeam serialized ANT state to backwards compatible format.
- *
- * @deprecated - this is no longer necessary because HyperBeam now uses the AOANTState type
- * @param state - The HyperBeam serialized ANT state.
- */
-export const convertHyperBeamStateToAoANTState = (initialState) => {
-    function lowerCaseKeys(obj) {
-        return Object.fromEntries(Object.entries(obj).map(([key, value]) => {
-            if (key.toLowerCase().includes('balances')) {
-                return [key.toLowerCase(), value];
-            }
-            if (typeof value === 'object' &&
-                !Array.isArray(value) &&
-                value !== null) {
-                return [key.toLowerCase(), lowerCaseKeys(value)];
-            }
-            return [key.toLowerCase(), value];
-        }));
-    }
-    // we need to ensure keys are lower cased because hyperbeam json serializes keys to lowercase inconsistently
-    const state = lowerCaseKeys(initialState);
-    return {
-        Name: state.name,
-        Ticker: state.ticker,
-        Description: state.description,
-        Keywords: state.keywords,
-        Denomination: parseInt(state.denomination),
-        Owner: state.owner,
-        Controllers: state.controllers,
-        Records: Object.entries(state.records).reduce((acc, [key, record]) => {
-            acc[key] = {
-                transactionId: record.transactionid,
-                ttlSeconds: record.ttlseconds,
-                targetProtocol: 0,
-                ...(record.priority !== undefined
-                    ? { priority: record.priority }
-                    : {}),
-            };
-            return acc;
-        }, {}),
-        Balances: state.balances,
-        Logo: state.logo,
-        TotalSupply: state.totalsupply || 1,
-        Initialized: state.initialized,
-    };
-};

package/lib/esm/utils/index.js

@@ -13,10 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export * from './ao.js';
-export * from './arweave.js';
 export * from './base64.js';
 export * from './json.js';
-export * from './processes.js';
 export * from './schema.js';
 export * from './ant.js';

package/lib/esm/version.js

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

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

@@ -13,16 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { AoANTSetBaseNameRecordParams, AoANTSetUndernameRecordParams } from '../../types/ant.js';
-import { CLIWriteOptionsFromAoAntParams, JsonSerializable } from '../types.js';
+import { ANTSetBaseNameRecordParams, ANTSetUndernameRecordParams } from '../../types/ant.js';
+import { CLIWriteOptionsFromAoAntParams } 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>>>;
-export declare function setAntUndernameCLICommand(o: CLIWriteOptionsFromAoAntParams<AoANTSetUndernameRecordParams>): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
+export declare function setAntRecordCLICommand(o: CLIWriteOptionsFromAoAntParams<ANTSetUndernameRecordParams>): Promise<import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>>;
+export declare function setAntBaseNameCLICommand(o: CLIWriteOptionsFromAoAntParams<ANTSetBaseNameRecordParams>): Promise<import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>>;
+export declare function setAntUndernameCLICommand(o: CLIWriteOptionsFromAoAntParams<ANTSetUndernameRecordParams>): Promise<import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>>;
 export declare function transferRecordOwnershipCLICommand(o: CLIWriteOptionsFromAoAntParams<{
     undername: string;
     recipient: string;
-}>): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
-export declare function upgradeAntCLICommand(o: CLIWriteOptionsFromAoAntParams<Record<string, unknown>>): Promise<{
-    [key: string]: JsonSerializable;
-}>;
+}>): Promise<import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>>;

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

@@ -1,22 +1,36 @@
-import { AoArNSPurchaseParams, AoBuyRecordParams, AoExtendLeaseParams, AoIncreaseUndernameLimitParams } from '../../types/io.js';
+/**
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ArNSPurchaseParams, BuyRecordParams, ExtendLeaseParams, IncreaseUndernameLimitParams } from '../../types/io.js';
 import { CLIWriteOptionsFromAoParams } from '../types.js';
-export declare function buyRecordCLICommand(o: CLIWriteOptionsFromAoParams<AoBuyRecordParams>): Promise<import("../../types/common.js").AoMessageResult>;
-export declare function upgradeRecordCLICommand(o: CLIWriteOptionsFromAoParams<AoArNSPurchaseParams>): Promise<import("../../types/common.js").AoMessageResult>;
-export declare function extendLeaseCLICommand(o: CLIWriteOptionsFromAoParams<AoExtendLeaseParams>): Promise<import("../../types/common.js").AoMessageResult>;
-export declare function increaseUndernameLimitCLICommand(o: CLIWriteOptionsFromAoParams<AoIncreaseUndernameLimitParams>): Promise<import("../../types/common.js").AoMessageResult>;
-export declare function requestPrimaryNameCLICommand(o: CLIWriteOptionsFromAoParams<AoArNSPurchaseParams>): Promise<Omit<import("../../types/common.js").AoPrimaryNameRequest, "initiator"> & {
+export declare function buyRecordCLICommand(o: CLIWriteOptionsFromAoParams<BuyRecordParams>): Promise<import("../../types/common.js").MessageResult>;
+export declare function upgradeRecordCLICommand(o: CLIWriteOptionsFromAoParams<ArNSPurchaseParams>): Promise<import("../../types/common.js").MessageResult>;
+export declare function extendLeaseCLICommand(o: CLIWriteOptionsFromAoParams<ExtendLeaseParams>): Promise<import("../../types/common.js").MessageResult>;
+export declare function increaseUndernameLimitCLICommand(o: CLIWriteOptionsFromAoParams<IncreaseUndernameLimitParams>): Promise<import("../../types/common.js").MessageResult>;
+export declare function requestPrimaryNameCLICommand(o: CLIWriteOptionsFromAoParams<ArNSPurchaseParams>): Promise<Omit<import("../../types/common.js").PrimaryNameRequest, "initiator"> & {
     initiator: import("../../types/common.js").WalletAddress;
 }>;
-export declare function setPrimaryNameCLICommand(o: CLIWriteOptionsFromAoParams<AoArNSPurchaseParams>): Promise<import("../../types/common.js").AoMessageResult>;
+export declare function setPrimaryNameCLICommand(o: CLIWriteOptionsFromAoParams<ArNSPurchaseParams>): Promise<import("../../types/common.js").MessageResult>;
 /**
  * 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.
+ * `Undername Limit`) with the current `ArnsRecord` state. Permissionless.
  *
- * 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).
+ * Use after a `buy-record` where the buyer 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>;
+}>): Promise<import("../../types/common.js").MessageResult>;

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

@@ -6,6 +6,12 @@
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 /**
  * CLI commands for `ario-ant-escrow` — trustless multi-protocol ANT custody.

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

@@ -1,38 +1,39 @@
 import { AddressAndVaultIdCLIWriteOptions, DecreaseDelegateStakeCLIOptions, JoinNetworkCLIOptions, OperatorStakeCLIOptions, RedelegateStakeCLIOptions, TransferCLIOptions, UpdateGatewaySettingsCLIOptions, WriteActionCLIOptions } from '../types.js';
 export declare function joinNetwork(options: JoinNetworkCLIOptions): Promise<{
-    joinNetworkResult: import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>;
+    joinNetworkResult: import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>;
     joinedAddress: string;
     message: string;
 }>;
 export declare function updateGatewaySettings(options: UpdateGatewaySettingsCLIOptions): Promise<{
-    updateGatewaySettingsResult: import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>;
+    updateGatewaySettingsResult: import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>;
     updatedGatewayAddress: string;
     message: string;
 }>;
-export declare function leaveNetwork(options: WriteActionCLIOptions): Promise<import("../../types/common.js").AoMessageResult>;
+export declare function leaveNetwork(options: WriteActionCLIOptions): Promise<import("../../types/common.js").MessageResult>;
 export declare function saveObservations(o: WriteActionCLIOptions & {
     failedGateways?: string[];
     transactionId?: string;
-}): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
-export declare function increaseOperatorStake(o: OperatorStakeCLIOptions): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
-export declare function decreaseOperatorStake(o: OperatorStakeCLIOptions): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
-export declare function instantWithdrawal(o: AddressAndVaultIdCLIWriteOptions): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
-export declare function cancelWithdrawal(o: AddressAndVaultIdCLIWriteOptions): Promise<import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>>;
+}): Promise<import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>>;
+export declare function increaseOperatorStake(o: OperatorStakeCLIOptions): Promise<import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>>;
+export declare function decreaseOperatorStake(o: OperatorStakeCLIOptions): Promise<import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>>;
+export declare function claimWithdrawal(o: AddressAndVaultIdCLIWriteOptions): Promise<import("../../types/common.js").MessageResult>;
+export declare function instantWithdrawal(o: AddressAndVaultIdCLIWriteOptions): Promise<import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>>;
+export declare function cancelWithdrawal(o: AddressAndVaultIdCLIWriteOptions): Promise<import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>>;
 export declare function delegateStake(options: TransferCLIOptions): Promise<{
     senderAddress: string;
-    transferResult: import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>;
+    transferResult: import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>;
     message: string;
 } | {
     message: string;
 }>;
 export declare function decreaseDelegateStake(options: DecreaseDelegateStakeCLIOptions): Promise<{
     targetGateway: string;
-    decreaseDelegateStakeResult: import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>;
+    decreaseDelegateStakeResult: import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>;
     message: string;
 }>;
 export declare function redelegateStake(options: RedelegateStakeCLIOptions): Promise<{
     sourceGateway: string;
     targetGateway: string;
-    redelegateStakeResult: import("../../types/common.js").AoMessageResult<Record<string, string | number | boolean | null>>;
+    redelegateStakeResult: import("../../types/common.js").MessageResult<Record<string, string | number | boolean | null>>;
     message: string;
 }>;