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

package/lib/types/solana/funding-plan.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Multi-source, multi-gateway funding plan builder + executor for the AR.IO
+ * Solana SDK.
+ *
+ * Lua-faithful port of `gar.getFundingPlan` / `gar.applyFundingPlan` from
+ * `ar-io-network-process/src/gar.lua`. Supports Delegation sources across
+ * multiple gateways in a single plan (closes BD-076).
+ *
+ * Drawdown order (matches Lua exactly):
+ *   1. Balance — taken first when `fundFrom in {'balance','any','plan'}`
+ *      (`planBalanceDrawdown` in gar.lua:1456)
+ *   2. Withdrawal vaults — sorted asc by `available_at`, oldest-maturing
+ *      first (`planVaultsDrawdown` in gar.lua:1510). Gateway-independent.
+ *   3. Excess delegated stake — iterates ALL gateways the user has delegated
+ *      on (Lua-sorted: desc excess, asc perf, desc total stake, desc start
+ *      timestamp). Up to MAX_DELEGATION_SOURCES gateways per plan.
+ *      (`planExcessStakesDrawdown` in gar.lua:1559)
+ *   4. Minimum delegated stake — drains the floor on each touched gateway,
+ *      auto-vaulting the residue. Same gateway iteration order as step 3.
+ *      (`planMinimumStakesDrawdown` in gar.lua:1585)
+ *
+ * Operator stake is a Solana extension: Lua's funding plans never touch it.
+ * The picker excludes operator stake unless `opts.fundAsOperator === true`.
+ *
+ * The on-chain `pay_from_funding_plan` ix caps the source list at
+ * MAX_FUNDING_SOURCES (5) and Delegation sources at MAX_DELEGATION_SOURCES (3)
+ * (see `programs/ario-gar/src/state/mod.rs`). The planner enforces the same
+ * caps so `executeFundingPlan` calls never get rejected for
+ * `TooManyFundingSources` / `TooManyDelegationSources`.
+ */
+import { AccountRole, type Address, type Rpc, type SolanaRpcApi, type SolanaRpcApiMainnet } from '@solana/kit';
+/**
+ * The discovery + executor accept either the dev/test or the mainnet RPC API
+ * shape — they only use methods that are common to both (`getProgramAccounts`,
+ * `getAccountInfo`).
+ */
+export type FundingPlanRpc = Rpc<SolanaRpcApi> | Rpc<SolanaRpcApiMainnet>;
+import { type FundingSourceKind, type FundingSourceSpec } from '../types/io.js';
+/**
+ * Hard cap on funding-plan length — must stay in sync with the on-chain
+ * `MAX_FUNDING_SOURCES` constant (`programs/ario-gar/src/state/mod.rs`).
+ */
+export declare const MAX_FUNDING_SOURCES = 5;
+/**
+ * Hard cap on Delegation sources within a single plan — must stay in sync
+ * with the on-chain `MAX_DELEGATION_SOURCES` constant.
+ */
+export declare const MAX_DELEGATION_SOURCES = 3;
+/** A single source the user can draw from. Discovery returns these. */
+export type DiscoveredFundingSource = {
+    kind: 'balance';
+    available: bigint;
+} | {
+    kind: 'delegation';
+    gateway: Address;
+    available: bigint;
+    /** Per-gateway floor; the residue auto-vaults if drained below this. */
+    minDelegationAmount: bigint;
+    /** Gateway performance ratio — used for Lua-faithful sort order. */
+    performanceRatio: number;
+    /** Total delegated stake on the gateway — secondary sort key. */
+    totalDelegatedStake: bigint;
+    /** Gateway start timestamp — tertiary sort key. */
+    startTimestamp: bigint;
+} | {
+    kind: 'operatorStake';
+    gateway: Address;
+    available: bigint;
+    minOperatorStake: bigint;
+} | {
+    kind: 'withdrawal';
+    withdrawalId: bigint;
+    gateway: Address;
+    available: bigint;
+    availableAt: bigint;
+};
+/** Output of `buildFundingPlan` when a plan covers the requested amount. */
+export type FundingPlan = {
+    /** Source specs in declaration order — passed verbatim to the on-chain ix. */
+    sources: FundingSourceSpec[];
+    /**
+     * Per-source bound gateway, in declaration order. `undefined` for Balance
+     * and Withdrawal sources; set for Delegation and OperatorStake sources.
+     * Used by the executor to materialize per-source gateway PDA slots in
+     * `remaining_accounts`.
+     */
+    gatewayPerSource: (Address | undefined)[];
+    /**
+     * Indexes (into `sources`) of Delegation sources that will trigger an
+     * on-chain residue auto-vault (drained below `min_delegation_amount`).
+     * The executor must supply that many trailing residue_vault PDAs in
+     * `remaining_accounts`, in the same order as these indexes.
+     */
+    residueDelegationIndexes: number[];
+    /** Whether any Balance source is in the plan (drives optional `payer_token_account`). */
+    hasBalanceSource: boolean;
+};
+/** Discriminated error emitted when no plan covers the requested amount. */
+export type InsufficientFundingError = {
+    kind: 'InsufficientFunding';
+    amountNeeded: bigint;
+    shortfall: bigint;
+    availableSources: DiscoveredFundingSource[];
+    message: string;
+};
+export type BuildFundingPlanOpts = {
+    /** SDK fundFrom mode — drives source preferences (balance / stakes / withdrawal / plan / any). */
+    fundFrom?: 'balance' | 'stakes' | 'withdrawal' | 'plan' | 'any';
+    /**
+     * When set, prefer this gateway first when iterating stake-locked
+     * delegation sources. Other gateways are still considered for additional
+     * fill (up to MAX_DELEGATION_SOURCES total).
+     */
+    preferGateway?: Address;
+    /** Solana extension: include OperatorStake in the picker. Default false (Lua parity). */
+    fundAsOperator?: boolean;
+    /** When set, use only sources of this kind (single-source mode). */
+    restrictToKind?: FundingSourceKind;
+};
+/**
+ * Enumerate the user's fund-from-eligible sources via `getProgramAccounts`
+ * + targeted reads.
+ *
+ * `getProgramAccounts` is restricted on most public Solana RPCs; callers
+ * pointing at default endpoints should switch to a DAS-equivalent RPC
+ * (Helius, Triton, etc.) or pass an explicit `sources` array on the
+ * fee-paying ix to skip discovery.
+ *
+ * Returns sources sorted in the Lua-faithful drawdown order so callers can
+ * iterate without re-sorting.
+ */
+export declare function discoverFundingSources(rpc: FundingPlanRpc, owner: Address, opts: {
+    /** Mint of ARIO; required to compute the user's ATA. */
+    arioMint: Address;
+    /** Optional: pre-fetched balance from the user's ATA (bypasses RPC). */
+    balanceOverride?: bigint;
+    /** Optional ario-gar program override (defaults to deployed program). */
+    garProgram?: Address;
+}): Promise<DiscoveredFundingSource[]>;
+/**
+ * Build a multi-source funding plan that covers `amountNeeded` mARIO.
+ *
+ * Returns `{ kind: 'InsufficientFunding', ... }` when no plan covers the
+ * amount given the supplied sources — caller handles by topping up balance,
+ * choosing a different gateway, or surfacing the error to the user.
+ *
+ * Multi-gateway: Delegation sources span up to MAX_DELEGATION_SOURCES (3)
+ * different gateways. The planner iterates delegations in Lua-faithful order
+ * (or `opts.preferGateway` first if set), drawing excess from each before
+ * falling back to floor-draining (which auto-vaults the residue).
+ *
+ * OperatorStake (Solana extension) is bound to a single gateway when present.
+ * Withdrawal sources have NO gateway constraint.
+ */
+export declare function buildFundingPlan(sources: DiscoveredFundingSource[], amountNeeded: bigint, opts?: BuildFundingPlanOpts): FundingPlan | InsufficientFundingError;
+/**
+ * Materialize a `FundingPlan` into the per-source PDAs the on-chain ix
+ * expects in `remaining_accounts`.
+ *
+ * Layout (per source, in declaration order):
+ *   - Balance:        0 slots
+ *   - Delegation:     2 slots [gateway_pda, delegation_pda]
+ *   - OperatorStake:  1 slot  [gateway_pda]
+ *   - Withdrawal:     1 slot  [withdrawal_pda]
+ *
+ * Followed by N residue_vault PDAs (in the order produced by
+ * `predictResidueVaults`), one per element of `plan.residueDelegationIndexes`.
+ */
+export declare function buildFundingPlanRemainingAccounts(plan: FundingPlan, owner: Address, opts?: {
+    /** Per-source override for Withdrawal PDAs. By index of Withdrawal sources in plan. */
+    withdrawalIds?: bigint[];
+    /** Residue-vault PDAs from `predictResidueVaults`, in plan order. */
+    residueVaults?: Address[];
+    garProgram?: Address;
+}): Promise<{
+    address: Address;
+    role: AccountRole;
+}[]>;
+/**
+ * Pure helper: given an array of explicit `FundingSourceSpec`s and the
+ * decoded (delegation.amount, gateway.minDelegationAmount) for each
+ * Delegation source, return the indexes of sources that will trigger an
+ * on-chain residue auto-vault (post-drain in `(0, min)`).
+ *
+ * `delegationStates[i]` matches `sources[i]` by index — entries for non-
+ * Delegation sources are ignored. Pass `undefined` for those slots.
+ *
+ * Caller is responsible for fetching the on-chain state; this function
+ * is intentionally pure to keep it unit-testable without mocking RPC.
+ */
+export declare function computeResidueIndexes(sources: {
+    kind: string;
+    amount: bigint;
+}[], delegationStates: ({
+    delegationAmount: bigint;
+    minDelegationAmount: bigint;
+} | undefined)[]): number[];
+/**
+ * Predict the residue Withdrawal PDAs the on-chain ix will use for any
+ * Delegation source draining sub-min. Returns one PDA per
+ * `plan.residueDelegationIndexes` entry, sequenced from the user's current
+ * `WithdrawalCounter.next_id`.
+ */
+export declare function predictResidueVaults(rpc: FundingPlanRpc, owner: Address, plan: FundingPlan, opts?: {
+    garProgram?: Address;
+}): Promise<{
+    residueVaults: Address[];
+    withdrawalCounter: Address;
+    nextId: bigint;
+}>;

