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

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/events/aclEntryAddedEvent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] AclEntryAddedEvent` emit. The
+ * 8-byte discriminator is sha256("event:AclEntryAddedEvent")[..8].
+ */
+import { type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const ACL_ENTRY_ADDED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAclEntryAddedEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AclEntryAddedEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    address: Address;
+    role: number;
+    timestamp: bigint;
+};
+export type AclEntryAddedEventArgs = {
+    mint: Address;
+    address: Address;
+    role: number;
+    timestamp: number | bigint;
+};
+export declare function getAclEntryAddedEventEncoder(): FixedSizeEncoder<AclEntryAddedEventArgs>;
+export declare function getAclEntryAddedEventDecoder(): FixedSizeDecoder<AclEntryAddedEvent>;
+export declare function getAclEntryAddedEventCodec(): FixedSizeCodec<AclEntryAddedEventArgs, AclEntryAddedEvent>;

package/lib/types/solana/generated/ant/events/aclEntryRemovedEvent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] AclEntryRemovedEvent` emit. The
+ * 8-byte discriminator is sha256("event:AclEntryRemovedEvent")[..8].
+ */
+import { type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const ACL_ENTRY_REMOVED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAclEntryRemovedEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AclEntryRemovedEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    address: Address;
+    role: number;
+    timestamp: bigint;
+};
+export type AclEntryRemovedEventArgs = {
+    mint: Address;
+    address: Address;
+    role: number;
+    timestamp: number | bigint;
+};
+export declare function getAclEntryRemovedEventEncoder(): FixedSizeEncoder<AclEntryRemovedEventArgs>;
+export declare function getAclEntryRemovedEventDecoder(): FixedSizeDecoder<AclEntryRemovedEvent>;
+export declare function getAclEntryRemovedEventCodec(): FixedSizeCodec<AclEntryRemovedEventArgs, AclEntryRemovedEvent>;

package/lib/types/solana/generated/ant/events/antMetadataUpdatedEvent.d.ts

@@ -0,0 +1,28 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] AntMetadataUpdatedEvent` emit. The
+ * 8-byte discriminator is sha256("event:AntMetadataUpdatedEvent")[..8].
+ */
+import { type Address, type Codec, type Decoder, type Encoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const ANT_METADATA_UPDATED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAntMetadataUpdatedEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AntMetadataUpdatedEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    caller: Address;
+    field: number;
+    newValue: string;
+    timestamp: bigint;
+};
+export type AntMetadataUpdatedEventArgs = {
+    mint: Address;
+    caller: Address;
+    field: number;
+    newValue: string;
+    timestamp: number | bigint;
+};
+export declare function getAntMetadataUpdatedEventEncoder(): Encoder<AntMetadataUpdatedEventArgs>;
+export declare function getAntMetadataUpdatedEventDecoder(): Decoder<AntMetadataUpdatedEvent>;
+export declare function getAntMetadataUpdatedEventCodec(): Codec<AntMetadataUpdatedEventArgs, AntMetadataUpdatedEvent>;

package/lib/types/solana/generated/ant/events/antReconciledEvent.d.ts

@@ -0,0 +1,28 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] AntReconciledEvent` emit. The
+ * 8-byte discriminator is sha256("event:AntReconciledEvent")[..8].
+ */
+import { type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const ANT_RECONCILED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAntReconciledEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AntReconciledEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    previousOwner: Address;
+    newOwner: Address;
+    controllersCleared: boolean;
+    timestamp: bigint;
+};
+export type AntReconciledEventArgs = {
+    mint: Address;
+    previousOwner: Address;
+    newOwner: Address;
+    controllersCleared: boolean;
+    timestamp: number | bigint;
+};
+export declare function getAntReconciledEventEncoder(): FixedSizeEncoder<AntReconciledEventArgs>;
+export declare function getAntReconciledEventDecoder(): FixedSizeDecoder<AntReconciledEvent>;
+export declare function getAntReconciledEventCodec(): FixedSizeCodec<AntReconciledEventArgs, AntReconciledEvent>;

