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

package/lib/types/cli/options.d.ts

@@ -49,6 +49,67 @@ export declare const optionMap: {
         alias: string;
         description: string;
     };
+    ao: {
+        alias: string;
+        description: string;
+        type: string;
+    };
+    rpcUrl: {
+        alias: string;
+        description: string;
+    };
+    antProgramId: {
+        alias: string;
+        description: string;
+    };
+    coreProgramId: {
+        alias: string;
+        description: string;
+    };
+    garProgramId: {
+        alias: string;
+        description: string;
+    };
+    arnsProgramId: {
+        alias: string;
+        description: string;
+    };
+    escrowProgramId: {
+        alias: string;
+        description: string;
+    };
+    ant: {
+        alias: string;
+        description: string;
+    };
+    recipientArweave: {
+        alias: string;
+        description: string;
+    };
+    recipientEthereum: {
+        alias: string;
+        description: string;
+    };
+    newRecipientArweave: {
+        alias: string;
+        description: string;
+    };
+    newRecipientEthereum: {
+        alias: string;
+        description: string;
+    };
+    signatureFile: {
+        alias: string;
+        description: string;
+    };
+    saltLen: {
+        alias: string;
+        description: string;
+    };
+    claimant: {
+        alias: string;
+        description: string;
+    };
     cuUrl: {
         alias: string;
         description: string;
@@ -234,6 +295,10 @@ export declare const optionMap: {
         alias: string;
         description: string;
     };
+    targetProtocol: {
+        alias: string;
+        description: string;
+    };
     ttlSeconds: {
         alias: string;
         description: string;
@@ -273,6 +338,23 @@ export declare const optionMap: {
         alias: string;
         description: string;
     };
+    gatewayAddress: {
+        alias: string;
+        description: string;
+    };
+    fundAsOperator: {
+        alias: string;
+        description: string;
+        type: string;
+    };
+    withdrawalId: {
+        alias: string;
+        description: string;
+    };
+    fundingPlanJson: {
+        alias: string;
+        description: string;
+    };
     revokable: {
         alias: string;
         description: string;
@@ -303,6 +385,10 @@ export declare const optionMap: {
         alias: string;
         description: string;
     };
+    metadataUri: {
+        alias: string;
+        description: string;
+    };
     token: {
         alias: string;
         description: string;

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

@@ -25,6 +25,12 @@ export type GlobalCLIOptions = WalletCLIOptions & {
     testnet: boolean;
     mainnet: boolean;
     debug: boolean;
+    ao?: boolean;
+    rpcUrl?: string;
+    antProgramId?: string;
+    coreProgramId?: string;
+    garProgramId?: string;
+    arnsProgramId?: string;
     arioProcessId?: string;
     antRegistryProcessId?: string;
     hyperbeamUrl?: string;

package/lib/types/cli/utils.d.ts

@@ -23,7 +23,7 @@ export declare function requiredJwkFromOptions(options: WalletCLIOptions): JWKIn
 export declare function jwkToAddress(jwk: JWKInterface): string;
 export declare function getLoggerFromOptions(options: GlobalCLIOptions): Logger;
 export declare function readARIOFromOptions(options: GlobalCLIOptions): AoARIORead;
-export declare function readANTRegistryFromOptions(options: ProcessIdCLIOptions): AoANTRegistryRead;
+export declare function readANTRegistryFromOptions(options: ProcessIdCLIOptions): Promise<AoANTRegistryRead>;
 export declare function contractSignerFromOptions(options: WalletCLIOptions): {
     signer: ContractSigner;
     signerAddress: string;
@@ -33,10 +33,10 @@ export declare function requiredContractSignerFromOptions(options: WalletCLIOpti
     signerAddress: string;
 };
 export declare function requiredAoSignerFromOptions(options: WalletCLIOptions): AoSigner;
-export declare function writeARIOFromOptions(options: GlobalCLIOptions): {
+export declare function writeARIOFromOptions(options: GlobalCLIOptions): Promise<{
     ario: AoARIOWrite;
     signerAddress: string;
-};
+}>;
 export declare function formatARIOWithCommas(value: ARIOToken): string;
 export declare function formatMARIOToARIOWithCommas(value: mARIOToken): string;
 /** helper to get address from --address option first, then check wallet options  */
@@ -74,8 +74,8 @@ export declare function assertConfirmationPrompt<O extends {
     skipConfirmation?: boolean;
 }>(message: string, options: O): Promise<boolean>;
 export declare function requiredProcessIdFromOptions<O extends ProcessIdCLIOptions>(o: O): string;
-export declare function readANTFromOptions(options: ProcessIdCLIOptions): AoANTRead;
-export declare function writeANTFromOptions(options: ProcessIdCLIOptions, signer?: ContractSigner): AoANTWrite;
+export declare function readANTFromOptions(options: ProcessIdCLIOptions): Promise<AoANTRead>;
+export declare function writeANTFromOptions(options: ProcessIdCLIOptions, signer?: ContractSigner): Promise<AoANTWrite>;
 export declare function booleanFromOptions<O extends GlobalCLIOptions>(options: O, key: string): boolean;
 export declare function requiredStringFromOptions<O extends GlobalCLIOptions>(options: O, key: string): string;
 export declare function stringArrayFromOptions<O extends GlobalCLIOptions>(options: O, key: string): string[] | undefined;
@@ -83,6 +83,20 @@ export declare function requiredStringArrayFromOptions<O extends GlobalCLIOption
 export declare function positiveIntegerFromOptions<O extends GlobalCLIOptions>(options: O, key: string): number | undefined;
 export declare function requiredPositiveIntegerFromOptions<O extends GlobalCLIOptions>(options: O, key: string): number;
 export declare function getANTStateFromOptions(options: ANTStateCLIOptions): SpawnANTState;
+/**
+ * Spawn a fresh ANT on Solana from CLI options.
+ *
+ * Resolves the signer the same way `writeARIOFromOptions` does (KeyPairSigner
+ * from `--wallet-file` or `--private-key`), then bundles MPL Core `CreateV1` +
+ * `ario_ant::initialize` into a single transaction. The signer's address
+ * becomes the ANT owner on chain — no separate `--address` is required.
+ *
+ * Maps the CLI's AO-shaped options (`--name`, `--ticker`, `--description`,
+ * `--keywords`, `--logo`, `--target` for the @ record tx id) onto the Solana
+ * `InitializeAntParams` payload. AO-only state fields like `controllers` and
+ * `balances` are intentionally dropped — they don't exist on Solana.
+ */
+export declare function spawnSolanaANTFromOptions(options: ANTStateCLIOptions): Promise<import('../solana/spawn-ant.js').SpawnSolanaANTResult>;
 export declare function getTokenCostParamsFromOptions(o: GetTokenCostCLIOptions): {
     type: "lease" | "permabuy";
     quantity: number | undefined;
@@ -97,6 +111,30 @@ export declare function fundFromFromOptions<O extends {
 export declare function referrerFromOptions<O extends {
     referrer?: string;
 }>(o: O): string | undefined;
+/** Parse `--withdrawal-id` from CLI options into a bigint. */
+export declare function withdrawalIdFromOptions<O extends {
+    withdrawalId?: string;
+}>(o: O): bigint | undefined;
+/**
+ * Parse `--funding-plan-json` into a `FundingSourceSpec[]`. Validates each
+ * entry's `kind` against the on-chain enum and parses `amount` as a bigint.
+ * Each Delegation/OperatorStake entry MAY carry a `gateway` field (base58
+ * Solana address) — required when the plan spans multiple gateways.
+ *
+ * Format examples:
+ *   '[{"kind":"balance","amount":"100"},{"kind":"withdrawal","amount":"500"}]'
+ *   '[{"kind":"delegation","amount":"100","gateway":"Gw1..."},{"kind":"delegation","amount":"50","gateway":"Gw2..."}]'
+ *
+ * Returns undefined when the flag isn't set; throws Error on malformed JSON
+ * or unknown kinds.
+ */
+export declare function fundingPlanFromOptions<O extends {
+    fundingPlanJson?: string;
+}>(o: O): {
+    kind: string;
+    amount: bigint;
+    gateway?: string;
+}[] | undefined;
 export declare function assertLockLengthInRange(lockLengthMs: number, assertMin?: boolean): void;
 export declare function antRecordMetadataFromOptions<O extends {
     owner?: string;

package/lib/types/common/ant-registry.d.ts

@@ -9,7 +9,48 @@ type ANTRegistryProcessConfig = Required<ProcessConfiguration> & {
 };
 type ANTRegistryNoSigner = ANTRegistryProcessConfig;
 type ANTRegistryWithSigner = WithSigner<ANTRegistryProcessConfig>;
+/**
+ * Solana-backend config for the ANT Registry.
+ *
+ * Reads the per-user paginated ACL on-chain (ADR-012): a head `AclConfig`
+ * PDA + N `AclPage` PDAs holding `(asset, role)` tuples for ANTs the user
+ * owns or controls. Pass a `signer` to opt into the writeable variant,
+ * which adds the preflight resolvers used by the contract-required ACL
+ * accounts (`add_controller`, `remove_controller`, `transfer`) plus the
+ * spawn / ex-controller workflow helpers and the standalone heal-flow
+ * instruction builders. See
+ * `sdk/src/solana/ant-registry-{readable,writeable}.ts` for the
+ * implementations.
+ */
+export type SolanaANTRegistryReadConfig = {
+    backend: 'solana';
+    rpc: import('../solana/types.js').SolanaRpc;
+    commitment?: import('@solana/kit').Commitment;
+    logger?: ILogger;
+    /**
+     * Override the ario-ant program ID. Required against any cluster other
+     * than mainnet — devnet, localnet, and the Surfpool harness all deploy
+     * programs at addresses derived from per-cluster keypair files. Source
+     * from `migration/localnet/out/localnet.env` (`ARIO_ANT_PROGRAM_ID`) on
+     * localnet.
+     */
+    antProgramId?: import('@solana/kit').Address;
+};
+export type SolanaANTRegistryWriteConfig = SolanaANTRegistryReadConfig & {
+    /**
+     * Solana signer used as the rent payer on `register_acl_config` /
+     * `add_acl_page` and as the authoriser for any bundled write tx.
+     */
+    signer: import('@solana/kit').TransactionSigner;
+};
+/**
+ * @deprecated Prefer `SolanaANTRegistryReadConfig` /
+ * `SolanaANTRegistryWriteConfig`. Kept as an alias for back-compat.
+ */
+export type SolanaANTRegistryConfig = SolanaANTRegistryReadConfig;
 export declare class ANTRegistry {
+    static init(config: SolanaANTRegistryWriteConfig): Promise<AoANTRegistryWrite>;
+    static init(config: SolanaANTRegistryReadConfig): Promise<AoANTRegistryRead>;
     static init(): AoANTRegistryRead;
     static init(config: ANTRegistryNoSigner): AoANTRegistryRead;
     static init(config: ANTRegistryWithSigner): AoANTRegistryWrite;

package/lib/types/common/ant.d.ts

@@ -8,6 +8,22 @@ type ANTConfigOptionalStrict = Required<ProcessConfiguration> & {
 };
 type ANTConfigNoSigner = ANTConfigOptionalStrict;
 type ANTConfigWithSigner = WithSigner<ANTConfigOptionalStrict>;
+type SolanaANTConfig = {
+    backend: 'solana';
+    processId: string;
+    rpc: import('../solana/types.js').SolanaRpc;
+    /** Required for write operations (needed by kit's sendAndConfirm). */
+    rpcSubscriptions?: import('../solana/types.js').SolanaRpcSubscriptions;
+    commitment?: import('@solana/kit').Commitment;
+    signer?: import('../solana/types.js').SolanaSigner;
+    /**
+     * Override the ario-ant program ID. Required against any cluster other than
+     * mainnet — devnet, localnet, and the Surfpool harness all deploy programs
+     * at addresses derived from per-cluster keypair files. Source from
+     * `migration/localnet/out/localnet.env` (`ARIO_ANT_PROGRAM_ID`) on localnet.
+     */
+    antProgramId?: import('@solana/kit').Address;
+};
 export declare class ANT {
     /**
      * Versions of ANTs according to the ANT registry.
@@ -17,8 +33,21 @@ export declare class ANT {
     static get versions(): import("../types/ant.js").AoANTVersionsRead;
     /**
      * Spawn a new ANT.
+     *
+     * Defaults to the legacy AO `spawnANT` flow. Pass `backend: 'solana'` plus a
+     * Solana `connection` and `signer` to mint a Metaplex Core asset and
+     * initialize the `ario-ant` PDAs in a single transaction.
+     *
+     * Solana return shape:
+     *   `{ processId: string; mint: Address; signature: string }`
+     *
+     * AO return shape:
+     *   `string` (the spawned AO process id)
      */
-    static spawn: typeof spawnANT;
+    static spawn(params: import('../solana/spawn-ant.js').SpawnSolanaANTParams & {
+        backend: 'solana';
+    }): Promise<import('../solana/spawn-ant.js').SpawnSolanaANTResult>;
+    static spawn(params: Parameters<typeof spawnANT>[0]): ReturnType<typeof spawnANT>;
     /**
      * Fork an ANT to a new process.
      *
@@ -61,8 +90,12 @@ export declare class ANT {
      *
      * @param config
      */
-    static init(config: ANTConfigNoSigner): AoANTRead;
+    static init(config: SolanaANTConfig & {
+        signer: import('../solana/types.js').SolanaSigner;
+    }): Promise<AoANTWrite>;
+    static init(config: SolanaANTConfig): Promise<AoANTRead>;
     static init(config: ANTConfigWithSigner): AoANTWrite;
+    static init(config: ANTConfigNoSigner): AoANTRead;
 }
 export declare class AoANTReadable implements AoANTRead {
     protected process: AOProcess;

package/lib/types/common/contracts/ao-process.d.ts

@@ -10,22 +10,15 @@ export declare class AOProcess implements AOContract {
         logger?: ILogger;
     });
     private isMessageDataEmpty;
-    read<K>({ tags, retries, fromAddress, select, }: {
+    read<K>({ tags, retries, fromAddress, }: {
         tags?: Array<{
             name: string;
             value: string;
         }>;
         retries?: number;
         fromAddress?: string;
-        select?: (message: {
-            Data: string;
-            Tags: Array<{
-                name: string;
-                value: string;
-            }>;
-        }) => boolean;
     }): Promise<K>;
-    send<K>({ tags, data, signer, retries, select, }: {
+    send<K>({ tags, data, signer, retries, }: {
         tags: Array<{
             name: string;
             value: string;
@@ -33,13 +26,6 @@ export declare class AOProcess implements AOContract {
         data?: string | undefined;
         signer: AoSigner;
         retries?: number;
-        select?: (message: {
-            Data: string;
-            Tags: Array<{
-                name: string;
-                value: string;
-            }>;
-        }) => boolean;
     }): Promise<{
         id: string;
         result?: K;

package/lib/types/common/io.d.ts

@@ -10,10 +10,42 @@ type ARIOConfigNoSigner = OptionalPaymentUrl<OptionalArweave<ProcessConfiguratio
 type ARIOConfigWithSigner = WithSigner<OptionalPaymentUrl<OptionalArweave<ProcessConfiguration & {
     hyperbeamUrl?: string;
 }>>>;
+/**
+ * Solana backend configuration for ARIO.init().
+ * When backend is 'solana', a kit `Rpc` is required instead of an AO process.
+ *
+ * Program ID overrides (`coreProgramId`, `garProgramId`, `arnsProgramId`) are
+ * required against any cluster other than mainnet — devnet, localnet, and the
+ * Surfpool harness all deploy programs at addresses derived from per-cluster
+ * keypair files, not the placeholder constants in `sdk/src/solana/constants.ts`.
+ * On localnet, source these from `migration/localnet/out/localnet.env`.
+ */
+type SolanaARIOConfig = {
+    backend: 'solana';
+    rpc: import('../solana/types.js').SolanaRpc;
+    /** Required for write operations (needed by kit's sendAndConfirm). */
+    rpcSubscriptions?: import('../solana/types.js').SolanaRpcSubscriptions;
+    commitment?: import('@solana/kit').Commitment;
+    signer?: import('../solana/types.js').SolanaSigner;
+    coreProgramId?: import('@solana/kit').Address;
+    garProgramId?: import('@solana/kit').Address;
+    arnsProgramId?: import('@solana/kit').Address;
+    /**
+     * Override the deployed `ario-ant` program id. Required for the
+     * ACL-driven `getArNSRecordsForAddress` pipeline on any cluster
+     * other than mainnet (devnet, localnet, Surfpool).
+     */
+    antProgramId?: import('@solana/kit').Address;
+};
+export declare const DEFAULT_SOLANA_RPC_URL = "https://api.mainnet-beta.solana.com";
 export declare class ARIO {
-    static init(): AoARIORead;
+    static init(config: SolanaARIOConfig & {
+        signer: import('../solana/types.js').SolanaSigner;
+        rpcSubscriptions: import('../solana/types.js').SolanaRpcSubscriptions;
+    }): AoARIOWrite;
+    static init(config: SolanaARIOConfig): AoARIORead;
     static init(config: ARIOConfigWithSigner): AoARIOWrite;
-    static init(config: ARIOConfigNoSigner): AoARIORead;
+    static init(config?: ARIOConfigNoSigner): AoARIORead;
     static mainnet(): AoARIORead;
     static mainnet(config: ARIOConfigNoSigner): AoARIORead;
     static mainnet(config: ARIOConfigWithSigner): AoARIOWrite;
@@ -262,5 +294,13 @@ export declare class ARIOWriteable extends ARIOReadable implements AoARIOWrite {
         stakeQty: number | mARIOToken;
         vaultId?: string;
     }, options?: WriteOptions): Promise<AoMessageResult>;
+    /**
+     * AO backend stub — `syncAttributes` is a Solana-only on-chain reconciliation
+     * for the ANT NFT's Attributes plugin. AO ANTs have no NFT trait surface, so
+     * there is nothing to sync.
+     */
+    syncAttributes(_params: {
+        name: string;
+    }, _options?: WriteOptions): Promise<AoMessageResult>;
 }
 export {};

package/lib/types/common/marketplace.d.ts

@@ -301,17 +301,6 @@ export interface ListNameForSaleCompleteEvent {
  * @experimental
  */
 export type ListNameForSaleProgressEvent = CreatingIntentProgressEvent | IntentCreatedProgressEvent | TransferringAntProgressEvent | AntTransferredProgressEvent | ListNameForSaleErrorEvent | ListNameForSaleCompleteEvent;
-/**
- * Timeout and retry options for listNameForSale status checks and polling.
- * Used when checking for intent (e.g. getIntentByANTId), transfer confirmation, and order listing.
- * @experimental
- */
-export interface ListNameForSaleTimeoutOptions {
-    /** Max retries when polling for intent, transfer confirmation, or order listing. Default 5. */
-    maxRetries?: number;
-    /** Base interval in ms for exponential backoff between status polls / retries. Wait time is base * 2^attempt. Default 1000. */
-    statusPollIntervalMs?: number;
-}
 /**
  * Write interface for the ArNS marketplace
  * @experimental
@@ -339,7 +328,6 @@ export interface AoArNSMarketplaceWrite {
     /**
      * List a name for sale on the marketplace
      * @param params - Parameters including name, expiration time, price, type, wallet address, and optional auction parameters
-     * @param timeoutOptions - Optional retries and wait times for intent, transfer, and order listing status polling
      * @returns Result containing intent, order, ANT transfer result, and any error
      */
     listNameForSale({ name, expirationTime, price, type, walletAddress, minimumPrice, decreaseInterval, onProgress, }: {
@@ -351,7 +339,7 @@ export interface AoArNSMarketplaceWrite {
         minimumPrice?: string;
         decreaseInterval?: string;
         onProgress?: (event: ListNameForSaleProgressEvent) => void;
-    }, timeoutOptions?: ListNameForSaleTimeoutOptions): Promise<{
+    }): Promise<{
         intent: MarketplaceIntent;
         order: Order | null;
         antTransferResult: AoMessageResult<Record<string, string | number | boolean | null>> | null;
@@ -485,7 +473,7 @@ export declare class ArNSMarketplaceWrite extends ArNSMarketplaceRead implements
         minimumPrice?: string;
         decreaseInterval?: string;
         onProgress?: (event: ListNameForSaleProgressEvent) => void;
-    }, timeoutOptions?: ListNameForSaleTimeoutOptions): Promise<{
+    }): Promise<{
         intent: MarketplaceIntent;
         order: Order | null;
         antTransferResult: AoMessageResult<Record<string, string | number | boolean | null>> | null;

package/lib/types/constants.d.ts

@@ -14,6 +14,17 @@
  * limitations under the License.
  */
 export declare const ARWEAVE_TX_REGEX: RegExp;
+/** ar:// protocol prefix for location-independent Arweave references */
+export declare const AR_IO_PROTOCOL = "ar://";
+/** Default AR.IO logo Arweave TX ID (32x32 PNG) */
+export declare const ARIO_LOGO_TX_ID = "WMLnh8pQL-UIXZMpdU2NUIriHfcFB5Bc49V8jTHjsZc";
+/**
+ * Construct an ar:// URI from an Arweave TX ID or ArNS name.
+ *
+ * - ar://{txId} — raw 43-char TX ID, resolved by wallets via arweave.net gateway
+ * - ar://{arnsName} — ArNS name, resolved by AR.IO gateways and Wayfinder SDK
+ */
+export declare function arweaveUri(txIdOrName: string): string;
 /** FQDN regex that matches the one used in the ArNS contract. */
 export declare const FQDN_REGEX: RegExp;
 export declare const ARIO_DEVNET_PROCESS_ID = "GaQrvEMKBpkjofgnBi_B3IgIDmY_XYelVLB6GcRGrHc";
@@ -34,4 +45,3 @@ export declare const AOS_MODULE_ID = "nEjlSFA_8narJlVHApbczDPkMc9znSqYtqtf1iOdox
 export declare const ANT_LUA_ID = "sOW9Sdm1yoPRrzerC5iu1nsupp4e6I-HnJyYVHzvzQo";
 export declare const AO_AUTHORITY = "fcoN_xJeisVsPXA-trzVAuIiqO3ydLQxM-L4XbrQKzY";
 export declare const DEFAULT_SCHEDULER_ID = "_GQ33BkPtZrqxA84vM8Zk-N2aO0toNNu_C-l-rawrBA";
-export declare const DEFAULT_CU_URL = "https://cu.ardrive.io";

package/lib/types/solana/ant-readable.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Solana implementation of ANT (Arweave Name Token) read interface.
+ *
+ * Reads ANT state from Metaplex Core NFT + PDA accounts on Solana.
+ * Each ANT is a Metaplex Core NFT with extended state in PDAs:
+ *   - AntConfig: name, ticker, logo, description, keywords, owner
+ *   - AntControllers: list of controller pubkeys
+ *   - AntRecord: undername records (transactionId, ttl, priority, etc.)
+ */
+import { type Address, type Commitment } from '@solana/kit';
+import { type ILogger } from '../common/logger.js';
+import type { AntReadOptions, AoANTHandler, AoANTInfo, AoANTRecord, AoANTState, SortedANTRecords } from '../types/ant.js';
+import type { WalletAddress } from '../types/common.js';
+import { SolanaANTRegistryReadable } from './ant-registry-readable.js';
+import type { SolanaRpc } from './types.js';
+/**
+ * Solana-backed read-only client for a single ANT (Arweave Name Token).
+ *
+ * Usage:
+ * ```ts
+ * import { createSolanaRpc } from '@solana/kit';
+ * import { SolanaANTReadable } from '@ar.io/sdk/solana';
+ *
+ * const rpc = createSolanaRpc('https://api.mainnet-beta.solana.com');
+ * const ant = new SolanaANTReadable({
+ *   rpc,
+ *   processId: 'MetaplexCoreAssetAddress...',
+ * });
+ *
+ * const owner = await ant.getOwner();
+ * const record = await ant.getRecord({ undername: '@' });
+ * ```
+ */
+export declare class SolanaANTReadable {
+    readonly processId: string;
+    protected readonly rpc: SolanaRpc;
+    protected readonly commitment: Commitment;
+    protected readonly logger: ILogger;
+    protected readonly antProgram: Address;
+    protected readonly mint: Address;
+    /**
+     * Composed registry instance — the source of truth for the per-user
+     * paginated ACL (ADR-012). Sharing one instance across the read and
+     * write classes keeps program id / commitment / RPC configuration
+     * coherent for both `accessControlList` reads and the maintenance
+     * planner used during writes.
+     */
+    readonly registry: SolanaANTRegistryReadable;
+    constructor(config: {
+        rpc: SolanaRpc;
+        processId: string;
+        commitment?: Commitment;
+        logger?: ILogger;
+        antProgramId?: Address;
+        /**
+         * Pre-built registry to compose. When omitted we build a readable
+         * registry from `rpc` / `commitment` / `antProgramId` so the simple
+         * "just give me an ANT" call path keeps working with a single arg.
+         */
+        registry?: SolanaANTRegistryReadable;
+    });
+    /**
+     * Build a `SolanaANTReadable` whose program id is read from the
+     * asset's `ANT Program` Attributes-plugin entry (ADR-016 / BD-100).
+     *
+     * Falls back to the canonical `ARIO_ANT_PROGRAM_ID` when the asset
+     * has no plugin section, no `ANT Program` trait, or any layer of the
+     * walk fails to decode — matching the on-chain leniency in
+     * `programs/ario-core/src/mpl_core.rs::read_ant_program`. This is the
+     * factory resolution paths should reach for: it does the asset fetch
+     * once, hands the resulting program id to the constructor, and
+     * shares one `SolanaANTRegistryReadable` instance with the new ANT.
+     *
+     * Use the plain constructor when the program id is already known
+     * (e.g. inside a freshly-spawned ANT flow where you've just minted
+     * the asset and know the program you targeted).
+     */
+    static fromAsset(config: {
+        rpc: SolanaRpc;
+        processId: string;
+        commitment?: Commitment;
+        logger?: ILogger;
+    }): Promise<SolanaANTReadable>;
+    private getAccount;
+    private fetchConfig;
+    private fetchControllers;
+    getOwner(_opts?: AntReadOptions): Promise<WalletAddress>;
+    /** Get the on-chain schema version of this ANT's config. */
+    getConfigVersion(): Promise<number>;
+    /** Check if this ANT needs a schema migration to the latest version. */
+    needsMigration(): Promise<boolean>;
+    getName(_opts?: AntReadOptions): Promise<string>;
+    getTicker(_opts?: AntReadOptions): Promise<string>;
+    getLogo(_opts?: AntReadOptions): Promise<string>;
+    getControllers(): Promise<WalletAddress[]>;
+    getRecord({ undername }: {
+        undername: string;
+    }, _opts?: AntReadOptions): Promise<AoANTRecord | undefined>;
+    getRecords(_opts?: AntReadOptions): Promise<SortedANTRecords>;
+    getBalance({ address: queryAddress }: {
+        address: WalletAddress;
+    }, _opts?: AntReadOptions): Promise<number>;
+    getBalances(_opts?: AntReadOptions): Promise<Record<WalletAddress, number>>;
+    getState(_opts?: AntReadOptions): Promise<AoANTState>;
+    getInfo(_opts?: AntReadOptions): Promise<AoANTInfo>;
+    getHandlers(): Promise<AoANTHandler[]>;
+    getModuleId(_opts?: {
+        graphqlUrl?: string;
+        retries?: number;
+    }): Promise<string>;
+    getVersion(_opts?: {
+        antRegistryId?: string;
+        graphqlUrl?: string;
+        retries?: number;
+    }): Promise<string>;
+    isLatestVersion(_opts?: {
+        antRegistryId?: string;
+        graphqlUrl?: string;
+        retries?: number;
+    }): Promise<boolean>;
+}