package/lib/types/solana/generated/ant/accounts/aclConfig.d.ts

@@ -0,0 +1,56 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { fetchEncodedAccount, fetchEncodedAccounts, type Account, type Address, type EncodedAccount, type FetchAccountConfig, type FetchAccountsConfig, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type MaybeAccount, type MaybeEncodedAccount, type ReadonlyUint8Array } from '@solana/kit';
+export declare const ACL_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAclConfigDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AclConfig = {
+    discriminator: ReadonlyUint8Array;
+    /** The wallet this ACL belongs to. */
+    user: Address;
+    /**
+     * Number of `AclPage` PDAs allocated for this user.
+     * Pages are addressed by their index `[0, page_count)`.
+     */
+    pageCount: bigint;
+    /**
+     * Total live entries across all pages. Maintained by the program on
+     * every record/remove ix; lets clients sanity-check fan-out reads.
+     */
+    totalEntries: bigint;
+    /** PDA bump. */
+    bump: number;
+};
+export type AclConfigArgs = {
+    /** The wallet this ACL belongs to. */
+    user: Address;
+    /**
+     * Number of `AclPage` PDAs allocated for this user.
+     * Pages are addressed by their index `[0, page_count)`.
+     */
+    pageCount: number | bigint;
+    /**
+     * Total live entries across all pages. Maintained by the program on
+     * every record/remove ix; lets clients sanity-check fan-out reads.
+     */
+    totalEntries: number | bigint;
+    /** PDA bump. */
+    bump: number;
+};
+/** Gets the encoder for {@link AclConfigArgs} account data. */
+export declare function getAclConfigEncoder(): FixedSizeEncoder<AclConfigArgs>;
+/** Gets the decoder for {@link AclConfig} account data. */
+export declare function getAclConfigDecoder(): FixedSizeDecoder<AclConfig>;
+/** Gets the codec for {@link AclConfig} account data. */
+export declare function getAclConfigCodec(): FixedSizeCodec<AclConfigArgs, AclConfig>;
+export declare function decodeAclConfig<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<AclConfig, TAddress>;
+export declare function decodeAclConfig<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<AclConfig, TAddress>;
+export declare function fetchAclConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<AclConfig, TAddress>>;
+export declare function fetchMaybeAclConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<AclConfig, TAddress>>;
+export declare function fetchAllAclConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<AclConfig>[]>;
+export declare function fetchAllMaybeAclConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<AclConfig>[]>;
+export declare function getAclConfigSize(): number;