package/lib/types/solana/generated/ant/events/antTransferredEvent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] AntTransferredEvent` emit. The
+ * 8-byte discriminator is sha256("event:AntTransferredEvent")[..8].
+ */
+import { type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const ANT_TRANSFERRED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAntTransferredEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AntTransferredEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    from: Address;
+    to: Address;
+    timestamp: bigint;
+};
+export type AntTransferredEventArgs = {
+    mint: Address;
+    from: Address;
+    to: Address;
+    timestamp: number | bigint;
+};
+export declare function getAntTransferredEventEncoder(): FixedSizeEncoder<AntTransferredEventArgs>;
+export declare function getAntTransferredEventDecoder(): FixedSizeDecoder<AntTransferredEvent>;
+export declare function getAntTransferredEventCodec(): FixedSizeCodec<AntTransferredEventArgs, AntTransferredEvent>;

package/lib/types/solana/generated/ant/events/attributesClearedEvent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] AttributesClearedEvent` emit. The
+ * 8-byte discriminator is sha256("event:AttributesClearedEvent")[..8].
+ */
+import { type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const ATTRIBUTES_CLEARED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAttributesClearedEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AttributesClearedEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    authority: Address;
+    keptProgram: boolean;
+    timestamp: bigint;
+};
+export type AttributesClearedEventArgs = {
+    mint: Address;
+    authority: Address;
+    keptProgram: boolean;
+    timestamp: number | bigint;
+};
+export declare function getAttributesClearedEventEncoder(): FixedSizeEncoder<AttributesClearedEventArgs>;
+export declare function getAttributesClearedEventDecoder(): FixedSizeDecoder<AttributesClearedEvent>;
+export declare function getAttributesClearedEventCodec(): FixedSizeCodec<AttributesClearedEventArgs, AttributesClearedEvent>;

package/lib/types/solana/generated/ant/events/attributesSyncedEvent.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] AttributesSyncedEvent` emit. The
+ * 8-byte discriminator is sha256("event:AttributesSyncedEvent")[..8].
+ */
+import { type Address, type Codec, type Decoder, type Encoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const ATTRIBUTES_SYNCED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getAttributesSyncedEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type AttributesSyncedEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    name: string;
+    timestamp: bigint;
+};
+export type AttributesSyncedEventArgs = {
+    mint: Address;
+    name: string;
+    timestamp: number | bigint;
+};
+export declare function getAttributesSyncedEventEncoder(): Encoder<AttributesSyncedEventArgs>;
+export declare function getAttributesSyncedEventDecoder(): Decoder<AttributesSyncedEvent>;
+export declare function getAttributesSyncedEventCodec(): Codec<AttributesSyncedEventArgs, AttributesSyncedEvent>;

package/lib/types/solana/generated/ant/events/controllerAddedEvent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] ControllerAddedEvent` emit. The
+ * 8-byte discriminator is sha256("event:ControllerAddedEvent")[..8].
+ */
+import { type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const CONTROLLER_ADDED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getControllerAddedEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type ControllerAddedEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    owner: Address;
+    controller: Address;
+    timestamp: bigint;
+};
+export type ControllerAddedEventArgs = {
+    mint: Address;
+    owner: Address;
+    controller: Address;
+    timestamp: number | bigint;
+};
+export declare function getControllerAddedEventEncoder(): FixedSizeEncoder<ControllerAddedEventArgs>;
+export declare function getControllerAddedEventDecoder(): FixedSizeDecoder<ControllerAddedEvent>;
+export declare function getControllerAddedEventCodec(): FixedSizeCodec<ControllerAddedEventArgs, ControllerAddedEvent>;

