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

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

@@ -0,0 +1,109 @@
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Cluster-specific deployment constants for AR.IO programs.
+ *
+ * The program-ID constants in `./constants.ts` (e.g. `ARIO_CORE_PROGRAM_ID`)
+ * are codama *placeholders* (`ARioCoreProgramXXX…`), not real on-chain
+ * addresses — consumers must pass real IDs via `ARIO.init({ programIds })`.
+ * This module exposes the deployed sets per cluster: `MAINNET_PROGRAM_IDS`
+ * and `DEVNET_PROGRAM_IDS`.
+ *
+ * Only root facts live here: program IDs, the RPC URL, and the ARIO mint.
+ * Everything else is derived rather than stored — config/settings PDAs come
+ * from the codama `find*Pda` helpers in `@ar.io/solana-contracts` (seeded by
+ * the program IDs below), and genesis-time token accounts (treasury / stake)
+ * are read on-chain from the ArioConfig / GarSettings accounts at runtime
+ * (see `io-writeable.ts` `getGarConfig`). Nothing to keep in sync, nothing to
+ * drift.
+ *
+ * Usage:
+ * ```ts
+ * import { ARIO } from '@ar.io/sdk';
+ * import { DEVNET_PROGRAM_IDS, DEVNET_RPC_URL } from '@ar.io/sdk/solana';
+ * import { createSolanaRpc, createSolanaRpcSubscriptions } from '@solana/kit';
+ *
+ * const rpc = createSolanaRpc(DEVNET_RPC_URL);
+ * const rpcSubscriptions = createSolanaRpcSubscriptions(
+ *   DEVNET_RPC_URL.replace(/^https/, 'wss'),
+ * );
+ * const ario = ARIO.init({
+ *   backend: 'solana',
+ *   rpc,
+ *   rpcSubscriptions,
+ *   programIds: DEVNET_PROGRAM_IDS,
+ * });
+ * ```
+ */
+import { type Address } from '@solana/kit';
+/**
+ * Default JSON-RPC URL for Solana mainnet-beta.
+ *
+ * The public endpoint rate-limits aggressively — for production use a premium
+ * RPC (QuickNode / Helius / Triton). Derive the WS URL with
+ * `MAINNET_RPC_URL.replace(/^https/, 'wss')`.
+ */
+export declare const MAINNET_RPC_URL = "https://api.mainnet-beta.solana.com";
+/**
+ * Default JSON-RPC URL for the Solana devnet cluster.
+ *
+ * Public devnet rate-limits aggressively — for high-volume work, swap in
+ * a premium RPC (QuickNode / Helius / Triton). Derive the WS URL with
+ * `DEVNET_RPC_URL.replace(/^https/, 'wss')`.
+ */
+export declare const DEVNET_RPC_URL = "https://api.devnet.solana.com";
+/**
+ * AR.IO program IDs deployed on Solana mainnet-beta.
+ *
+ * Shape matches the `programIds` argument of
+ * `ARIO.init({ backend: 'solana', programIds, ... })`.
+ */
+export declare const MAINNET_PROGRAM_IDS: {
+    readonly core: Address<"73YoECm6NKXpVRoe5f1Q9BcP5DJGPFUjnFy6AxBE5Nvh">;
+    readonly gar: Address<"89fNiiwgpFSPHKuqfNUkgYTYjtAJAhyqHjXmgXeppGpf">;
+    readonly arns: Address<"2yCUx5edFvUrkibYaUa2ZXWyx9kuJkS8CwyzsgHPWdZZ">;
+    readonly ant: Address<"2MWexMHfMhGJwMHv9Qm9YAVCqjUFUJwDJAysW4oCUGk5">;
+    readonly antEscrow: Address<"5HZhe9UqKL5zAsdz81nuuaxV41h8bFhudzxxBigAQndM">;
+};
+/**
+ * Mainnet attestor pubkey — the key that signs cross-protocol attestations
+ * (e.g. escrow recipient proofs). Deployment metadata; not consumed by the
+ * SDK, exposed here for reference/verification by downstream tooling.
+ */
+export declare const MAINNET_ATTESTOR_PUBKEY: Address;
+/**
+ * Mainnet upgrade/admin authority pubkey — holds the upgrade authority for
+ * the programs above. Deployment metadata; not consumed by the SDK, exposed
+ * here for reference.
+ */
+export declare const MAINNET_AUTHORITY_PUBKEY: Address;
+/** ARIO SPL Token mint on Solana mainnet-beta. */
+export declare const MAINNET_ARIO_MINT: Address;
+/**
+ * AR.IO program IDs deployed on Solana devnet (staging).
+ *
+ * Shape matches the `programIds` argument of
+ * `ARIO.init({ backend: 'solana', programIds, ... })`.
+ */
+export declare const DEVNET_PROGRAM_IDS: {
+    readonly core: Address<"8Njx9wPkXiNzDCgjwVsJFRjpAEV34gGW3n8DzX3V23m1">;
+    readonly gar: Address<"7WsDTrtZBsfKtnP33XkjuqXCY69JE7n4QVYpynqJCFxz">;
+    readonly arns: Address<"6EZNezcg4rc5hnh8HG34vGquT3WpW5xXypzPb24uyEpp">;
+    readonly ant: Address<"DbHbRwUD1oAn1mrDSqtWtvwGcNrmhWdD2g8L4xmeQ7NX">;
+    readonly antEscrow: Address<"bttco5oAnBwCucG63iKokBJCZmNr493f3Ewe9LM3oTx">;
+};
+/** ARIO SPL Token mint on devnet (Staging v2). */
+export declare const DEVNET_ARIO_MINT: Address;

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