package/lib/types/solana/generated/ant/accounts/aclPage.d.ts

@@ -0,0 +1,44 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { fetchEncodedAccount, fetchEncodedAccounts, type Account, type Address, type Codec, type Decoder, type EncodedAccount, type Encoder, type FetchAccountConfig, type FetchAccountsConfig, type MaybeAccount, type MaybeEncodedAccount, type ReadonlyUint8Array } from '@solana/kit';
+import { type AclEntry, type AclEntryArgs } from '../types/index.js';
+export declare const ACL_PAGE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAclPageDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AclPage = {
+    discriminator: ReadonlyUint8Array;
+    /** Owning user (matches `AclConfig.user`). */
+    user: Address;
+    /** Index of this page within the user's ACL. */
+    pageIdx: bigint;
+    /** Live entries on this page. Length ≤ `MAX_ACL_PAGE_ENTRIES`. */
+    entries: Array<AclEntry>;
+    /** PDA bump. */
+    bump: number;
+};
+export type AclPageArgs = {
+    /** Owning user (matches `AclConfig.user`). */
+    user: Address;
+    /** Index of this page within the user's ACL. */
+    pageIdx: number | bigint;
+    /** Live entries on this page. Length ≤ `MAX_ACL_PAGE_ENTRIES`. */
+    entries: Array<AclEntryArgs>;
+    /** PDA bump. */
+    bump: number;
+};
+/** Gets the encoder for {@link AclPageArgs} account data. */
+export declare function getAclPageEncoder(): Encoder<AclPageArgs>;
+/** Gets the decoder for {@link AclPage} account data. */
+export declare function getAclPageDecoder(): Decoder<AclPage>;
+/** Gets the codec for {@link AclPage} account data. */
+export declare function getAclPageCodec(): Codec<AclPageArgs, AclPage>;
+export declare function decodeAclPage<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<AclPage, TAddress>;
+export declare function decodeAclPage<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<AclPage, TAddress>;
+export declare function fetchAclPage<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<AclPage, TAddress>>;
+export declare function fetchMaybeAclPage<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<AclPage, TAddress>>;
+export declare function fetchAllAclPage(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<AclPage>[]>;
+export declare function fetchAllMaybeAclPage(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<AclPage>[]>;

package/lib/types/solana/generated/ant/accounts/antConfig.d.ts

@@ -0,0 +1,63 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { fetchEncodedAccount, fetchEncodedAccounts, type Account, type Address, type Codec, type Decoder, type EncodedAccount, type Encoder, type FetchAccountConfig, type FetchAccountsConfig, type MaybeAccount, type MaybeEncodedAccount, type ReadonlyUint8Array } from '@solana/kit';
+export declare const ANT_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAntConfigDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AntConfig = {
+    discriminator: ReadonlyUint8Array;
+    /** The Metaplex Core asset (NFT mint) this config belongs to */
+    mint: Address;
+    /** ANT display name (max 61 chars, matches Lua Name field) */
+    name: string;
+    /** Ticker symbol (e.g. "ANT") */
+    ticker: string;
+    /** Logo - Arweave transaction ID (43 chars) */
+    logo: string;
+    /** Description (max 256 chars) */
+    description: string;
+    /** Keywords (max 8, each max 32 chars) */
+    keywords: Array<string>;
+    /** Last known NFT owner - for lazy controller cleanup on transfer */
+    lastKnownOwner: Address;
+    /** PDA bump */
+    bump: number;
+    /** Schema version — used for per-ANT data migrations */
+    version: number;
+};
+export type AntConfigArgs = {
+    /** The Metaplex Core asset (NFT mint) this config belongs to */
+    mint: Address;
+    /** ANT display name (max 61 chars, matches Lua Name field) */
+    name: string;
+    /** Ticker symbol (e.g. "ANT") */
+    ticker: string;
+    /** Logo - Arweave transaction ID (43 chars) */
+    logo: string;
+    /** Description (max 256 chars) */
+    description: string;
+    /** Keywords (max 8, each max 32 chars) */
+    keywords: Array<string>;
+    /** Last known NFT owner - for lazy controller cleanup on transfer */
+    lastKnownOwner: Address;
+    /** PDA bump */
+    bump: number;
+    /** Schema version — used for per-ANT data migrations */
+    version: number;
+};
+/** Gets the encoder for {@link AntConfigArgs} account data. */
+export declare function getAntConfigEncoder(): Encoder<AntConfigArgs>;
+/** Gets the decoder for {@link AntConfig} account data. */
+export declare function getAntConfigDecoder(): Decoder<AntConfig>;
+/** Gets the codec for {@link AntConfig} account data. */
+export declare function getAntConfigCodec(): Codec<AntConfigArgs, AntConfig>;
+export declare function decodeAntConfig<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<AntConfig, TAddress>;
+export declare function decodeAntConfig<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<AntConfig, TAddress>;
+export declare function fetchAntConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<AntConfig, TAddress>>;
+export declare function fetchMaybeAntConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<AntConfig, TAddress>>;
+export declare function fetchAllAntConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<AntConfig>[]>;
+export declare function fetchAllMaybeAntConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<AntConfig>[]>;

package/lib/types/solana/generated/ant/accounts/antControllers.d.ts

@@ -0,0 +1,51 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { fetchEncodedAccount, fetchEncodedAccounts, type Account, type Address, type Codec, type Decoder, type EncodedAccount, type Encoder, type FetchAccountConfig, type FetchAccountsConfig, type MaybeAccount, type MaybeEncodedAccount, type ReadonlyUint8Array } from '@solana/kit';
+export declare const ANT_CONTROLLERS_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAntControllersDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AntControllers = {
+    discriminator: ReadonlyUint8Array;
+    /** The Metaplex Core asset this controller list belongs to */
+    mint: Address;
+    /** Controller addresses (max 10) */
+    controllers: Array<Address>;
+    /** PDA bump */
+    bump: number;
+    /**
+     * Schema version — see `ANT_CONTROLLERS_VERSION`. Forward-compat marker
+     * for future schema migrations; production handlers don't currently
+     * branch on it.
+     */
+    version: number;
+};
+export type AntControllersArgs = {
+    /** The Metaplex Core asset this controller list belongs to */
+    mint: Address;
+    /** Controller addresses (max 10) */
+    controllers: Array<Address>;
+    /** PDA bump */
+    bump: number;
+    /**
+     * Schema version — see `ANT_CONTROLLERS_VERSION`. Forward-compat marker
+     * for future schema migrations; production handlers don't currently
+     * branch on it.
+     */
+    version: number;
+};
+/** Gets the encoder for {@link AntControllersArgs} account data. */
+export declare function getAntControllersEncoder(): Encoder<AntControllersArgs>;
+/** Gets the decoder for {@link AntControllers} account data. */
+export declare function getAntControllersDecoder(): Decoder<AntControllers>;
+/** Gets the codec for {@link AntControllers} account data. */
+export declare function getAntControllersCodec(): Codec<AntControllersArgs, AntControllers>;
+export declare function decodeAntControllers<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<AntControllers, TAddress>;
+export declare function decodeAntControllers<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<AntControllers, TAddress>;
+export declare function fetchAntControllers<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<AntControllers, TAddress>>;
+export declare function fetchMaybeAntControllers<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<AntControllers, TAddress>>;
+export declare function fetchAllAntControllers(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<AntControllers>[]>;
+export declare function fetchAllMaybeAntControllers(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<AntControllers>[]>;

package/lib/types/solana/generated/ant/accounts/antMigrationConfig.d.ts

@@ -0,0 +1,44 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { fetchEncodedAccount, fetchEncodedAccounts, type Account, type Address, type EncodedAccount, type FetchAccountConfig, type FetchAccountsConfig, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type MaybeAccount, type MaybeEncodedAccount, type ReadonlyUint8Array } from '@solana/kit';
+export declare const ANT_MIGRATION_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAntMigrationConfigDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AntMigrationConfig = {
+    discriminator: ReadonlyUint8Array;
+    /** Admin authority (multi-sig) */
+    authority: Address;
+    /** Dedicated migration authority (hot key for batch imports) */
+    migrationAuthority: Address;
+    /** Whether migration import is active (permanently disabled by finalize_migration) */
+    migrationActive: boolean;
+    /** PDA bump */
+    bump: number;
+};
+export type AntMigrationConfigArgs = {
+    /** Admin authority (multi-sig) */
+    authority: Address;
+    /** Dedicated migration authority (hot key for batch imports) */
+    migrationAuthority: Address;
+    /** Whether migration import is active (permanently disabled by finalize_migration) */
+    migrationActive: boolean;
+    /** PDA bump */
+    bump: number;
+};
+/** Gets the encoder for {@link AntMigrationConfigArgs} account data. */
+export declare function getAntMigrationConfigEncoder(): FixedSizeEncoder<AntMigrationConfigArgs>;
+/** Gets the decoder for {@link AntMigrationConfig} account data. */
+export declare function getAntMigrationConfigDecoder(): FixedSizeDecoder<AntMigrationConfig>;
+/** Gets the codec for {@link AntMigrationConfig} account data. */
+export declare function getAntMigrationConfigCodec(): FixedSizeCodec<AntMigrationConfigArgs, AntMigrationConfig>;
+export declare function decodeAntMigrationConfig<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<AntMigrationConfig, TAddress>;
+export declare function decodeAntMigrationConfig<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<AntMigrationConfig, TAddress>;
+export declare function fetchAntMigrationConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<AntMigrationConfig, TAddress>>;
+export declare function fetchMaybeAntMigrationConfig<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<AntMigrationConfig, TAddress>>;
+export declare function fetchAllAntMigrationConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<AntMigrationConfig>[]>;
+export declare function fetchAllMaybeAntMigrationConfig(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<AntMigrationConfig>[]>;
+export declare function getAntMigrationConfigSize(): number;

package/lib/types/solana/generated/ant/accounts/antRecord.d.ts

@@ -0,0 +1,75 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { fetchEncodedAccount, fetchEncodedAccounts, type Account, type Address, type Codec, type Decoder, type EncodedAccount, type Encoder, type FetchAccountConfig, type FetchAccountsConfig, type MaybeAccount, type MaybeEncodedAccount, type Option, type OptionOrNullable, type ReadonlyUint8Array } from '@solana/kit';
+export declare const ANT_RECORD_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAntRecordDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AntRecord = {
+    discriminator: ReadonlyUint8Array;
+    /** The Metaplex Core asset this record belongs to */
+    mint: Address;
+    /** The undername (e.g. "@", "blog", "docs") — lowercase */
+    undername: string;
+    /** Content address — Arweave TX ID (43 chars base64url), IPFS CID, or future protocol */
+    target: string;
+    /** Storage protocol (0 = arweave, 1 = ipfs, 2+ = reserved for future) */
+    targetProtocol: number;
+    /** TTL in seconds (60-86400) */
+    ttlSeconds: number;
+    /** Priority for ordering (None = unset, Some(0) required for "@") */
+    priority: Option<number>;
+    /** Optional record owner (delegated control) */
+    owner: Option<Address>;
+    /**
+     * Last reconciled owner — tracks the ANT owner at last record modification.
+     * If this differs from config.last_known_owner, the record's `owner` is cleared
+     * to prevent stale record-level ownership surviving NFT transfers.
+     */
+    lastReconciledOwner: Address;
+    /** PDA bump */
+    bump: number;
+    /** Schema version — see `ANT_RECORD_VERSION`. */
+    version: number;
+};
+export type AntRecordArgs = {
+    /** The Metaplex Core asset this record belongs to */
+    mint: Address;
+    /** The undername (e.g. "@", "blog", "docs") — lowercase */
+    undername: string;
+    /** Content address — Arweave TX ID (43 chars base64url), IPFS CID, or future protocol */
+    target: string;
+    /** Storage protocol (0 = arweave, 1 = ipfs, 2+ = reserved for future) */
+    targetProtocol: number;
+    /** TTL in seconds (60-86400) */
+    ttlSeconds: number;
+    /** Priority for ordering (None = unset, Some(0) required for "@") */
+    priority: OptionOrNullable<number>;
+    /** Optional record owner (delegated control) */
+    owner: OptionOrNullable<Address>;
+    /**
+     * Last reconciled owner — tracks the ANT owner at last record modification.
+     * If this differs from config.last_known_owner, the record's `owner` is cleared
+     * to prevent stale record-level ownership surviving NFT transfers.
+     */
+    lastReconciledOwner: Address;
+    /** PDA bump */
+    bump: number;
+    /** Schema version — see `ANT_RECORD_VERSION`. */
+    version: number;
+};
+/** Gets the encoder for {@link AntRecordArgs} account data. */
+export declare function getAntRecordEncoder(): Encoder<AntRecordArgs>;
+/** Gets the decoder for {@link AntRecord} account data. */
+export declare function getAntRecordDecoder(): Decoder<AntRecord>;
+/** Gets the codec for {@link AntRecord} account data. */
+export declare function getAntRecordCodec(): Codec<AntRecordArgs, AntRecord>;
+export declare function decodeAntRecord<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<AntRecord, TAddress>;
+export declare function decodeAntRecord<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<AntRecord, TAddress>;
+export declare function fetchAntRecord<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<AntRecord, TAddress>>;
+export declare function fetchMaybeAntRecord<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<AntRecord, TAddress>>;
+export declare function fetchAllAntRecord(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<AntRecord>[]>;
+export declare function fetchAllMaybeAntRecord(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<AntRecord>[]>;

package/lib/types/solana/generated/ant/accounts/antRecordMetadata.d.ts

@@ -0,0 +1,59 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { fetchEncodedAccount, fetchEncodedAccounts, type Account, type Address, type Codec, type Decoder, type EncodedAccount, type Encoder, type FetchAccountConfig, type FetchAccountsConfig, type MaybeAccount, type MaybeEncodedAccount, type Option, type OptionOrNullable, type ReadonlyUint8Array } from '@solana/kit';
+export declare const ANT_RECORD_METADATA_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAntRecordMetadataDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AntRecordMetadata = {
+    discriminator: ReadonlyUint8Array;
+    /** The Metaplex Core asset this metadata belongs to (for getProgramAccounts filtering) */
+    mint: Address;
+    /** Hash of the undername (for PDA re-derivation in close/remove operations) */
+    undernameHash: ReadonlyUint8Array;
+    /** Optional display name (max 61 chars) */
+    displayName: Option<string>;
+    /** Optional logo (Arweave TX ID, 43 chars — Arweave-only for permanence) */
+    recordLogo: Option<string>;
+    /** Optional description (max 256 chars) */
+    recordDescription: Option<string>;
+    /** Optional keywords (max 8, each max 32 chars) */
+    recordKeywords: Option<Array<string>>;
+    /** PDA bump */
+    bump: number;
+    /** Schema version — see `ANT_RECORD_METADATA_VERSION`. */
+    version: number;
+};
+export type AntRecordMetadataArgs = {
+    /** The Metaplex Core asset this metadata belongs to (for getProgramAccounts filtering) */
+    mint: Address;
+    /** Hash of the undername (for PDA re-derivation in close/remove operations) */
+    undernameHash: ReadonlyUint8Array;
+    /** Optional display name (max 61 chars) */
+    displayName: OptionOrNullable<string>;
+    /** Optional logo (Arweave TX ID, 43 chars — Arweave-only for permanence) */
+    recordLogo: OptionOrNullable<string>;
+    /** Optional description (max 256 chars) */
+    recordDescription: OptionOrNullable<string>;
+    /** Optional keywords (max 8, each max 32 chars) */
+    recordKeywords: OptionOrNullable<Array<string>>;
+    /** PDA bump */
+    bump: number;
+    /** Schema version — see `ANT_RECORD_METADATA_VERSION`. */
+    version: number;
+};
+/** Gets the encoder for {@link AntRecordMetadataArgs} account data. */
+export declare function getAntRecordMetadataEncoder(): Encoder<AntRecordMetadataArgs>;
+/** Gets the decoder for {@link AntRecordMetadata} account data. */
+export declare function getAntRecordMetadataDecoder(): Decoder<AntRecordMetadata>;
+/** Gets the codec for {@link AntRecordMetadata} account data. */
+export declare function getAntRecordMetadataCodec(): Codec<AntRecordMetadataArgs, AntRecordMetadata>;
+export declare function decodeAntRecordMetadata<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<AntRecordMetadata, TAddress>;
+export declare function decodeAntRecordMetadata<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<AntRecordMetadata, TAddress>;
+export declare function fetchAntRecordMetadata<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<AntRecordMetadata, TAddress>>;
+export declare function fetchMaybeAntRecordMetadata<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<AntRecordMetadata, TAddress>>;
+export declare function fetchAllAntRecordMetadata(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<AntRecordMetadata>[]>;
+export declare function fetchAllMaybeAntRecordMetadata(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<AntRecordMetadata>[]>;

package/lib/types/solana/generated/ant/accounts/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+export * from './aclConfig.js';
+export * from './aclPage.js';
+export * from './antConfig.js';
+export * from './antControllers.js';
+export * from './antMigrationConfig.js';
+export * from './antRecord.js';
+export * from './antRecordMetadata.js';