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

package/lib/types/solana/constants.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Solana program IDs and PDA seed constants for AR.IO programs.
+ *
+ * These must match the seeds defined in the Anchor programs under
+ * contracts/programs/{ario-core,ario-gar,ario-arns,ario-ant}/src/.
+ */
+import { type Address } from '@solana/kit';
+export declare const ARIO_CORE_PROGRAM_ID: Address;
+export declare const ARIO_GAR_PROGRAM_ID: Address;
+export declare const ARIO_ARNS_PROGRAM_ID: Address;
+export declare const ARIO_ANT_PROGRAM_ID: Address;
+export declare const ARIO_ANT_ESCROW_PROGRAM_ID: Address;
+export declare const MPL_CORE_PROGRAM_ID: Address;
+export declare const TOKEN_DECIMALS = 6;
+export declare const ONE_TOKEN = 1000000;
+export declare const RATE_SCALE = 1000000;
+/**
+ * Scaling factor for the per-share reward accumulator
+ * `Gateway.cumulative_reward_per_token` in `ario-gar`. Must match the
+ * `REWARD_PRECISION` constant in `programs/ario-gar/src/state/mod.rs`.
+ */
+export declare const REWARD_PRECISION = 1000000000000000000n;
+export declare const ARIO_CONFIG_SEED: Buffer<ArrayBuffer>;
+export declare const VAULT_SEED: Buffer<ArrayBuffer>;
+export declare const VAULT_COUNTER_SEED: Buffer<ArrayBuffer>;
+export declare const BALANCE_SEED: Buffer<ArrayBuffer>;
+export declare const PRIMARY_NAME_SEED: Buffer<ArrayBuffer>;
+export declare const PRIMARY_NAME_REQUEST_SEED: Buffer<ArrayBuffer>;
+export declare const PRIMARY_NAME_REVERSE_SEED: Buffer<ArrayBuffer>;
+export declare const GATEWAY_REGISTRY_SEED: Buffer<ArrayBuffer>;
+export declare const GAR_SETTINGS_SEED: Buffer<ArrayBuffer>;
+export declare const GATEWAY_SEED: Buffer<ArrayBuffer>;
+export declare const DELEGATION_SEED: Buffer<ArrayBuffer>;
+export declare const WITHDRAWAL_SEED: Buffer<ArrayBuffer>;
+export declare const WITHDRAWAL_COUNTER_SEED: Buffer<ArrayBuffer>;
+export declare const ALLOWLIST_SEED: Buffer<ArrayBuffer>;
+export declare const EPOCH_SEED: Buffer<ArrayBuffer>;
+export declare const EPOCH_SETTINGS_SEED: Buffer<ArrayBuffer>;
+export declare const OBSERVATION_SEED: Buffer<ArrayBuffer>;
+export declare const REDELEGATION_SEED: Buffer<ArrayBuffer>;
+export declare const OBSERVER_LOOKUP_SEED: Buffer<ArrayBuffer>;
+export declare const ARNS_REGISTRY_SEED: Buffer<ArrayBuffer>;
+export declare const ARNS_SETTINGS_SEED: Buffer<ArrayBuffer>;
+export declare const ARNS_RECORD_SEED: Buffer<ArrayBuffer>;
+export declare const RESERVED_NAME_SEED: Buffer<ArrayBuffer>;
+export declare const RETURNED_NAME_SEED: Buffer<ArrayBuffer>;
+export declare const DEMAND_FACTOR_SEED: Buffer<ArrayBuffer>;
+/**
+ * Byte offsets of fixed-size fields within an `ArnsRecord` account.
+ *
+ * Used as `memcmp` filter offsets for `getProgramAccounts` so callers
+ * can resolve "which ArNS record points at this ANT mint?" as a true
+ * point query instead of scanning every record. Mirrors the
+ * `ArnsRecord::ANT_OFFSET` / `OWNER_OFFSET` constants in
+ * `contracts/programs/ario-arns/src/state/mod.rs` — keep them in
+ * sync if the on-chain layout ever changes.
+ */
+export declare const ARNS_RECORD_NAME_HASH_OFFSET = 8;
+export declare const ARNS_RECORD_OWNER_OFFSET: number;
+export declare const ARNS_RECORD_ANT_OFFSET: number;
+export declare const ANT_CONFIG_VERSION = 1;
+export declare const ANT_CONFIG_SEED: Buffer<ArrayBuffer>;
+export declare const ANT_CONTROLLERS_SEED: Buffer<ArrayBuffer>;
+export declare const ANT_RECORD_SEED: Buffer<ArrayBuffer>;
+export declare const ANT_RECORD_META_SEED: Buffer<ArrayBuffer>;
+export declare const ACL_CONFIG_SEED: Buffer<ArrayBuffer>;
+export declare const ACL_PAGE_SEED: Buffer<ArrayBuffer>;
+/**
+ * Maximum live entries per `AclPage` (must match the on-chain constant).
+ *
+ * Each entry is 33 bytes (`Pubkey + u8`). 256 entries = 8_448 bytes raw —
+ * fits the default 32 KiB BPF heap with margin and stays well under the
+ * 10 KiB per-tx realloc cap when allocated at full size.
+ */
+export declare const MAX_ACL_PAGE_ENTRIES = 256;
+/** ACL relationship roles (encoded as `u8` on each `AclEntry`). */
+export declare const ACL_ROLE_OWNER = 0;
+export declare const ACL_ROLE_CONTROLLER = 1;
+export declare const ESCROW_ANT_SEED: Buffer<ArrayBuffer>;
+export declare const ESCROW_TOKEN_SEED: Buffer<ArrayBuffer>;
+export declare const ESCROW_VAULT_SEED: Buffer<ArrayBuffer>;
+export declare const ESCROW_PROTOCOL_ARWEAVE = 0;
+export declare const ESCROW_PROTOCOL_ETHEREUM = 1;
+export declare const ESCROW_ARWEAVE_PUBKEY_LEN = 512;
+export declare const ESCROW_ETHEREUM_PUBKEY_LEN = 20;
+export declare const ESCROW_RECIPIENT_PUBKEY_MAX_LEN = 512;
+export declare const ESCROW_ASSET_TYPE_TOKEN = 1;
+export declare const ESCROW_ASSET_TYPE_VAULT = 2;
+export declare const PROTOCOL_ARWEAVE = 0;
+export declare const PROTOCOL_IPFS = 1;
+export declare const MAX_TARGET_LENGTH = 128;
+export declare const MAX_NAME_LENGTH = 51;
+export declare const MIN_TTL_SECONDS = 60;
+export declare const MAX_TTL_SECONDS = 86400;
+export declare const MAX_CONTROLLERS = 10;
+export declare const EPOCH_DURATION_SECONDS = 86400;
+export declare const WITHDRAWAL_LOCK_PERIOD: number;
+export declare const MIN_OPERATOR_STAKE: number;
+export declare const MIN_DELEGATION_AMOUNT: number;
+export declare const LEASE_GRACE_PERIOD: number;
+export declare const PRIMARY_NAME_REQUEST_EXPIRY: number;
+export declare const MAX_GATEWAYS = 3000;
+export declare const MAX_NAMES = 50000;

