@ar.io/sdk 3.24.0 → 4.0.0-alpha.1

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { AOProcess } from '../common/index.js';
-import { AoCreatePrimaryNameRequest, AoMessageResult, AoPrimaryName, AoPrimaryNameRequest, AoRedelegationFeeInfo, AoWriteAction, AtLeastOne, BlockHeight, BuyArNSNameProgressEvents, ProcessId, SetPrimaryNameProgressEvents, Timestamp, TransactionId, WalletAddress, WriteOptions } from './index.js';
+import { AtLeastOne, BlockHeight, BuyArNSNameProgressEvents, CreatePrimaryNameRequest, MessageResult, PrimaryName, PrimaryNameRequest, ProcessId, RedelegationFeeInfo, SetPrimaryNameProgressEvents, Timestamp, TransactionId, WalletAddress, WriteAction, WriteOptions } from './index.js';
 import { mARIOToken } from './token.js';
 type NestedKeys<T> = T extends object ? T extends readonly unknown[] ? never : {
     [K in keyof T & string]: T[K] extends object ? `${K}.${NestedKeys<T[K]>}` : K;
@@ -39,91 +38,87 @@ export type PaginationResult<T> = {
 export type ProcessIdConfig = {
     processId?: string;
 };
-export type ProcessConfig = {
-    process?: AOProcess;
-};
-export type ProcessConfiguration = ProcessConfig | ProcessIdConfig;
 export type EpochTimestampInput = {
     timestamp: Timestamp;
 };
 export type EpochIndexInput = {
-    epochIndex: AoEpochIndex;
+    epochIndex: EpochIndex;
 };
 export type EpochInput = EpochTimestampInput | EpochIndexInput | undefined;
-export type AoBalances = Record<WalletAddress, number>;
-export type AoRegistrationFees = Record<number, {
+export type Balances = Record<WalletAddress, number>;
+export type RegistrationFees = Record<number, {
     lease: Record<number, number>;
     permabuy: number;
 }>;
-export type AoEpochIndex = number;
-export type AoEpochObservationData = {
+export type EpochIndex = number;
+export type EpochObservationData = {
     failureSummaries: Record<WalletAddress, WalletAddress[]>;
     reports: Record<WalletAddress, TransactionId>;
 };
-export type AoEpochPrescribedObservers = Record<WalletAddress, WalletAddress[]>;
-export type AoVaultData = {
+export type EpochPrescribedObservers = Record<WalletAddress, WalletAddress[]>;
+export type VaultData = {
     balance: number;
     startTimestamp: Timestamp;
     endTimestamp: Timestamp;
     controller?: WalletAddress;
 };
-export type AoArNSReservedNameData = {
+export type ArNSReservedNameData = {
     target?: string;
     endTimestamp?: number;
 };
-export type AoArNSNameData = AoArNSPermabuyData | AoArNSLeaseData;
-export type AoArNSNameDataWithName = AoArNSNameData & {
+export type ArNSNameData = ArNSPermabuyData | ArNSLeaseData;
+export type ArNSNameDataWithName = ArNSNameData & {
     name: string;
 };
-export type AoArNSReservedNameDataWithName = AoArNSReservedNameData & {
+export type ArNSReservedNameDataWithName = ArNSReservedNameData & {
     name: string;
 };
-export type AoArNSBaseNameData = {
+export type ArNSBaseNameData = {
     processId: ProcessId;
     startTimestamp: number;
     type: 'lease' | 'permabuy';
     undernameLimit: number;
     purchasePrice: number;
 };
-export type AoArNSPermabuyData = AoArNSBaseNameData & {
+export type ArNSPermabuyData = ArNSBaseNameData & {
     type: 'permabuy';
 };
-export type AoArNSLeaseData = AoArNSBaseNameData & {
+export type ArNSLeaseData = ArNSBaseNameData & {
     type: 'lease';
     endTimestamp: Timestamp;
 };
-export type AoEpochSettings = {
+export type EpochSettings = {
     epochZeroStartTimestamp: Timestamp;
     durationMs: number;
     prescribedNameCount: number;
     maxObservers: number;
 };
-export type AoEpochDistributionTotalsData = {
+export type EpochDistributionTotalsData = {
     totalEligibleGateways: number;
     totalEligibleRewards: number;
     totalEligibleObserverReward: number;
     totalEligibleGatewayReward: number;
 };
 /** @deprecated Use getEligibleEpochRewards getEpochDistributions, will be removed in a future release  */
-export type AoEpochDistributionRewards = {
+export type EpochDistributionRewards = {
     eligible: Record<WalletAddress, {
         delegateRewards: Record<WalletAddress, number>;
         operatorReward: number;
     }>;
     distributed: Record<WalletAddress, number>;
 };
-export type AoEpochDistributed = AoEpochDistributionTotalsData & {
+export type EpochDistributed = EpochDistributionTotalsData & {
     /** @deprecated Use getEligibleEpochRewards getEpochDistributions, will be removed in a future release  */
-    rewards: AoEpochDistributionRewards;
+    rewards: EpochDistributionRewards;
     distributedTimestamp: Timestamp;
     totalDistributedRewards: number;
 };
-export type AoEpochDistributionData = AoEpochDistributionTotalsData | AoEpochDistributed;
-export type AoEpochData<D = AoEpochDistributionData> = {
-    epochIndex: AoEpochIndex;
+export type EpochDistributionData = EpochDistributionTotalsData | EpochDistributed;
+export type EpochData<D = EpochDistributionData> = {
+    epochIndex: EpochIndex;
     startHeight: BlockHeight;
-    observations: AoEpochObservationData;
-    prescribedObservers: AoWeightedObserver[];
+    observations: EpochObservationData;
+    prescribedObservers: WeightedObserver[];
     prescribedNames: string[];
     startTimestamp: Timestamp;
     endTimestamp: Timestamp;
@@ -136,20 +131,30 @@ export type AoEpochData<D = AoEpochDistributionData> = {
         totalReservedNames: number;
     };
 };
-export declare const isDistributedEpochData: (data: AoEpochDistributed | AoEpochDistributionTotalsData) => data is AoEpochDistributed;
-export declare const isDistributedEpoch: (data: AoEpochData) => data is AoEpochData<AoEpochDistributed> & {
+export declare const isDistributedEpochData: (data: EpochDistributed | EpochDistributionTotalsData) => data is EpochDistributed;
+export declare const isDistributedEpoch: (data: EpochData) => data is EpochData<EpochDistributed> & {
     distributions: {
         rewards: object;
     };
 };
-export type AoEligibleDistribution = {
+export type EligibleDistribution = {
     type: 'operatorReward' | 'delegateReward';
     recipient: WalletAddress;
     eligibleReward: number;
     gatewayAddress: WalletAddress;
     cursorId: string;
 };
-export type AoTokenSupplyData = {
+/**
+ * The six ARIO supply buckets. They are mutually exclusive and sum to `total`:
+ *   circulating + locked + staked + delegated + withdrawn + protocolBalance === total
+ *
+ * `protocolBalance` is the protocol **reward reserve** (the pool epoch rewards
+ * are paid from) — on Solana this is the live balance of the protocol token
+ * account, matching AO's `protocolBalance` (the qNvAoz0 reserve). It is NOT the
+ * on-chain `ArioConfig.protocol_balance` accounting field, which folds the
+ * staking buckets in and would double-count.
+ */
+export type TokenSupplyData = {
     total: number;
     circulating: number;
     locked: number;
@@ -158,34 +163,34 @@ export type AoTokenSupplyData = {
     staked: number;
     protocolBalance: number;
 };
-export type AoGatewayService = {
+export type GatewayService = {
     fqdn: string;
     path: string;
     protocol: 'https';
     port: number;
 };
-export type AoGatewayServices = {
-    bundlers: AoGatewayService[];
+export type GatewayServices = {
+    bundlers: GatewayService[];
 };
-export type AoGatewayDelegates = Record<WalletAddress, AoGatewayDelegate>;
-export type AoGatewayDelegateAllowList = WalletAddress[];
-export type AoWalletVault = AoVaultData & {
+export type GatewayDelegates = Record<WalletAddress, GatewayDelegate>;
+export type GatewayDelegateAllowList = WalletAddress[];
+export type WalletVault = VaultData & {
     address: WalletAddress;
     vaultId: string;
 };
-export type AoGateway = {
-    settings: AoGatewaySettings;
-    stats: AoGatewayStats;
+export type Gateway = {
+    settings: GatewaySettings;
+    stats: GatewayStats;
     totalDelegatedStake: number;
     startTimestamp: Timestamp;
     endTimestamp: Timestamp;
     observerAddress: WalletAddress;
     operatorStake: number;
     status: 'joined' | 'leaving';
-    weights: AoGatewayWeights;
-    services?: AoGatewayServices;
+    weights: GatewayWeights;
+    services?: GatewayServices;
 };
-export type AoGatewayStats = {
+export type GatewayStats = {
     passedConsecutiveEpochs: number;
     failedConsecutiveEpochs: number;
     totalEpochCount: number;
@@ -194,13 +199,13 @@ export type AoGatewayStats = {
     observedEpochCount: number;
     prescribedEpochCount: number;
 };
-export type AoWeightedObserver = {
+export type WeightedObserver = {
     gatewayAddress: WalletAddress;
     observerAddress: WalletAddress;
     stake: number;
     startTimestamp: number;
-} & AoGatewayWeights;
-export type AoGatewayWeights = {
+} & GatewayWeights;
+export type GatewayWeights = {
     stakeWeight: number;
     tenureWeight: number;
     gatewayRewardRatioWeight: number;
@@ -210,22 +215,22 @@ export type AoGatewayWeights = {
     compositeWeight: number;
     normalizedCompositeWeight: number;
 };
-export type AoGatewayWithAddress = AoGateway & {
+export type GatewayWithAddress = Gateway & {
     gatewayAddress: WalletAddress;
 };
-export type AoGatewayDelegate = {
+export type GatewayDelegate = {
     delegatedStake: number;
     startTimestamp: Timestamp;
 };
-export type AoGatewayDelegateWithAddress = AoGatewayDelegate & {
+export type GatewayDelegateWithAddress = GatewayDelegate & {
     address: WalletAddress;
 };
-export type AoAllDelegates = AoGatewayDelegateWithAddress & {
+export type AllDelegates = GatewayDelegateWithAddress & {
     gatewayAddress: WalletAddress;
     vaultedStake: number;
     cursorId: string;
 };
-export type AoGatewaySettings = {
+export type GatewaySettings = {
     allowDelegatedStaking: boolean | 'allowlist';
     delegateRewardShareRatio: number;
     allowedDelegates: WalletAddress[];
@@ -237,35 +242,51 @@ export type AoGatewaySettings = {
     fqdn: string;
     port: number;
     protocol: 'https';
-};
-export type AoBalanceWithAddress = {
+    /**
+     * Solana only (GATEWAY_VERSION 1.1.0+). A `delegateRewardShareRatio` change
+     * requested mid-epoch is staged here and applied at the next epoch's
+     * `tally_weights` (WP §6.3 / Fix #7), so the active value stays epoch-stable.
+     * When set, render the active `delegateRewardShareRatio` as the current rate
+     * and this as "pending until next epoch". Percent (0-95), same scale as
+     * `delegateRewardShareRatio`. Undefined when no change is queued.
+     */
+    pendingDelegateRewardShareRatio?: number;
+    /**
+     * Solana only (GATEWAY_VERSION 1.1.0+). Unix seconds when the operator
+     * disabled delegation (WP §6.3 / Fix #6). Re-enabling is blocked until every
+     * delegate has been withdrawn AND the withdrawal-period cooldown has elapsed
+     * since this time. Undefined when delegation is enabled.
+     */
+    delegationDisabledAt?: number;
+};
+export type BalanceWithAddress = {
     address: WalletAddress;
     balance: number;
 };
-export type AoReturnedName = {
+export type ReturnedName = {
     name: string;
     startTimestamp: Timestamp;
     endTimestamp: Timestamp;
     initiator: string;
     premiumMultiplier: number;
 };
-export type AoDelegationBase = {
+export type DelegationBase = {
     type: 'stake' | 'vault';
     gatewayAddress: WalletAddress;
     delegationId: string;
 };
-export type AoVaultDelegation = AoDelegationBase & AoVaultData & {
+export type VaultDelegation = DelegationBase & VaultData & {
     type: 'vault';
     vaultId: TransactionId;
 };
-export type AoStakeDelegation = AoDelegationBase & {
+export type StakeDelegation = DelegationBase & {
     type: 'stake';
     startTimestamp: Timestamp;
     balance: number;
 };
-export type AoDelegation = AoStakeDelegation | AoVaultDelegation;
+export type Delegation = StakeDelegation | VaultDelegation;
 /** Operator stake being withdrawn from a given gateway */
-export type AoGatewayVault = {
+export type GatewayVault = {
     cursorId: string;
     vaultId: TransactionId;
     balance: number;
@@ -273,28 +294,38 @@ export type AoGatewayVault = {
     startTimestamp: Timestamp;
 };
 /** Operator stake being withdrawn from all gateway gateways */
-export type AoAllGatewayVaults = AoGatewayVault & {
+export type AllGatewayVaults = GatewayVault & {
     gatewayAddress: WalletAddress;
 };
-export type AoJoinNetworkParams = Pick<AoGateway, 'operatorStake'> & Partial<AoGatewaySettings> & {
+/**
+ * A pending or matured stake withdrawal owned by a wallet. Covers both
+ * operator-stake decreases and delegate-stake decreases — discriminate with
+ * `isDelegate`. A withdrawal is claimable when `Date.now() >= endTimestamp`.
+ *
+ * Solana-only: AO releases withdrawals automatically at maturity and has no
+ * equivalent per-owner read.
+ */
+export type UserWithdrawal = AllGatewayVaults & {
+    isDelegate: boolean;
+};
+export type JoinNetworkParams = Pick<Gateway, 'operatorStake'> & Partial<GatewaySettings> & {
     observerAddress?: WalletAddress;
-    services?: AoGatewayServices;
 };
-export type AoUpdateGatewaySettingsParams = AtLeastOne<Omit<AoJoinNetworkParams, 'operatorStake'>>;
-export type AoArNSNameParams = {
+export type UpdateGatewaySettingsParams = AtLeastOne<Omit<JoinNetworkParams, 'operatorStake'>>;
+export type ArNSNameParams = {
     name: string;
 };
-export type AoAddressParams = {
+export type AddressParams = {
     address: WalletAddress;
 };
-export type AoBalanceParams = AoAddressParams;
-export type AoPaginatedAddressParams = PaginationParams<string> & AoAddressParams;
-export type AoDelegateStakeParams = {
+export type BalanceParams = AddressParams;
+export type PaginatedAddressParams = PaginationParams<string> & AddressParams;
+export type DelegateStakeParams = {
     target: WalletAddress;
     stakeQty: number | mARIOToken;
 };
-export type AoGetArNSRecordsParams = PaginationParams<AoArNSNameDataWithName>;
-export type AoRedelegateStakeParams = {
+export type GetArNSRecordsParams = PaginationParams<ArNSNameDataWithName>;
+export type RedelegateStakeParams = {
     target: string;
     source: string;
     stakeQty: number | mARIOToken;
@@ -304,7 +335,7 @@ export declare const validIntents: readonly ["Buy-Name", "Buy-Record", "Extend-L
 export declare const intentsUsingYears: readonly ["Buy-Record", "Buy-Name", "Extend-Lease"];
 export type Intent = (typeof validIntents)[number];
 export declare const isValidIntent: (intent: string) => intent is Intent;
-export type AoTokenCostParams = {
+export type TokenCostParams = {
     intent: Intent;
     type?: 'permabuy' | 'lease';
     years?: number;
@@ -312,13 +343,44 @@ export type AoTokenCostParams = {
     quantity?: number;
     fromAddress?: WalletAddress;
 };
-export declare const fundFromOptions: readonly ["balance", "stakes", "any", "turbo"];
+export declare const fundFromOptions: readonly ["balance", "stakes", "withdrawal", "plan", "any", "turbo"];
 export type FundFrom = (typeof fundFromOptions)[number];
 export declare const isValidFundFrom: (fundFrom: string) => fundFrom is FundFrom;
-export type AoGetCostDetailsParams = AoTokenCostParams & {
+/**
+ * One entry in a multi-source funding plan. Mirrors the on-chain
+ * `ario_gar::FundingSourceSpec` shape (kind + amount); `gateway` is an
+ * SDK-side hint for explicit (non-discovered) plans so the executor knows
+ * which gateway PDA to slot in for `Delegation` / `OperatorStake` sources.
+ *
+ * Multi-gateway: `Delegation` sources may span up to MAX_DELEGATION_SOURCES
+ * (3) distinct gateways per plan. `Balance` and `Withdrawal` sources are
+ * gateway-independent. Hard cap of MAX_FUNDING_SOURCES (5) total sources
+ * per `pay_from_funding_plan` call.
+ */
+export type FundingSourceKind = 'balance' | 'delegation' | 'operatorStake' | 'withdrawal';
+export type FundingSourceSpec = {
+    kind: FundingSourceKind;
+    /** mARIO amount drawn from this source. Must be > 0. */
+    amount: bigint;
+    /**
+     * Bound gateway (base58). Required for `delegation` / `operatorStake` in
+     * multi-gateway explicit plans; ignored for `balance` / `withdrawal`. When
+     * omitted on stake-locked sources, the executor falls back to
+     * `params.gatewayAddress`.
+     */
+    gateway?: WalletAddress;
+    /**
+     * Withdrawal vault id — required for `kind: 'withdrawal'` in multi-
+     * withdrawal plans. Single-withdrawal plans may omit it and rely on
+     * `params.withdrawalId`. Ignored for non-withdrawal kinds. Client-side
+     * metadata only — does NOT change the on-chain wire format.
+     */
+    withdrawalId?: bigint;
+};
+export type GetCostDetailsParams = TokenCostParams & {
     fundFrom?: FundFrom;
 };
-export type AoFundingPlan = {
+export type FundingPlan = {
     address: WalletAddress;
     balance: number;
     stakes: Record<WalletAddress, {
@@ -336,55 +398,68 @@ export type CostDiscount = {
 export type CostDetailsResult = {
     tokenCost: number;
     discounts: CostDiscount[];
-    returnedNameDetails?: AoReturnedName & {
+    returnedNameDetails?: ReturnedName & {
         basePrice: number;
     };
-    fundingPlan?: AoFundingPlan;
+    fundingPlan?: FundingPlan;
     wincQty?: string;
 };
-export type AoGetVaultParams = {
+export type GetVaultParams = {
     address: WalletAddress;
     vaultId: string;
 };
-export type AoArNSPurchaseParams = AoArNSNameParams & {
+export type ArNSPurchaseParams = ArNSNameParams & {
     fundFrom?: FundFrom;
+    /** Gateway operator address — required when fundFrom is 'stakes' */
+    gatewayAddress?: WalletAddress;
+    /** If true, fund from operator stake instead of delegation (default: delegation) */
+    fundAsOperator?: boolean;
+    /** Withdrawal vault id — required when fundFrom is 'withdrawal' (Solana only) */
+    withdrawalId?: bigint;
+    /**
+     * Explicit funding plan — when provided AND fundFrom is 'plan' or 'any',
+     * the SDK skips source discovery and uses these sources verbatim. Caller
+     * is responsible for matching `sum(amounts) == cost` and respecting the
+     * single-gateway invariant. Solana only.
+     */
+    sources?: FundingSourceSpec[];
     paidBy?: WalletAddress | WalletAddress[];
     referrer?: string;
 };
-export type AoBuyRecordParams = AoArNSPurchaseParams & {
+export type BuyRecordParams = ArNSPurchaseParams & {
     years?: number;
     type: 'lease' | 'permabuy';
     processId?: string;
 };
-export type AoExtendLeaseParams = AoArNSPurchaseParams & {
+export type ExtendLeaseParams = ArNSPurchaseParams & {
     years: number;
 };
-export type AoIncreaseUndernameLimitParams = AoArNSPurchaseParams & {
+export type IncreaseUndernameLimitParams = ArNSPurchaseParams & {
     increaseCount: number;
 };
-export type AoVaultedTransferParams = {
+export type VaultedTransferParams = {
     recipient: WalletAddress;
     quantity: mARIOToken | number;
     lockLengthMs: number;
     revokable?: boolean;
 };
-export type AoRevokeVaultParams = {
+export type RevokeVaultParams = {
     vaultId: TransactionId;
     recipient: WalletAddress;
 };
-export type AoCreateVaultParams = {
+export type CreateVaultParams = {
     quantity: mARIOToken | number;
     lockLengthMs: number;
 };
-export type AoExtendVaultParams = {
+export type ExtendVaultParams = {
     vaultId: string;
     extendLengthMs: number;
 };
-export type AoIncreaseVaultParams = {
+export type IncreaseVaultParams = {
     vaultId: string;
     quantity: mARIOToken | number;
 };
-export type AoGatewayRegistrySettings = {
+export type GatewayRegistrySettings = {
     delegates: {
         minStake: number;
         withdrawLengthMs: number;
@@ -439,8 +514,7 @@ export interface ArNSNameResolver {
         name: string;
     }): Promise<ArNSNameResolutionData>;
 }
-export interface AoARIORead extends ArNSNameResolver {
-    process: AOProcess;
+export interface ARIORead extends ArNSNameResolver {
     getInfo(): Promise<{
         Ticker: string;
         Name: string;
@@ -450,117 +524,129 @@ export interface AoARIORead extends ArNSNameResolver {
         LastCreatedEpochIndex: number;
         LastDistributedEpochIndex: number;
     }>;
-    getTokenSupply(): Promise<AoTokenSupplyData>;
-    getEpochSettings(): Promise<AoEpochSettings>;
-    getGateway({ address }: AoAddressParams): Promise<AoGateway>;
-    getGatewayDelegates({ address, ...pageParams }: AoAddressParams & PaginationParams<AoGatewayDelegateWithAddress>): Promise<PaginationResult<AoGatewayDelegateWithAddress>>;
-    getGatewayDelegateAllowList(params: AoPaginatedAddressParams): Promise<PaginationResult<WalletAddress>>;
-    getGateways(params?: PaginationParams<AoGatewayWithAddress>): Promise<PaginationResult<AoGatewayWithAddress>>;
-    getDelegations(params: PaginationParams<AoDelegation> & {
+    getTokenSupply(): Promise<TokenSupplyData>;
+    getEpochSettings(): Promise<EpochSettings>;
+    getGateway({ address }: AddressParams): Promise<Gateway>;
+    getGatewayDelegates({ address, ...pageParams }: AddressParams & PaginationParams<GatewayDelegateWithAddress>): Promise<PaginationResult<GatewayDelegateWithAddress>>;
+    getGatewayDelegateAllowList(params: PaginatedAddressParams): Promise<PaginationResult<WalletAddress>>;
+    getGateways(params?: PaginationParams<GatewayWithAddress>): Promise<PaginationResult<GatewayWithAddress>>;
+    getDelegations(params: PaginationParams<Delegation> & {
         address: WalletAddress;
-    }): Promise<PaginationResult<AoDelegation>>;
-    getAllowedDelegates(params: AoPaginatedAddressParams): Promise<PaginationResult<WalletAddress>>;
-    getGatewayVaults(params: PaginationParams<AoGatewayVault> & {
+    }): Promise<PaginationResult<Delegation>>;
+    getAllowedDelegates(params: PaginatedAddressParams): Promise<PaginationResult<WalletAddress>>;
+    getGatewayVaults(params: PaginationParams<GatewayVault> & {
         address: WalletAddress;
-    }): Promise<PaginationResult<AoGatewayVault>>;
+    }): Promise<PaginationResult<GatewayVault>>;
     getBalance(params: {
         address: WalletAddress;
     }): Promise<number>;
-    getBalances(params?: PaginationParams<AoBalanceWithAddress>): Promise<PaginationResult<AoBalanceWithAddress>>;
+    getBalances(params?: PaginationParams<BalanceWithAddress>): Promise<PaginationResult<BalanceWithAddress>>;
     getArNSRecord({ name }: {
         name: string;
-    }): Promise<AoArNSNameData>;
-    getArNSRecords(params?: AoGetArNSRecordsParams): Promise<PaginationResult<AoArNSNameDataWithName>>;
-    getArNSRecordsForAddress(params: PaginationParams<AoArNSNameDataWithName> & {
+    }): Promise<ArNSNameData>;
+    getArNSRecords(params?: GetArNSRecordsParams): Promise<PaginationResult<ArNSNameDataWithName>>;
+    getArNSRecordsForAddress(params: PaginationParams<ArNSNameDataWithName> & {
         address: WalletAddress;
         antRegistryProcessId?: string;
-    }): Promise<PaginationResult<AoArNSNameDataWithName>>;
-    getArNSReservedNames(params?: PaginationParams<AoArNSReservedNameDataWithName>): Promise<PaginationResult<AoArNSReservedNameDataWithName>>;
+    }): Promise<PaginationResult<ArNSNameDataWithName>>;
+    getArNSReservedNames(params?: PaginationParams<ArNSReservedNameDataWithName>): Promise<PaginationResult<ArNSReservedNameDataWithName>>;
     getArNSReservedName({ name, }: {
         name: string;
-    }): Promise<AoArNSReservedNameData>;
-    getArNSReturnedNames(params?: PaginationParams<AoReturnedName>): Promise<PaginationResult<AoReturnedName>>;
+    }): Promise<ArNSReservedNameData>;
+    getArNSReturnedNames(params?: PaginationParams<ReturnedName>): Promise<PaginationResult<ReturnedName>>;
     getArNSReturnedName({ name }: {
         name: string;
-    }): Promise<AoReturnedName>;
-    getEpoch(epoch?: EpochInput): Promise<AoEpochData>;
-    getCurrentEpoch(): Promise<AoEpochData>;
-    getPrescribedObservers(epoch?: EpochInput): Promise<AoWeightedObserver[]>;
+    }): Promise<ReturnedName>;
+    getEpoch(epoch?: EpochInput): Promise<EpochData>;
+    getCurrentEpoch(): Promise<EpochData>;
+    getPrescribedObservers(epoch?: EpochInput): Promise<WeightedObserver[]>;
     getPrescribedNames(epoch?: EpochInput): Promise<string[]>;
-    getObservations(epoch?: EpochInput): Promise<AoEpochObservationData>;
-    getDistributions(epoch?: EpochInput): Promise<AoEpochDistributionData>;
-    getEligibleEpochRewards(epoch?: EpochInput, params?: PaginationParams<AoEligibleDistribution>): Promise<PaginationResult<AoEligibleDistribution>>;
-    getTokenCost({ intent, type, years, name, quantity, }: AoTokenCostParams): Promise<number>;
-    getCostDetails({ intent, type, years, name, quantity, fundFrom, }: AoGetCostDetailsParams): Promise<CostDetailsResult>;
-    getRegistrationFees(): Promise<AoRegistrationFees>;
+    getObservations(epoch?: EpochInput): Promise<EpochObservationData>;
+    getDistributions(epoch?: EpochInput): Promise<EpochDistributionData>;
+    getEligibleEpochRewards(epoch?: EpochInput, params?: PaginationParams<EligibleDistribution>): Promise<PaginationResult<EligibleDistribution>>;
+    getTokenCost({ intent, type, years, name, quantity, }: TokenCostParams): Promise<number>;
+    getCostDetails({ intent, type, years, name, quantity, fundFrom, }: GetCostDetailsParams): Promise<CostDetailsResult>;
+    getRegistrationFees(): Promise<RegistrationFees>;
     getDemandFactor(): Promise<number>;
     getDemandFactorSettings(): Promise<DemandFactorSettings>;
-    getVaults(params?: PaginationParams<AoWalletVault>): Promise<PaginationResult<AoWalletVault>>;
-    getVault({ address, vaultId }: AoGetVaultParams): Promise<AoVaultData>;
+    getVaults(params?: PaginationParams<WalletVault>): Promise<PaginationResult<WalletVault>>;
+    getVault({ address, vaultId }: GetVaultParams): Promise<VaultData>;
     getPrimaryNameRequest(params: {
         initiator: WalletAddress;
-    }): Promise<AoPrimaryNameRequest>;
-    getPrimaryNameRequests(params?: PaginationParams<AoPrimaryNameRequest>): Promise<PaginationResult<AoPrimaryNameRequest>>;
+    }): Promise<PrimaryNameRequest>;
+    getPrimaryNameRequests(params?: PaginationParams<PrimaryNameRequest>): Promise<PaginationResult<PrimaryNameRequest>>;
     getPrimaryName(params: {
         address: WalletAddress;
     } | {
         name: string;
-    }): Promise<AoPrimaryName>;
-    getPrimaryNames(params?: PaginationParams<AoPrimaryName>): Promise<PaginationResult<AoPrimaryName>>;
+    }): Promise<PrimaryName>;
+    getPrimaryNames(params?: PaginationParams<PrimaryName>): Promise<PaginationResult<PrimaryName>>;
     getRedelegationFee(params: {
         address: WalletAddress;
-    }): Promise<AoRedelegationFeeInfo>;
-    getGatewayRegistrySettings(): Promise<AoGatewayRegistrySettings>;
-    getAllDelegates(params?: PaginationParams<AoAllDelegates>): Promise<PaginationResult<AoAllDelegates>>;
-    getAllGatewayVaults(params?: PaginationParams<AoAllGatewayVaults>): Promise<PaginationResult<AoAllGatewayVaults>>;
+    }): Promise<RedelegationFeeInfo>;
+    getGatewayRegistrySettings(): Promise<GatewayRegistrySettings>;
+    getAllDelegates(params?: PaginationParams<AllDelegates>): Promise<PaginationResult<AllDelegates>>;
+    getAllGatewayVaults(params?: PaginationParams<AllGatewayVaults>): Promise<PaginationResult<AllGatewayVaults>>;
+    getWithdrawals(params: PaginationParams<UserWithdrawal> & {
+        address: WalletAddress;
+    }): Promise<PaginationResult<UserWithdrawal>>;
 }
-export interface AoARIOWrite extends AoARIORead {
-    transfer: AoWriteAction<{
+export interface ARIOWrite extends ARIORead {
+    transfer: WriteAction<{
         target: WalletAddress;
         qty: number | mARIOToken;
     }>;
-    vaultedTransfer: AoWriteAction<AoVaultedTransferParams>;
-    revokeVault: AoWriteAction<AoRevokeVaultParams>;
-    createVault: AoWriteAction<AoCreateVaultParams>;
-    extendVault: AoWriteAction<AoExtendVaultParams>;
-    increaseVault: AoWriteAction<AoIncreaseVaultParams>;
-    joinNetwork: AoWriteAction<AoJoinNetworkParams>;
-    leaveNetwork: (options?: WriteOptions) => Promise<AoMessageResult>;
-    updateGatewaySettings: AoWriteAction<AoUpdateGatewaySettingsParams>;
-    increaseOperatorStake: AoWriteAction<{
+    vaultedTransfer: WriteAction<VaultedTransferParams>;
+    revokeVault: WriteAction<RevokeVaultParams>;
+    createVault: WriteAction<CreateVaultParams>;
+    extendVault: WriteAction<ExtendVaultParams>;
+    increaseVault: WriteAction<IncreaseVaultParams>;
+    joinNetwork: WriteAction<JoinNetworkParams>;
+    leaveNetwork: (options?: WriteOptions) => Promise<MessageResult>;
+    updateGatewaySettings: WriteAction<UpdateGatewaySettingsParams>;
+    increaseOperatorStake: WriteAction<{
         increaseQty: number | mARIOToken;
     }>;
-    decreaseOperatorStake: AoWriteAction<{
+    decreaseOperatorStake: WriteAction<{
         decreaseQty: number | mARIOToken;
         instant?: boolean;
     }>;
-    delegateStake: AoWriteAction<AoDelegateStakeParams>;
-    decreaseDelegateStake: AoWriteAction<{
+    delegateStake: WriteAction<DelegateStakeParams>;
+    decreaseDelegateStake: WriteAction<{
         target: WalletAddress;
         decreaseQty: number | mARIOToken;
         instant?: boolean;
     }>;
-    instantWithdrawal: AoWriteAction<{
+    instantWithdrawal: WriteAction<{
         gatewayAddress?: WalletAddress;
         vaultId: string;
     }>;
-    saveObservations: AoWriteAction<{
+    saveObservations: WriteAction<{
         reportTxId: TransactionId;
         failedGateways: WalletAddress[];
     }>;
-    buyRecord: AoWriteAction<AoBuyRecordParams, AoMessageResult, keyof BuyArNSNameProgressEvents, BuyArNSNameProgressEvents[keyof BuyArNSNameProgressEvents]>;
-    upgradeRecord: AoWriteAction<AoArNSPurchaseParams, AoMessageResult>;
-    extendLease: AoWriteAction<AoExtendLeaseParams, AoMessageResult>;
-    increaseUndernameLimit: AoWriteAction<AoIncreaseUndernameLimitParams, AoMessageResult>;
-    cancelWithdrawal: AoWriteAction<{
+    buyRecord: WriteAction<BuyRecordParams, MessageResult, keyof BuyArNSNameProgressEvents, BuyArNSNameProgressEvents[keyof BuyArNSNameProgressEvents]>;
+    upgradeRecord: WriteAction<ArNSPurchaseParams, MessageResult>;
+    extendLease: WriteAction<ExtendLeaseParams, MessageResult>;
+    increaseUndernameLimit: WriteAction<IncreaseUndernameLimitParams, MessageResult>;
+    cancelWithdrawal: WriteAction<{
         gatewayAddress?: WalletAddress;
         vaultId: string;
     }>;
-    requestPrimaryName(params: AoArNSPurchaseParams, options?: WriteOptions): Promise<AoMessageResult<AoCreatePrimaryNameRequest>>;
-    setPrimaryName: AoWriteAction<AoArNSPurchaseParams, AoMessageResult, keyof SetPrimaryNameProgressEvents, SetPrimaryNameProgressEvents[keyof SetPrimaryNameProgressEvents]>;
-    redelegateStake: AoWriteAction<AoRedelegateStakeParams>;
+    requestPrimaryName(params: ArNSPurchaseParams, options?: WriteOptions): Promise<MessageResult<CreatePrimaryNameRequest>>;
+    setPrimaryName: WriteAction<ArNSPurchaseParams, MessageResult, keyof SetPrimaryNameProgressEvents, SetPrimaryNameProgressEvents[keyof SetPrimaryNameProgressEvents]>;
+    redelegateStake: WriteAction<RedelegateStakeParams>;
+    /**
+     * Reconcile an ANT NFT's on-chain Attributes plugin (`ArNS Name`, `Type`,
+     * `Undername Limit`) with its current `ArnsRecord` state. Permissionless
+     * cache-sync — useful when a `buyRecord`/`reassignName` was performed on
+     * behalf of a different ANT holder, leaving traits unpopulated.
+     *
+     * Solana-only: throws on the AO backend (AO ANTs have no NFT trait surface).
+     */
+    syncAttributes: WriteAction<{
+        name: string;
+    }, MessageResult>;
 }
-export declare function isProcessConfiguration(config: object | undefined): config is Required<ProcessConfiguration> & Record<string, never>;
-export declare function isProcessIdConfiguration(config: object | undefined): config is Required<ProcessIdConfig> & Record<string, never>;
-export declare function isLeasedArNSRecord(record: AoArNSNameData): record is AoArNSLeaseData;
+export declare function isLeasedArNSRecord(record: ArNSNameData): record is ArNSLeaseData;
 export {};