package/lib/types/solana/generated/ant/events/controllerRemovedEvent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] ControllerRemovedEvent` emit. The
+ * 8-byte discriminator is sha256("event:ControllerRemovedEvent")[..8].
+ */
+import { type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const CONTROLLER_REMOVED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getControllerRemovedEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type ControllerRemovedEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    owner: Address;
+    controller: Address;
+    timestamp: bigint;
+};
+export type ControllerRemovedEventArgs = {
+    mint: Address;
+    owner: Address;
+    controller: Address;
+    timestamp: number | bigint;
+};
+export declare function getControllerRemovedEventEncoder(): FixedSizeEncoder<ControllerRemovedEventArgs>;
+export declare function getControllerRemovedEventDecoder(): FixedSizeDecoder<ControllerRemovedEvent>;
+export declare function getControllerRemovedEventCodec(): FixedSizeCodec<ControllerRemovedEventArgs, ControllerRemovedEvent>;

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

@@ -0,0 +1,15 @@
+export * from './aclEntryAddedEvent.js';
+export * from './aclEntryRemovedEvent.js';
+export * from './antMetadataUpdatedEvent.js';
+export * from './antReconciledEvent.js';
+export * from './antTransferredEvent.js';
+export * from './attributesClearedEvent.js';
+export * from './attributesSyncedEvent.js';
+export * from './controllerAddedEvent.js';
+export * from './controllerRemovedEvent.js';
+export * from './recordMetadataPrunedEvent.js';
+export * from './recordMetadataRemovedEvent.js';
+export * from './recordMetadataUpdatedEvent.js';
+export * from './recordRemovedEvent.js';
+export * from './recordSetEvent.js';
+export * from './recordTransferredEvent.js';

package/lib/types/solana/generated/ant/events/recordMetadataPrunedEvent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] RecordMetadataPrunedEvent` emit. The
+ * 8-byte discriminator is sha256("event:RecordMetadataPrunedEvent")[..8].
+ */
+import { type Address, type Codec, type Decoder, type Encoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const RECORD_METADATA_PRUNED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getRecordMetadataPrunedEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type RecordMetadataPrunedEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    undername: string;
+    pruner: Address;
+    timestamp: bigint;
+};
+export type RecordMetadataPrunedEventArgs = {
+    mint: Address;
+    undername: string;
+    pruner: Address;
+    timestamp: number | bigint;
+};
+export declare function getRecordMetadataPrunedEventEncoder(): Encoder<RecordMetadataPrunedEventArgs>;
+export declare function getRecordMetadataPrunedEventDecoder(): Decoder<RecordMetadataPrunedEvent>;
+export declare function getRecordMetadataPrunedEventCodec(): Codec<RecordMetadataPrunedEventArgs, RecordMetadataPrunedEvent>;

package/lib/types/solana/generated/ant/events/recordMetadataRemovedEvent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] RecordMetadataRemovedEvent` emit. The
+ * 8-byte discriminator is sha256("event:RecordMetadataRemovedEvent")[..8].
+ */
+import { type Address, type Codec, type Decoder, type Encoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const RECORD_METADATA_REMOVED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getRecordMetadataRemovedEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type RecordMetadataRemovedEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    caller: Address;
+    undername: string;
+    timestamp: bigint;
+};
+export type RecordMetadataRemovedEventArgs = {
+    mint: Address;
+    caller: Address;
+    undername: string;
+    timestamp: number | bigint;
+};
+export declare function getRecordMetadataRemovedEventEncoder(): Encoder<RecordMetadataRemovedEventArgs>;
+export declare function getRecordMetadataRemovedEventDecoder(): Decoder<RecordMetadataRemovedEvent>;
+export declare function getRecordMetadataRemovedEventCodec(): Codec<RecordMetadataRemovedEventArgs, RecordMetadataRemovedEvent>;

package/lib/types/solana/generated/ant/events/recordMetadataUpdatedEvent.d.ts

@@ -0,0 +1,28 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] RecordMetadataUpdatedEvent` emit. The
+ * 8-byte discriminator is sha256("event:RecordMetadataUpdatedEvent")[..8].
+ */
+import { type Address, type Codec, type Decoder, type Encoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const RECORD_METADATA_UPDATED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getRecordMetadataUpdatedEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type RecordMetadataUpdatedEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    caller: Address;
+    undername: string;
+    field: number;
+    timestamp: bigint;
+};
+export type RecordMetadataUpdatedEventArgs = {
+    mint: Address;
+    caller: Address;
+    undername: string;
+    field: number;
+    timestamp: number | bigint;
+};
+export declare function getRecordMetadataUpdatedEventEncoder(): Encoder<RecordMetadataUpdatedEventArgs>;
+export declare function getRecordMetadataUpdatedEventDecoder(): Decoder<RecordMetadataUpdatedEvent>;
+export declare function getRecordMetadataUpdatedEventCodec(): Codec<RecordMetadataUpdatedEventArgs, RecordMetadataUpdatedEvent>;

