upshift-sdk 8.20.1

package/lib/adapters/solana/index.d.ts

@@ -0,0 +1,233 @@
+/**
+ * Solana Adapter for August SDK
+ *
+ * @module SolanaAdapter
+ */
+import * as SolanaConstants from './constants';
+import * as SolanaGetters from './getters';
+import * as SolanaActions from './vault.actions';
+import type { AnchorProvider, web3 } from '@coral-xyz/anchor';
+import { Connection, PublicKey, type Transaction } from '@solana/web3.js';
+import type { ISolanaNetwork, ISolanaRpcEndpoint } from './types';
+import type { SendTransactionOptions } from '@solana/wallet-adapter-base';
+export declare const Solana: {
+    utils: {
+        getExplorerLink: ({ signature, type, network, }: {
+            signature: string;
+            type: "tx" | "address" | "token";
+        } & import("./types").ISolanaConnectionOptions) => string;
+        isSolanaAddress: typeof import("./utils").isSolanaAddress;
+        isSolana: (signature: string) => boolean;
+        getProgram: ({ provider, idl, programId, network, }: {
+            idl?: any;
+            programId?: string;
+        } & import("./types").ISolanaConnectionOptions) => import("@coral-xyz/anchor").Program<any>;
+        getProvider: ({ connection, publicKey, signTransaction, }: {
+            publicKey: PublicKey;
+            signTransaction: (<T extends Transaction | web3.VersionedTransaction>(transaction: T) => Promise<T>) | undefined;
+        } & import("./types").ISolanaConnectionOptions) => AnchorProvider;
+        getReadOnlyProvider: ({ connection }: import("./types").ISolanaConnectionOptions) => AnchorProvider;
+        deriveShareMintPda: (vaultProgramId: PublicKey | string) => web3.PublicKey;
+        deriveVaultStatePda: (vaultProgramId: PublicKey | string) => web3.PublicKey;
+        deriveVaultTokenAtaPda: (vaultProgramId: PublicKey | string, depositMint: PublicKey, vaultVersion?: number) => web3.PublicKey;
+        getVaultState: ({ provider, connection, vaultProgramId, vaultAddress, idl, }: {
+            vaultProgramId: PublicKey | string;
+            vaultAddress?: PublicKey | string;
+            idl: any;
+        } & import("./types").ISolanaConnectionOptions) => Promise<{
+            vaultState: unknown | null;
+            depositMintDecimals: number | null;
+        }>;
+        getVaultStateReadOnly: ({ vaultProgramId, vaultAddress, connection, idl, }: {
+            vaultProgramId: PublicKey | string;
+            vaultAddress?: PublicKey | string;
+            idl: any;
+        } & import("./types").ISolanaConnectionOptions) => Promise<{
+            vaultState: import("./types").ISolanaVaultState | null;
+            depositMintDecimals: number | null;
+        }>;
+        getToken: ({ mintAddress, endpoint, connection, }: {
+            mintAddress: string | PublicKey;
+        } & import("./types").ISolanaConnectionOptions) => Promise<{
+            address: string;
+            symbol: string;
+            decimals: number;
+            name: string;
+            image: string;
+        } | null>;
+        getTokenSymbol: ({ endpoint, mintAddress, }: {
+            mintAddress: string | PublicKey;
+        } & import("./types").ISolanaConnectionOptions) => Promise<string | null>;
+        fetchUserTokenBalance: ({ connection, publicKey, depositMint, }: {
+            publicKey: PublicKey | string;
+            depositMint?: PublicKey | string;
+        } & import("./types").ISolanaConnectionOptions) => Promise<any>;
+        fetchUserShareBalance: ({ connection, publicKey, shareMint, }: {
+            publicKey: PublicKey | string;
+            shareMint?: PublicKey | string;
+        } & import("./types").ISolanaConnectionOptions) => Promise<any>;
+        fetchUserShareBalanceRaw: ({ connection, publicKey, shareMint, }: {
+            publicKey: PublicKey | string;
+            shareMint?: PublicKey | string;
+        } & import("./types").ISolanaConnectionOptions) => Promise<{
+            amount: string;
+            decimals: number | null;
+        }>;
+        getBestRpcEndpoint: ({ endpoint, network, connection, }: import("./types").ISolanaConnectionOptions) => Promise<"http://127.0.0.1:8899" | `https://${string}`>;
+        fallbackDecimals: number;
+        fallbackNetwork: import("../..").ISolanaNetwork;
+        programIds: {
+            devnet: {
+                vault: string;
+            };
+            "mainnet-beta": {
+                vault: string;
+            };
+            localnet: {
+                vault: string;
+            };
+        };
+        getVaultMints: ({ vaultProgramId, vaultAddress, connection, idl, }: {
+            vaultProgramId: PublicKey | string;
+            vaultAddress?: PublicKey | string;
+            idl: any;
+        } & import("./types").ISolanaConnectionOptions) => Promise<{
+            depositMint: string;
+            shareMint: string;
+            vaultVersion: number | undefined;
+        }>;
+        resolveProgramId: (vaultAddress: string, solanaMetadata?: {
+            program_id?: string;
+        } | null) => string;
+    };
+    constants: typeof SolanaConstants;
+    actions: typeof SolanaActions;
+    getters: typeof SolanaGetters;
+};
+/**
+ * Solana Adapter for August SDK
+ *
+ * @example
+ * To access the Solana adapter instance
+ * ```
+ * const sdk = new AugustSDK()
+ * sdk.solana.getVaultState()
+ * ```
+ */
+declare class SolanaAdapter {
+    private _endpoint;
+    private _network;
+    private _connection;
+    private _provider;
+    constructor(endpoint: ISolanaRpcEndpoint, network?: ISolanaNetwork);
+    get endpoint(): `https://${string}`;
+    get network(): ISolanaNetwork;
+    get connection(): web3.Connection;
+    get provider(): AnchorProvider;
+    setWalletProvider(_publicKey: PublicKey | string, signTransaction: (<T extends Transaction | web3.VersionedTransaction>(transaction: T) => Promise<T>) | undefined): void;
+    /**
+     * Build an Anchor `Program` bound to this adapter's provider and network.
+     *
+     * The program id is resolved as: explicit `programId` → the `address` carried
+     * by a custom `programIdl` → the canonical deployment for this adapter's
+     * network. A copy of the SDK's bundled `vaultIdl` defers to the network
+     * default (its embedded `address` is a build stamp, not network-aware), so
+     * forwarding it on devnet never silently targets the mainnet program.
+     *
+     * @param programIdl - Anchor IDL to bind. Defaults to the SDK's bundled
+     *   `august_vault` IDL. A custom IDL's `address` is honoured when it differs
+     *   from the bundled build stamp.
+     * @param programId - Base58 program id that overrides both the IDL's address
+     *   and the network default. Use this to target a non-canonical deployment.
+     * @returns An Anchor `Program` for the resolved program id. No RPC is made —
+     *   construction is offline.
+     * @throws {@link AugustValidationError} if no program id can be resolved
+     *   because this adapter's network has no canonical deployment (e.g.
+     *   `testnet`) and neither `programId` nor a custom IDL address was supplied.
+     *
+     * @example
+     * ```ts
+     * // canonical program on the adapter's network
+     * const program = sdk.solana.getProgram();
+     *
+     * // a different deployment, same interface
+     * const legacy = sdk.solana.getProgram(vaultIdl, '7B8n9vL51b6ibqRAd1adZsi3x3kxtq5NZaondh22Vkyq');
+     * ```
+     */
+    getProgram(programIdl?: any, programId?: string): import("@coral-xyz/anchor").Program<any>;
+    getVaultState(vaultProgramId: PublicKey | string, idl: any, vaultAddress?: PublicKey | string): Promise<{
+        vaultState: unknown | null;
+        depositMintDecimals: number | null;
+    }>;
+    getVaultStateReadOnly(vaultProgramId: PublicKey | string, idl: any, vaultAddress?: PublicKey | string): Promise<{
+        vaultState: import("./types").ISolanaVaultState | null;
+        depositMintDecimals: number | null;
+    }>;
+    getToken(mintAddress: string | PublicKey): Promise<{
+        address: string;
+        symbol: string;
+        decimals: number;
+        name: string;
+        image: string;
+    }>;
+    getTokenSymbol(mintAddress: string | PublicKey): Promise<string>;
+    fetchUserTokenBalance(publicKey: PublicKey | string, depositMint: PublicKey | string): Promise<any>;
+    fetchUserShareBalance(publicKey: PublicKey | string, shareMint: PublicKey | string): Promise<any>;
+    /**
+     * BigInt-safe variant of {@link fetchUserShareBalance}. Returns the raw u64
+     * `amount` (as a base-units string) plus the mint's `decimals` (or `null`
+     * when the scale can't be determined — see Returns), so the caller can
+     * produce a correct `INormalizedNumber` without losing precision.
+     *
+     * Prefer this anywhere the result feeds BigInt math — positions, max-
+     * actions, redemption sizing, allowance checks. `fetchUserShareBalance`
+     * returns a JS-number `uiAmount` which silently encodes against 18 decimals
+     * when passed through `toNormalizedBn(value)` without an explicit decimals
+     * argument; that's exactly how the jitoSOL "missing position" regression
+     * manifested.
+     *
+     * RPC cost: 1 `getParsedTokenAccountsByOwner` call. Worst case ~150ms on a
+     * healthy mainnet endpoint.
+     *
+     * @param publicKey   Wallet owner (PublicKey or base58 string).
+     * @param shareMint   The vault's share-token mint (PublicKey or base58).
+     * @returns
+     *   `{ amount, decimals }`. Three observable shapes:
+     *   - `{ amount: '<u64>', decimals: <number> }` — token account exists.
+     *   - `{ amount: '0', decimals: null }` — no token account for this mint
+     *     under this wallet, OR `tokenAmount` was missing from the response,
+     *     OR `publicKey`/`shareMint` was not supplied. Distinguishable from a
+     *     genuine zero-balance account (`decimals` would be set there).
+     *   - `{ amount: '0', decimals: null }` — RPC threw (error is logged).
+     *
+     *   `decimals === null` means "we could not determine the scale" — callers
+     *   that need an `INormalizedNumber` must fall back to a known decimals
+     *   value (typically the deposit mint's decimals from backend metadata)
+     *   before normalizing. Never throws.
+     */
+    fetchUserShareBalanceRaw(publicKey: PublicKey | string, shareMint: PublicKey | string): Promise<{
+        amount: string;
+        decimals: number | null;
+    }>;
+    /**
+     * Deposit funds into a Solana August vault.
+     * @param depositAmount  `bigint` (raw on-chain units) or `number` (UI amount).
+     */
+    vaultDeposit(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, depositAmount: number | bigint, sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
+    /**
+     * Redeem vault shares from a Solana August vault.
+     * @param redeemShares  `bigint` (raw share units) or `number` (UI amount).
+     */
+    vaultRedeem(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, redeemShares: number | bigint, sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
+    /**
+     * Canonical program id for a program type on this adapter's network.
+     *
+     * @param type - Program to look up. Only `'vault'` (august_vault) exists today.
+     * @returns The base58 program id.
+     * @throws {@link AugustValidationError} if the canonical program is not
+     *   deployed on this adapter's network (e.g. `testnet`). Previously an
+     *   unmapped network threw a bare `TypeError`.
+     */
+    getProgramId(type: 'vault'): string;
+}
+export default SolanaAdapter;

package/lib/adapters/solana/index.js

@@ -0,0 +1,291 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Solana = void 0;
+/**
+ * Solana Adapter for August SDK
+ *
+ * @module SolanaAdapter
+ */
+const SolanaConstants = __importStar(require("./constants"));
+const SolanaGetters = __importStar(require("./getters"));
+const SolanaActions = __importStar(require("./vault.actions"));
+const web3_js_1 = require("@solana/web3.js");
+const utils_1 = require("./utils");
+const vault_actions_1 = require("./vault.actions");
+const constants_1 = require("./constants");
+const core_1 = require("../../core");
+exports.Solana = {
+    utils: utils_1.SolanaUtils,
+    constants: SolanaConstants,
+    actions: SolanaActions,
+    getters: SolanaGetters,
+};
+/**
+ * Solana Adapter for August SDK
+ *
+ * @example
+ * To access the Solana adapter instance
+ * ```
+ * const sdk = new AugustSDK()
+ * sdk.solana.getVaultState()
+ * ```
+ */
+class SolanaAdapter {
+    _endpoint;
+    _network;
+    _connection;
+    _provider;
+    constructor(endpoint, network = utils_1.SolanaUtils.fallbackNetwork) {
+        this._endpoint = endpoint;
+        this._network = network;
+        const connection = new web3_js_1.Connection(endpoint);
+        this._connection = connection;
+        this._provider = utils_1.SolanaUtils.getReadOnlyProvider({
+            network: this._network,
+            connection,
+        });
+    }
+    // Getters and setters for private properties
+    get endpoint() {
+        return this._endpoint;
+    }
+    get network() {
+        return this._network;
+    }
+    get connection() {
+        return this._connection;
+    }
+    get provider() {
+        return this._provider;
+    }
+    // Method to set connection with wallet for authenticated operations
+    setWalletProvider(_publicKey, signTransaction) {
+        if (_publicKey && signTransaction) {
+            const publicKey = typeof _publicKey === 'string' ? new web3_js_1.PublicKey(_publicKey) : _publicKey;
+            this._provider = utils_1.SolanaUtils.getProvider({
+                network: this._network,
+                connection: this._connection,
+                publicKey,
+                signTransaction,
+            });
+        }
+        else {
+            this._provider = utils_1.SolanaUtils.getReadOnlyProvider({
+                network: this._network,
+                connection: this._connection,
+            });
+        }
+    }
+    /**
+     * Build an Anchor `Program` bound to this adapter's provider and network.
+     *
+     * The program id is resolved as: explicit `programId` → the `address` carried
+     * by a custom `programIdl` → the canonical deployment for this adapter's
+     * network. A copy of the SDK's bundled `vaultIdl` defers to the network
+     * default (its embedded `address` is a build stamp, not network-aware), so
+     * forwarding it on devnet never silently targets the mainnet program.
+     *
+     * @param programIdl - Anchor IDL to bind. Defaults to the SDK's bundled
+     *   `august_vault` IDL. A custom IDL's `address` is honoured when it differs
+     *   from the bundled build stamp.
+     * @param programId - Base58 program id that overrides both the IDL's address
+     *   and the network default. Use this to target a non-canonical deployment.
+     * @returns An Anchor `Program` for the resolved program id. No RPC is made —
+     *   construction is offline.
+     * @throws {@link AugustValidationError} if no program id can be resolved
+     *   because this adapter's network has no canonical deployment (e.g.
+     *   `testnet`) and neither `programId` nor a custom IDL address was supplied.
+     *
+     * @example
+     * ```ts
+     * // canonical program on the adapter's network
+     * const program = sdk.solana.getProgram();
+     *
+     * // a different deployment, same interface
+     * const legacy = sdk.solana.getProgram(vaultIdl, '7B8n9vL51b6ibqRAd1adZsi3x3kxtq5NZaondh22Vkyq');
+     * ```
+     */
+    getProgram(programIdl, programId) {
+        return utils_1.SolanaUtils.getProgram({
+            network: this._network,
+            provider: this._provider,
+            idl: programIdl,
+            programId,
+        });
+    }
+    async getVaultState(vaultProgramId, idl, vaultAddress) {
+        return await utils_1.SolanaUtils.getVaultState({
+            network: this._network,
+            provider: this._provider,
+            connection: this._connection,
+            vaultProgramId,
+            vaultAddress,
+            idl,
+        });
+    }
+    async getVaultStateReadOnly(vaultProgramId, idl, vaultAddress) {
+        return await utils_1.SolanaUtils.getVaultStateReadOnly({
+            network: this._network,
+            connection: this._connection,
+            vaultProgramId,
+            vaultAddress,
+            idl,
+        });
+    }
+    async getToken(mintAddress) {
+        return await utils_1.SolanaUtils.getToken({
+            network: this._network,
+            mintAddress,
+            endpoint: this._endpoint,
+        });
+    }
+    async getTokenSymbol(mintAddress) {
+        return await utils_1.SolanaUtils.getTokenSymbol({
+            network: this._network,
+            mintAddress,
+            endpoint: this._endpoint,
+        });
+    }
+    async fetchUserTokenBalance(publicKey, depositMint) {
+        return await utils_1.SolanaUtils.fetchUserTokenBalance({
+            network: this._network,
+            connection: this._connection,
+            publicKey,
+            depositMint,
+        });
+    }
+    async fetchUserShareBalance(publicKey, shareMint) {
+        return await utils_1.SolanaUtils.fetchUserShareBalance({
+            network: this._network,
+            connection: this._connection,
+            publicKey,
+            shareMint,
+        });
+    }
+    /**
+     * BigInt-safe variant of {@link fetchUserShareBalance}. Returns the raw u64
+     * `amount` (as a base-units string) plus the mint's `decimals` (or `null`
+     * when the scale can't be determined — see Returns), so the caller can
+     * produce a correct `INormalizedNumber` without losing precision.
+     *
+     * Prefer this anywhere the result feeds BigInt math — positions, max-
+     * actions, redemption sizing, allowance checks. `fetchUserShareBalance`
+     * returns a JS-number `uiAmount` which silently encodes against 18 decimals
+     * when passed through `toNormalizedBn(value)` without an explicit decimals
+     * argument; that's exactly how the jitoSOL "missing position" regression
+     * manifested.
+     *
+     * RPC cost: 1 `getParsedTokenAccountsByOwner` call. Worst case ~150ms on a
+     * healthy mainnet endpoint.
+     *
+     * @param publicKey   Wallet owner (PublicKey or base58 string).
+     * @param shareMint   The vault's share-token mint (PublicKey or base58).
+     * @returns
+     *   `{ amount, decimals }`. Three observable shapes:
+     *   - `{ amount: '<u64>', decimals: <number> }` — token account exists.
+     *   - `{ amount: '0', decimals: null }` — no token account for this mint
+     *     under this wallet, OR `tokenAmount` was missing from the response,
+     *     OR `publicKey`/`shareMint` was not supplied. Distinguishable from a
+     *     genuine zero-balance account (`decimals` would be set there).
+     *   - `{ amount: '0', decimals: null }` — RPC threw (error is logged).
+     *
+     *   `decimals === null` means "we could not determine the scale" — callers
+     *   that need an `INormalizedNumber` must fall back to a known decimals
+     *   value (typically the deposit mint's decimals from backend metadata)
+     *   before normalizing. Never throws.
+     */
+    async fetchUserShareBalanceRaw(publicKey, shareMint) {
+        return await utils_1.SolanaUtils.fetchUserShareBalanceRaw({
+            network: this._network,
+            connection: this._connection,
+            publicKey,
+            shareMint,
+        });
+    }
+    /**
+     * Deposit funds into a Solana August vault.
+     * @param depositAmount  `bigint` (raw on-chain units) or `number` (UI amount).
+     */
+    async vaultDeposit(vaultProgramId, idl, publicKey, depositAmount, sendTransaction, vaultAddress) {
+        return await (0, vault_actions_1.handleSolanaDeposit)({
+            network: this._network,
+            provider: this._provider,
+            connection: this._connection,
+            vaultProgramId,
+            vaultAddress,
+            idl,
+            publicKey,
+            depositAmount,
+            sendTransaction,
+        });
+    }
+    /**
+     * Redeem vault shares from a Solana August vault.
+     * @param redeemShares  `bigint` (raw share units) or `number` (UI amount).
+     */
+    async vaultRedeem(vaultProgramId, idl, publicKey, redeemShares, sendTransaction, vaultAddress) {
+        return await (0, vault_actions_1.handleSolanaRedeem)({
+            network: this._network,
+            provider: this._provider,
+            connection: this._connection,
+            vaultProgramId,
+            vaultAddress,
+            idl,
+            publicKey,
+            redeemShares,
+            sendTransaction,
+        });
+    }
+    /**
+     * Canonical program id for a program type on this adapter's network.
+     *
+     * @param type - Program to look up. Only `'vault'` (august_vault) exists today.
+     * @returns The base58 program id.
+     * @throws {@link AugustValidationError} if the canonical program is not
+     *   deployed on this adapter's network (e.g. `testnet`). Previously an
+     *   unmapped network threw a bare `TypeError`.
+     */
+    getProgramId(type) {
+        const deployment = (0, constants_1.getDeployedProgramIds)(this._network);
+        if (!deployment) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `No canonical august_vault deployment for Solana network '${this._network}'. ` +
+                `Deployed networks: ${Object.keys(constants_1.programIds).join(', ')}.`);
+        }
+        return deployment[type];
+    }
+}
+exports.default = SolanaAdapter;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,67 @@
+import type { AnchorProvider } from '@coral-xyz/anchor';
+import type { Connection, PublicKey } from '@solana/web3.js';
+export type ISolanaRpcEndpoint = `https://${string}`;
+export type ISolanaNetwork = 'devnet' | 'mainnet-beta' | 'testnet' | 'localnet';
+export interface ISolanaConnectionOptions {
+    endpoint?: ISolanaRpcEndpoint;
+    connection?: Connection;
+    provider?: AnchorProvider;
+    network?: ISolanaNetwork;
+}
+export interface ISolanaVaultState {
+    operator: PublicKey | null;
+    admin: PublicKey | null;
+    shareMint: PublicKey | null;
+    depositMint: PublicKey | null;
+    feeRecipient: PublicKey | null;
+    withdrawalFee: number | null;
+    localAum: number | null;
+    deployedAum: number | null;
+    aumIncreaseLimit: number | null;
+    aumDecreaseLimit: number | null;
+    pdaBump: number[] | null;
+    vaultVersion: number[] | null;
+    paused: boolean | null;
+}
+export interface ISolanaToken {
+    address: string;
+    symbol: any;
+    decimals: number;
+    name: any;
+    image: any;
+    program: any;
+    mintAuthority: any;
+    freezeAuthority: any;
+    supply: string;
+    shareMintAddress: string;
+}
+export interface ISolanaVaultConfig {
+    programId: string;
+    vaultState: string;
+    shareMint: string;
+    vaultTokenAta: string;
+    depositMint: string;
+    network: ISolanaNetwork;
+}
+export interface ISolanaDepositResult {
+    success: boolean;
+    signature?: string;
+    sharesMinted?: number;
+    error?: string;
+}
+export interface ISolanaWithdrawResult {
+    success: boolean;
+    signature?: string;
+    tokensWithdrawn?: number;
+    error?: string;
+}
+export interface ISolanaVaultStats {
+    totalAssets: number;
+    totalShares: number;
+    isPaused: boolean;
+    withdrawalFee: number;
+    admin: string;
+    operator: string;
+    feeRecipient: string;
+    lastUpdated: Date;
+}

package/lib/adapters/solana/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map