@@ -0,0 +1,119 @@
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * 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 ARIO_TOKEN_MINT_ADDRESS: 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,45 @@
+/**
+ * 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;
+/**
+ * Select the delegations worth compounding, from decoded delegations + a map
+ * of their gateways' reward accumulators. Pure (no I/O) so it's unit-testable
+ * independently of RPC; `SolanaARIOReadable.getDelegationsToCompound` is just
+ * fetch+decode wrapped around this.
+ *
+ * A delegation is included when its pending reward (live balance − settled
+ * principal) exceeds `minPendingRewards`, EXCEPT when its gateway is `leaving`
+ * (those settle via `claim_delegate_from_leaving_gateway`, not compounding) or
+ * its gateway is missing/unreadable. Compounding sub-threshold dust only
+ * advances `reward_debt` for no balance gain, so it's filtered out.
+ */
+export declare function selectCompoundableDelegations(delegations: Array<{
+    gateway: string;
+    delegator: string;
+    delegatedStake: number;
+    rewardDebt: bigint;
+}>, gatewaysByOperator: Map<string, {
+    cumulativeRewardPerToken: bigint;
+    status: string;
+}>, minPendingRewards?: number): Array<{
+    gatewayAddress: string;
+    delegatorAddress: string;
+    pendingRewards: number;
+}>;

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