package/lib/types/solana/generated/ant/events/recordRemovedEvent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] RecordRemovedEvent` emit. The
+ * 8-byte discriminator is sha256("event:RecordRemovedEvent")[..8].
+ */
+import { type Address, type Codec, type Decoder, type Encoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const RECORD_REMOVED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getRecordRemovedEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type RecordRemovedEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    caller: Address;
+    undername: string;
+    timestamp: bigint;
+};
+export type RecordRemovedEventArgs = {
+    mint: Address;
+    caller: Address;
+    undername: string;
+    timestamp: number | bigint;
+};
+export declare function getRecordRemovedEventEncoder(): Encoder<RecordRemovedEventArgs>;
+export declare function getRecordRemovedEventDecoder(): Decoder<RecordRemovedEvent>;
+export declare function getRecordRemovedEventCodec(): Codec<RecordRemovedEventArgs, RecordRemovedEvent>;

package/lib/types/solana/generated/ant/events/recordSetEvent.d.ts

@@ -0,0 +1,34 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] RecordSetEvent` emit. The
+ * 8-byte discriminator is sha256("event:RecordSetEvent")[..8].
+ */
+import { type Address, type Codec, type Decoder, type Encoder, type ReadonlyUint8Array } from '@solana/kit';
+export declare const RECORD_SET_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getRecordSetEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type RecordSetEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    caller: Address;
+    undername: string;
+    target: string;
+    targetProtocol: number;
+    ttlSeconds: number;
+    priority: number;
+    timestamp: bigint;
+};
+export type RecordSetEventArgs = {
+    mint: Address;
+    caller: Address;
+    undername: string;
+    target: string;
+    targetProtocol: number;
+    ttlSeconds: number;
+    priority: number;
+    timestamp: number | bigint;
+};
+export declare function getRecordSetEventEncoder(): Encoder<RecordSetEventArgs>;
+export declare function getRecordSetEventDecoder(): Decoder<RecordSetEvent>;
+export declare function getRecordSetEventCodec(): Codec<RecordSetEventArgs, RecordSetEvent>;

package/lib/types/solana/generated/ant/events/recordTransferredEvent.d.ts

@@ -0,0 +1,30 @@
+/**
+ * This code was AUTOGENERATED by sdk/scripts/events-codegen.mjs.
+ * Please DO NOT EDIT THIS FILE — re-run `yarn codegen` instead.
+ *
+ * Decoder for the Anchor `#[event] RecordTransferredEvent` emit. The
+ * 8-byte discriminator is sha256("event:RecordTransferredEvent")[..8].
+ */
+import { type Address, type Codec, type Decoder, type Encoder, type Option, type OptionOrNullable, type ReadonlyUint8Array } from '@solana/kit';
+export declare const RECORD_TRANSFERRED_EVENT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getRecordTransferredEventDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type RecordTransferredEvent = {
+    discriminator: ReadonlyUint8Array;
+    mint: Address;
+    caller: Address;
+    undername: string;
+    previousOwner: Option<Address>;
+    newOwner: Address;
+    timestamp: bigint;
+};
+export type RecordTransferredEventArgs = {
+    mint: Address;
+    caller: Address;
+    undername: string;
+    previousOwner: OptionOrNullable<Address>;
+    newOwner: Address;
+    timestamp: number | bigint;
+};
+export declare function getRecordTransferredEventEncoder(): Encoder<RecordTransferredEventArgs>;
+export declare function getRecordTransferredEventDecoder(): Decoder<RecordTransferredEvent>;
+export declare function getRecordTransferredEventCodec(): Codec<RecordTransferredEventArgs, RecordTransferredEvent>;