package/lib/types/solana/delegation-math.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Compute the live delegation balance: the last-settled principal plus any
+ * pending rewards accrued since the last settlement.
+ *
+ * Mirrors `settle_delegate_rewards` in
+ * `programs/ario-gar/src/state/mod.rs` — including the u128 overflow-safe
+ * quotient/remainder split and the saturating-to-`u64::MAX` cap at the end —
+ * so a value computed here matches what the on-chain instruction would write
+ * if it were called right now.
+ *
+ * @param delegatedStake          - `Delegation.amount` (u64 → number).
+ * @param rewardDebt              - `Delegation.reward_debt` (u128 → bigint).
+ * @param cumulativeRewardPerToken - `Gateway.cumulative_reward_per_token` (u128 → bigint).
+ * @returns The delegate's live balance in mARIO, saturating-capped at `u64::MAX`.
+ */
+export declare function computeLiveDelegationBalance({ delegatedStake, rewardDebt, cumulativeRewardPerToken, }: {
+    delegatedStake: number;
+    rewardDebt: bigint;
+    cumulativeRewardPerToken: bigint;
+}): number;

package/lib/types/solana/deserialize.d.ts

@@ -0,0 +1,440 @@
+/**
+ * Account deserialization for AR.IO Solana programs.
+ *
+ * Reads raw account data (Borsh-encoded by Anchor) and returns SDK-compatible
+ * types. Each function skips the 8-byte Anchor discriminator, then reads
+ * fields in the exact order defined in the Rust structs.
+ *
+ * NOTE on discriminators: this module no longer exports a hand-rolled
+ * discriminator table. The Codama-generated account modules under
+ * `./generated/<program>/accounts/` already export
+ * `<NAME>_DISCRIMINATOR: Uint8Array` constants pulled directly from each
+ * IDL, so they're guaranteed to match the on-chain struct names.
+ * Use those at the call site (see `io-readable.ts` for the
+ * `getAccountsByDiscriminator` helper that bs58-encodes them for
+ * `getProgramAccounts` memcmp filters).
+ *
+ * Borsh encoding rules (Anchor default):
+ *   - u8/bool: 1 byte
+ *   - u16: 2 bytes LE
+ *   - u32: 4 bytes LE
+ *   - u64: 8 bytes LE
+ *   - u128: 16 bytes LE
+ *   - i64: 8 bytes LE (signed)
+ *   - Pubkey: 32 bytes
+ *   - String: 4-byte LE length prefix + UTF-8 bytes
+ *   - Option<T>: 1-byte tag (0=None, 1=Some) + T if Some
+ *   - Vec<T>: 4-byte LE length + T[] elements
+ *   - Enum: 1-byte variant index
+ */
+import { type Address } from '@solana/kit';
+import type { AoArNSNameData, AoGateway, AoGatewayRegistrySettings, AoVaultData } from '../types/io.js';
+declare class BorshReader {
+    private data;
+    private offset;
+    constructor(data: Buffer, startOffset?: number);
+    readU8(): number;
+    readBool(): boolean;
+    readU16(): number;
+    readU32(): number;
+    readU64(): bigint;
+    readU64AsNumber(): number;
+    readI64(): bigint;
+    readI64AsNumber(): number;
+    readU128(): bigint;
+    readPubkey(): Address;
+    readString(): string;
+    readOptionI64(): number | undefined;
+    readOptionU32(): number | undefined;
+    skip(bytes: number): void;
+    getOffset(): number;
+    remaining(): number;
+    readOptionPubkey(): Address | undefined;
+    readOptionString(): string | undefined;
+    readVecString(): string[];
+    readOptionVecString(): string[] | undefined;
+    readVecPubkey(): Address[];
+    readFixedU64Array(count: number): number[];
+    readFixedBytes(count: number): Buffer;
+}
+declare class BorshWriter {
+    private buf;
+    private offset;
+    constructor(size: number);
+    writeU8(val: number): void;
+    writeBool(val: boolean): void;
+    writeU16(val: number): void;
+    writeU32(val: number): void;
+    writeU64(val: bigint | number): void;
+    writeI64(val: bigint | number): void;
+    writePubkey(key: Address): void;
+    /** Write raw bytes without a length prefix (fixed-size fields). */
+    writeFixedBytes(data: Buffer | Uint8Array): void;
+    writeString(str: string): void;
+    writeOptionI64(val: number | undefined): void;
+    writeOptionU32(val: number | undefined): void;
+    writeOptionPubkey(key: Address | undefined): void;
+    writeOptionString(val: string | undefined): void;
+    /** Borsh `Option<Vec<String>>`: 0/1 tag, then u32 length + each string. */
+    writeOptionStringVec(val: string[] | undefined): void;
+    toBuffer(): Buffer;
+    getOffset(): number;
+}
+/**
+ * Internal variant of {@link deserializeGateway} that additionally surfaces
+ * the on-chain `cumulative_reward_per_token` u128 accumulator. Used by the
+ * live delegation balance pipeline ({@link computeLiveDelegationBalance} via
+ * `getGatewayAccumulators` in `io-readable.ts`).
+ *
+ * Not part of the public AoGateway shape — `bigint` is not JSON-serializable
+ * and would leak through `getGateway` / `getGateways`. Prefer
+ * {@link deserializeGateway} everywhere except inside live-balance plumbing.
+ *
+ * PDA: ["gateway", operator_pubkey] in ario-gar program.
+ */
+export declare function deserializeGatewayWithAccumulator(data: Buffer): AoGateway & {
+    operator: string;
+    cumulativeRewardPerToken: bigint;
+};
+/**
+ * Deserialize a Gateway account from raw bytes.
+ *
+ * Returns the SDK-compatible AoGateway type (plus `operator: string`).
+ * The on-chain `cumulative_reward_per_token` u128 is intentionally NOT
+ * surfaced on the returned object — `bigint` is not JSON-serializable,
+ * and leaking it through `getGateway` / `getGateways` would break
+ * downstream consumers that call `JSON.stringify` on results. Use
+ * {@link deserializeGatewayWithAccumulator} from within the live-balance
+ * pipeline when the accumulator value is actually needed.
+ */
+export declare function deserializeGateway(data: Buffer): AoGateway & {
+    operator: string;
+};
+/**
+ * Deserialize an ArNS record account from raw bytes.
+ * PDA: ["arns_record", hash(name)] in ario-arns program.
+ *
+ * Field order is **load-bearing** and mirrors the on-chain
+ * `ArnsRecord` struct in `contracts/programs/ario-arns/src/state/mod.rs`.
+ * Every fixed-size field appears before the variable-length `name` so
+ * `getProgramAccounts` callers can `memcmp`-filter on `ant` (offset
+ * 72) — see `ARNS_RECORD_ANT_OFFSET` in `./constants.ts`. If you
+ * touch the contract layout, both files have to move in lockstep.
+ */
+export declare function deserializeArnsRecord(data: Buffer): AoArNSNameData & {
+    name: string;
+    owner: string;
+};
+/**
+ * Deserialize a Vault account from raw bytes.
+ * PDA: ["vault", owner, vault_id] in ario-core program.
+ *
+ * On-chain layout (matches `state::Vault`):
+ *   disc(8) + owner(Pubkey=32) + vault_id(u64=8) + amount(u64=8)
+ *   + start_timestamp(i64=8) + end_timestamp(i64=8)
+ *   + controller(Option<Pubkey>=33) + revocable(bool=1) + bump(u8=1)
+ */
+export declare function deserializeVault(data: Buffer): AoVaultData & {
+    owner: string;
+};
+export type DeserializedDelegation = {
+    gateway: string;
+    delegator: string;
+    /**
+     * Last-settled principal (raw `Delegation.amount` from on-chain state).
+     * This value is stale between epochs — see `INVARIANTS.md` in the contracts
+     * repo. Use `computeLiveDelegationBalance` (with the gateway's current
+     * `cumulativeRewardPerToken`) to get the actual current balance.
+     */
+    delegatedStake: number;
+    startTimestamp: number;
+    /**
+     * Snapshot of `gateway.cumulative_reward_per_token` at the last settlement.
+     * Required input to `computeLiveDelegationBalance`.
+     */
+    rewardDebt: bigint;
+};
+/**
+ * Deserialize a Delegation account from raw bytes.
+ * PDA: ["delegation", gateway, delegator] in ario-gar program.
+ */
+export declare function deserializeDelegation(data: Buffer): DeserializedDelegation;
+/**
+ * Deserialize a Balance account from raw bytes.
+ * PDA: ["balance", owner] in ario-core program.
+ *
+ * Backed by the Codama-generated decoder so the encoder
+ * (`getBalanceEncoder` used by migration/snapshot) and decoder share a single
+ * source of truth derived from the `ario_core` IDL.
+ */
+export declare function deserializeBalance(data: Buffer): {
+    owner: string;
+    balance: number;
+};
+export declare function deserializeEpochSettings(data: Buffer): {
+    epochZeroStartTimestamp: number;
+    durationMs: number;
+    prescribedNameCount: number;
+    maxObservers: number;
+};
+/**
+ * Deserialize an ArioConfig account from raw bytes.
+ * PDA: ["ario_config"] in ario-core program.
+ */
+export declare function deserializeArioConfig(data: Buffer): {
+    totalSupply: number;
+    protocolBalance: number;
+    circulatingSupply: number;
+    lockedSupply: number;
+};
+/**
+ * Deserialize a DemandFactor account from raw bytes.
+ * PDA: ["demand_factor"] in ario-arns program.
+ */
+export declare function deserializeDemandFactor(data: Buffer): {
+    currentDemandFactor: number;
+    currentPeriod: number;
+    periodZeroStartTimestamp: number;
+    consecutivePeriodsWithMinDemandFactor: number;
+    trailingPeriodPurchases: number[];
+    trailingPeriodRevenues: number[];
+    fees: number[];
+};
+/**
+ * Deserialize a ReservedName account from raw bytes.
+ * PDA: ["reserved_name", hash(name)] in ario-arns program.
+ */
+export declare function deserializeReservedName(data: Buffer): {
+    name: string;
+    target?: string;
+    endTimestamp?: number;
+};
+/**
+ * Deserialize a ReturnedName account from raw bytes.
+ * PDA: ["returned_name", hash(name)] in ario-arns program.
+ */
+export declare function deserializeReturnedName(data: Buffer): {
+    name: string;
+    startTimestamp: number;
+    endTimestamp: number;
+    initiator: string;
+    premiumMultiplier: number;
+};
+/**
+ * Deserialize a Withdrawal account from raw bytes.
+ * PDA: ["withdrawal", gateway, owner, withdrawal_id] in ario-gar program.
+ */
+export declare function deserializeWithdrawal(data: Buffer): {
+    owner: string;
+    vaultId: string;
+    gateway: string;
+    balance: number;
+    startTimestamp: number;
+    endTimestamp: number;
+    isDelegate: boolean;
+};
+/**
+ * Deserialize a RedelegationRecord account from raw bytes.
+ * PDA: ["redelegation", delegator] in ario-gar program.
+ */
+export declare function deserializeRedelegationRecord(data: Buffer): {
+    delegator: string;
+    redelegationCount: number;
+    lastRedelegationAt: number;
+    feeResetAt: number;
+};
+/**
+ * Deserialize a PrimaryNameRequest account from raw bytes.
+ * PDA: ["primary_name_request", initiator] in ario-core program.
+ */
+export declare function deserializePrimaryNameRequest(data: Buffer): {
+    name: string;
+    initiator: string;
+    startTimestamp: number;
+    endTimestamp: number;
+};
+/**
+ * Deserialize a GarSettings account from raw bytes and return
+ * the full AoGatewayRegistrySettings type.
+ * PDA: ["gar_settings"] in ario-gar program.
+ *
+ * Fields not stored in GarSettings are filled with protocol defaults.
+ */
+export declare function deserializeGarSettings(data: Buffer): AoGatewayRegistrySettings;
+/**
+ * Deserialize supply counter fields from GatewaySettings account.
+ * These 3 fields were added after arns_program_id, before bump.
+ */
+export declare function deserializeGarSupplyCounters(data: Buffer): {
+    totalStaked: number;
+    totalDelegated: number;
+    totalWithdrawn: number;
+};
+/**
+ * Deserialize the full EpochSettings account from raw bytes.
+ * Unlike deserializeEpochSettings (which returns 4 fields), this reads
+ * all fields from the on-chain struct.
+ * PDA: ["epoch_settings"] in ario-gar program.
+ */
+export declare function deserializeEpochSettingsFull(data: Buffer): {
+    currentEpochIndex: number;
+    genesisTimestamp: number;
+    epochDuration: number;
+    enabled: boolean;
+    prescribedObserverCount: number;
+    prescribedNameCount: number;
+    tenureWeightDuration: number;
+    maxTenureWeight: number;
+    gatewayRewardRatio: number;
+    observerRewardRatio: number;
+    maxConsecutiveFailures: number;
+};
+/**
+ * Deserialize an Epoch account from raw bytes.
+ * PDA: ["epoch", epoch_index_le_bytes] in ario-gar program.
+ *
+ * This is a zero-copy account with #[repr(C)] layout (not Borsh).
+ * Fields are at fixed offsets after the 8-byte discriminator.
+ */
+export declare function deserializeEpoch(data: Buffer): {
+    epochIndex: number;
+    startTimestamp: number;
+    endTimestamp: number;
+    totalEligibleRewards: number;
+    perGatewayReward: number;
+    perObserverReward: number;
+    rewardRate: number;
+    activeGatewayCount: number;
+    distributionIndex: number;
+    tallyIndex: number;
+    observerCount: number;
+    nameCount: number;
+    observationsSubmitted: number;
+    rewardsDistributed: number;
+    weightsTallied: number;
+    prescriptionsDone: number;
+    failureCounts: Uint16Array;
+    prescribedObservers: Address[];
+    prescribedObserverGateways: Address[];
+    prescribedNameHashes: Buffer[];
+    hasObserved: Uint8Array;
+};
+/**
+ * Deserialize an Observation account from raw bytes.
+ * PDA: ["observation", epoch_index_le_bytes, observer_pubkey] in ario-gar program.
+ */
+export declare function deserializeObservation(data: Buffer): {
+    epochIndex: number;
+    observer: string;
+    gatewayResults: Buffer;
+    gatewayCount: number;
+    reportTxId: string;
+    submittedAt: number;
+};
+/**
+ * Deserialize an AntConfig account from raw bytes.
+ * PDA: ["ant_config", mint] in ario-ant program.
+ */
+export declare function deserializeAntConfig(data: Buffer): {
+    mint: string;
+    name: string;
+    ticker: string;
+    logo: string;
+    description: string;
+    keywords: string[];
+    owner: string;
+    version: number;
+};
+/**
+ * Deserialize an AntControllers account from raw bytes.
+ * PDA: ["ant_controllers", mint] in ario-ant program.
+ */
+export declare function deserializeAntControllers(data: Buffer): {
+    mint: string;
+    controllers: string[];
+};
+/**
+ * Deserialize an AntRecord account from raw bytes.
+ * PDA: ["ant_record", mint, hash(undername)] in ario-ant program.
+ */
+export declare function deserializeAntRecord(data: Buffer): {
+    mint: string;
+    undername: string;
+    transactionId: string;
+    targetProtocol: number;
+    ttlSeconds: number;
+    priority?: number;
+    owner?: string;
+};
+/**
+ * Deserialize an AntRecordMetadata account from raw bytes.
+ * This is a separate PDA that holds optional per-record metadata fields.
+ */
+export declare function deserializeAntRecordMetadata(data: Buffer): {
+    mint: string;
+    displayName?: string;
+    logo?: string;
+    description?: string;
+    keywords?: string[];
+};
+/**
+ * Per-user ACL entry: a `(asset, role)` tuple where `role` is `0=Owner`,
+ * `1=Controller` (see `AclRole` in ario-ant). The byte layout matches the
+ * on-chain `AclEntry` (33 bytes).
+ */
+export type DeserializedAclEntry = {
+    asset: string;
+    role: number;
+};
+/**
+ * Deserialize an `AclConfig` account (paginated ACL head — ADR-012).
+ * PDA: `["acl_config", user]` in ario-ant program.
+ *
+ * Holds counts but no entries. Read this first, then fan out to each
+ * `AclPage` PDA (`["acl_page", user, page_idx_le]`) for the entries.
+ */
+export declare function deserializeAclConfig(data: Buffer): {
+    user: string;
+    pageCount: bigint;
+    totalEntries: bigint;
+};
+/**
+ * Deserialize an `AclPage` account (paginated ACL page — ADR-012).
+ * PDA: `["acl_page", user, page_idx_le]` in ario-ant program.
+ *
+ * Stores up to `MAX_ACL_PAGE_ENTRIES` `(asset, role)` entries. Pages can
+ * be sparse mid-life (entries are removed via `swap_remove`) — the SDK's
+ * append path fills the first non-full page to keep density reasonable.
+ */
+export declare function deserializeAclPage(data: Buffer): {
+    user: string;
+    pageIdx: bigint;
+    entries: DeserializedAclEntry[];
+};
+/**
+ * Deserialize a PrimaryName account from raw bytes.
+ * PDA: ["primary_name", owner] in ario-core program.
+ *
+ * The on-chain `PrimaryName` (programs/ario-core/src/state/mod.rs) has
+ * **no** `processId` field — only `{owner, name, set_at, bump}`. The ANT
+ * mint that a primary name resolves to lives on the matching `ArnsRecord`
+ * (looked up by `name`), and callers wanting an `AoPrimaryName`-shaped
+ * result MUST enrich this output with that lookup. The previous
+ * implementation read 32 bytes from where `set_at` (i64) + part of `bump`
+ * actually sit and returned a fake `processId` pubkey, which broke every
+ * `assert.equal(pn.processId, antMint)` check downstream.
+ */
+export declare function deserializePrimaryName(data: Buffer): {
+    owner: string;
+    name: string;
+    startTimestamp: number;
+};
+/**
+ * Deserialize an Allowlist entry account from raw bytes.
+ * PDA: ["allowlist", gateway, delegate] in ario-gar program.
+ */
+export declare function deserializeAllowlist(data: Buffer): {
+    gateway: string;
+    delegate: string;
+};
+export { BorshReader, BorshWriter };