@@ -0,0 +1,262 @@
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Thin adapter layer over Codama-generated account decoders from
+ * `@ar.io/solana-contracts`. Each function accepts a raw `Buffer` (as
+ * returned by `fetchEncodedAccount(...).data`) and returns the same
+ * SDK-compatible plain-object shape the hand-rolled BorshReader
+ * implementations used to return.
+ *
+ * The Codama decoders return `Address` (branded string) and `bigint`
+ * for numeric fields. This module maps them to plain `string` and
+ * `number` so the SDK's public API contract doesn't change.
+ */
+import { type Address } from '@solana/kit';
+import type { ArNSNameData, Gateway, GatewayRegistrySettings, VaultData } 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;
+    readOptionU16(): 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;
+    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;
+    writeOptionStringVec(val: string[] | undefined): void;
+    toBuffer(): Buffer;
+    getOffset(): number;
+}
+export declare function deserializeGatewayWithAccumulator(data: Buffer): Gateway & {
+    operator: string;
+    cumulativeRewardPerToken: bigint;
+};
+export declare function deserializeGateway(data: Buffer): Gateway & {
+    operator: string;
+};
+export declare function deserializeArnsRecord(data: Buffer): ArNSNameData & {
+    name: string;
+    owner: string;
+};
+export declare function deserializeVault(data: Buffer): VaultData & {
+    owner: string;
+};
+export type DeserializedDelegation = {
+    gateway: string;
+    delegator: string;
+    delegatedStake: number;
+    startTimestamp: number;
+    rewardDebt: bigint;
+};
+export declare function deserializeDelegation(data: Buffer): DeserializedDelegation;
+export declare function deserializeBalance(data: Buffer): {
+    owner: string;
+    balance: number;
+};
+export declare function deserializeEpochSettings(data: Buffer): {
+    epochZeroStartTimestamp: number;
+    durationMs: number;
+    prescribedNameCount: number;
+    maxObservers: number;
+};
+export declare function deserializeArioConfig(data: Buffer): {
+    totalSupply: number;
+    protocolBalance: number;
+    circulatingSupply: number;
+    lockedSupply: number;
+};
+export declare function deserializeDemandFactor(data: Buffer): {
+    currentDemandFactor: number;
+    currentPeriod: number;
+    periodZeroStartTimestamp: number;
+    consecutivePeriodsWithMinDemandFactor: number;
+    trailingPeriodPurchases: number[];
+    trailingPeriodRevenues: number[];
+    fees: number[];
+};
+export declare function deserializeReservedName(data: Buffer): {
+    name: string;
+    target?: string;
+    endTimestamp?: number;
+};
+export declare function deserializeReturnedName(data: Buffer): {
+    name: string;
+    startTimestamp: number;
+    endTimestamp: number;
+    initiator: string;
+    premiumMultiplier: number;
+};
+export declare function deserializeWithdrawal(data: Buffer): {
+    owner: string;
+    vaultId: string;
+    gateway: string;
+    balance: number;
+    startTimestamp: number;
+    endTimestamp: number;
+    isDelegate: boolean;
+};
+export declare function deserializeRedelegationRecord(data: Buffer): {
+    delegator: string;
+    redelegationCount: number;
+    lastRedelegationAt: number;
+    feeResetAt: number;
+};
+export declare function deserializePrimaryNameRequest(data: Buffer): {
+    name: string;
+    initiator: string;
+    startTimestamp: number;
+    endTimestamp: number;
+};
+export declare function deserializeGarSettings(data: Buffer): GatewayRegistrySettings;
+export declare function deserializeGarSupplyCounters(data: Buffer): {
+    totalStaked: number;
+    totalDelegated: number;
+    totalWithdrawn: number;
+};
+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;
+};
+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;
+};
+export declare function deserializeObservation(data: Buffer): {
+    epochIndex: number;
+    observer: string;
+    gatewayResults: Buffer;
+    gatewayCount: number;
+    reportTxId: string;
+    submittedAt: number;
+};
+export declare function deserializeAntConfig(data: Buffer): {
+    mint: string;
+    name: string;
+    ticker: string;
+    logo: string;
+    description: string;
+    keywords: string[];
+    owner: string;
+    version: number;
+};
+export declare function deserializeAntControllers(data: Buffer): {
+    mint: string;
+    controllers: string[];
+};
+export declare function deserializeAntRecord(data: Buffer): {
+    mint: string;
+    undername: string;
+    transactionId: string;
+    targetProtocol: number;
+    ttlSeconds: number;
+    priority?: number;
+    owner?: string;
+};
+export declare function deserializeAntRecordMetadata(data: Buffer): {
+    mint: string;
+    displayName?: string;
+    logo?: string;
+    description?: string;
+    keywords?: string[];
+};
+export type DeserializedAclEntry = {
+    asset: string;
+    role: number;
+};
+export declare function deserializeAclConfig(data: Buffer): {
+    user: string;
+    pageCount: bigint;
+    totalEntries: bigint;
+};
+export declare function deserializeAclPage(data: Buffer): {
+    user: string;
+    pageIdx: bigint;
+    entries: DeserializedAclEntry[];
+};
+export declare function deserializePrimaryName(data: Buffer): {
+    owner: string;
+    name: string;
+    startTimestamp: number;
+};
+export declare function deserializeAllowlist(data: Buffer): {
+    gateway: string;
+    delegate: string;
+};
+export { BorshReader, BorshWriter };