> For the complete documentation index, see [llms.txt](https://docs.augustdigital.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.augustdigital.io/developers/typescript-sdk/api/solanaadapter.md). # SolanaAdapter [SDK Reference](/developers/typescript-sdk/api.md) / SolanaAdapter ## SolanaAdapter Solana Adapter for August SDK ### Classes #### default Solana Adapter for August SDK **Example** To access the Solana adapter instance ``` const sdk = new AugustSDK() sdk.solana.getVaultState() ``` **Constructors** **Constructor** > **new default**(`endpoint`, `network?`, `commitment?`): [`default`](#default) **Parameters** | Parameter | Type | Default value | Description | | ------------ | ------------------------- | ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `endpoint` | `` `https://${string}` `` | `undefined` | - | | `network` | `ISolanaNetwork` | `SolanaUtils.fallbackNetwork` | - | | `commitment` | `Commitment` | `'finalized'` | Commitment for every read this adapter makes *and* for the confirmation of every write, so the two always describe the same chain state — the vault handlers take it from this same `Connection`. Defaults to `'finalized'`, which is what this adapter has always used in practice: it previously passed no commitment at all, so both reads and confirmations fell through to the RPC's own `'finalized'` default. The default is stated explicitly now rather than inherited, but it is unchanged. Pass `'confirmed'` for a markedly faster round trip — seconds rather than tens of seconds — accepting that the state you act on can still, in principle, be rolled back. Also settable as the `commitment` field of the `solana` config passed to `AugustSDK`. | **Returns** [`default`](#default) **Accessors** **connection** **Get Signature** > **get** **connection**(): `Connection` **Returns** `Connection` **endpoint** **Get Signature** > **get** **endpoint**(): `` `https://${string}` `` **Returns** `` `https://${string}` `` **network** **Get Signature** > **get** **network**(): `ISolanaNetwork` **Returns** `ISolanaNetwork` **provider** **Get Signature** > **get** **provider**(): `AnchorProvider` **Returns** `AnchorProvider` **Methods** **fetchUserShareBalance()** > **fetchUserShareBalance**(`publicKey`, `shareMint`): `Promise`<`number`> **Parameters** | Parameter | Type | | ----------- | ----------------------- | | `publicKey` | `string` \| `PublicKey` | | `shareMint` | `string` \| `PublicKey` | **Returns** `Promise`<`number`> **fetchUserShareBalanceRaw()** > **fetchUserShareBalanceRaw**(`publicKey`, `shareMint`): `Promise`<{ `amount`: `string`; `decimals`: `number`; }> BigInt-safe variant of [fetchUserShareBalance](#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. **Parameters** | Parameter | Type | Description | | ----------- | ----------------------- | --------------------------------------------------- | | `publicKey` | `string` \| `PublicKey` | Wallet owner (PublicKey or base58 string). | | `shareMint` | `string` \| `PublicKey` | The vault's share-token mint (PublicKey or base58). | **Returns** `Promise`<{ `amount`: `string`; `decimals`: `number`; }> `{ amount, decimals }`. Three observable shapes: * `{ amount: '', decimals: }` — 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. **fetchUserTokenBalance()** > **fetchUserTokenBalance**(`publicKey`, `depositMint`): `Promise`<`string`> **Parameters** | Parameter | Type | | ------------- | ----------------------- | | `publicKey` | `string` \| `PublicKey` | | `depositMint` | `string` \| `PublicKey` | **Returns** `Promise`<`string`> **getProgram()** > **getProgram**(`programIdl?`, `programId?`): `Program`<`any`> 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. **Parameters** | Parameter | Type | Description | | ------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- | | `programIdl?` | `any` | 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. | | `programId?` | `string` | Base58 program id that overrides both the IDL's address and the network default. Use this to target a non-canonical deployment. | **Returns** `Program`<`any`> An Anchor `Program` for the resolved program id. No RPC is made — construction is offline. **Throws** 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'); ``` **getProgramId()** > **getProgramId**(`type`): `string` Canonical program id for a program type on this adapter's network. **Parameters** | Parameter | Type | Description | | --------- | -------------------------------- | ------------------------------------------------------------------------------------------------- | | `type` | `"vault"` \| `"withdrawalQueue"` | Program to look up: `'vault'` (august\_vault) or `'withdrawalQueue'` (august\_withdrawal\_queue). | **Returns** `string` The base58 program id. **Throws** AugustValidationError if `type` is not one of the two program types, or the program is not deployed on this adapter's network (neither program on `testnet`). **Example** ```ts const queueProgram = adapter.getProgramId('withdrawalQueue'); ``` **getToken()** > **getToken**(`mintAddress`): `Promise`<{ `address`: `string`; `decimals`: `number`; `image`: `string`; `name`: `string`; `symbol`: `string`; }> **Parameters** | Parameter | Type | | ------------- | ----------------------- | | `mintAddress` | `string` \| `PublicKey` | **Returns** `Promise`<{ `address`: `string`; `decimals`: `number`; `image`: `string`; `name`: `string`; `symbol`: `string`; }> **getTokenSymbol()** > **getTokenSymbol**(`mintAddress`): `Promise`<`string`> **Parameters** | Parameter | Type | | ------------- | ----------------------- | | `mintAddress` | `string` \| `PublicKey` | **Returns** `Promise`<`string`> **getVaultState()** > **getVaultState**(`vaultProgramId`, `idl`, `vaultAddress?`): `Promise`<{ `depositMintDecimals`: `number`; `vaultState`: `unknown`; }> **Parameters** | Parameter | Type | | ---------------- | ----------------------- | | `vaultProgramId` | `string` \| `PublicKey` | | `idl` | `any` | | `vaultAddress?` | `string` \| `PublicKey` | **Returns** `Promise`<{ `depositMintDecimals`: `number`; `vaultState`: `unknown`; }> **getVaultStateReadOnly()** > **getVaultStateReadOnly**(`vaultProgramId`, `idl`, `vaultAddress?`): `Promise`<{ `depositMintDecimals`: `number`; `vaultState`: `ISolanaVaultState`; }> **Parameters** | Parameter | Type | | ---------------- | ----------------------- | | `vaultProgramId` | `string` \| `PublicKey` | | `idl` | `any` | | `vaultAddress?` | `string` \| `PublicKey` | **Returns** `Promise`<{ `depositMintDecimals`: `number`; `vaultState`: `ISolanaVaultState`; }> **setWalletProvider()** > **setWalletProvider**(`_publicKey`, `signTransaction`): `void` **Parameters** | Parameter | Type | | ----------------- | -------------------------------------- | | `_publicKey` | `string` \| `PublicKey` | | `signTransaction` | <`T`>(`transaction`) => `Promise`<`T`> | **Returns** `void` **vaultCancelRedeemRequest()** > **vaultCancelRedeemRequest**(`params`): `Promise`<`string`> Cancel a pending withdrawal request, returning its shares to the holder. Allowed at any time while the request exists: during the cooldown, after it, past the fulfillment window, and while the vault is paused. Only the holder who made the request may cancel it. Signs through the provider's wallet; the request's rent is refunded to the holder. RPC: three reads, then the send. **Parameters** | Parameter | Type | Description | | --------- | ----------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | | `params` | [`ISolanaCancelRedeemRequestParams`](#isolanacancelredeemrequestparams) | The holder and the request address. See [ISolanaCancelRedeemRequestParams](#isolanacancelredeemrequestparams). | **Returns** `Promise`<`string`> The confirmed transaction's signature. **Throws** AugustValidationError for a missing request, or one this wallet did not make, before signing. **Throws** AugustSDKError when the transaction fails. **Example** ```ts await sdk.solana.vaultCancelRedeemRequest({ wallet: wallet.publicKey, request }); ``` **vaultDeposit()** > **vaultDeposit**(`vaultProgramId`, `idl`, `publicKey`, `depositAmount`, `sendTransaction?`, `vaultAddress?`, `options?`): `Promise`<`any`> Deposit funds into a Solana August vault. **Parameters** | Parameter | Type | Description | | ------------------ | ---------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `vaultProgramId` | `string` \| `PublicKey` | - | | `idl` | `any` | - | | `publicKey` | `string` \| `PublicKey` | - | | `depositAmount` | `number` \| `bigint` | `bigint` (raw on-chain units) or `number` (UI amount). | | `sendTransaction?` | (`transaction`, `connection`, `options?`) => `Promise`<`string`> | **Ignored; scheduled for removal in the next major release.** Share-account creation is now prepended to the deposit instruction, so the SDK sends no second transaction and never invokes this callback — signing goes through the provider's wallet. **Pass `undefined` here; do not delete the argument.** It sits *before* `vaultAddress`, so removing it shifts your vault address into this slot and leaves `vaultAddress` undefined — which silently falls back to the legacy single-vault PDA derivation and targets a different vault. | | `vaultAddress?` | `string` \| `PublicKey` | - | | `options?` | [`ISolanaDepositOptions`](#isolanadepositoptions) | Slippage protection. By default the SDK quotes the shares this deposit should mint from the vault's current state and passes that quote, lowered by 50 bps, as the floor to the program's checked instruction. See [ISolanaDepositOptions](#isolanadepositoptions). | **Returns** `Promise`<`any`> **vaultRedeem()** > **vaultRedeem**(`vaultProgramId`, `idl`, `publicKey`, `redeemShares`, `sendTransaction?`, `vaultAddress?`, `options?`): `Promise`<`any`> Redeem vault shares from a Solana August vault. **Parameters** | Parameter | Type | Description | | ------------------ | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `vaultProgramId` | `string` \| `PublicKey` | - | | `idl` | `any` | - | | `publicKey` | `string` \| `PublicKey` | - | | `redeemShares` | `number` \| `bigint` | `bigint` (raw share units) or `number` (UI amount). | | `sendTransaction?` | (`transaction`, `connection`, `options?`) => `Promise`<`string`> | **Ignored; scheduled for removal in the next major release.** Payout- and fee-recipient-account creation is now prepended to the redeem instruction, so the SDK sends no second transaction and never invokes this callback — signing goes through the provider's wallet. **Pass `undefined` here; do not delete the argument.** It sits *before* `vaultAddress`, so removing it shifts your vault address into this slot and leaves `vaultAddress` undefined — which silently falls back to the legacy single-vault PDA derivation and targets a different vault. | | `vaultAddress?` | `string` \| `PublicKey` | - | | `options?` | [`ISolanaRedeemOptions`](#isolanaredeemoptions) | Slippage protection. By default the SDK quotes the net payout these shares should return from the vault's current state and passes that quote, lowered by 50 bps, as the floor to the program's checked instruction. See [ISolanaRedeemOptions](#isolanaredeemoptions). **On a vault with a withdrawal queue**, holders cannot redeem directly: request with [SolanaAdapter.vaultRequestRedeem](#vaultrequestredeem), then claim here with `options.request` once the cooldown has run. The claim settles at the share price of that moment, net of the withdrawal fee, held to the floor set at request time, and pays the request's recipient; `redeemShares` and `vaultAddress` are then ignored, and `slippageBps` / `minAssetsOut` must be left unset. Without `request`, a queued vault is refused before signing. | **Returns** `Promise`<`any`> The confirmed transaction's signature. **Throws** AugustValidationError for bad input, for a queued vault without `options.request`, or for a request the wallet cannot claim yet. **Example** ```ts // A vault with a withdrawal queue: claim a ready request. const { pendingRedemptions } = await sdk.getVaultAvailableRedemptions({ vault, wallet }); await sdk.solana.vaultRedeem(programId, vaultIdl, wallet, 0n, undefined, undefined, { request: pendingRedemptions[0].id, }); ``` **vaultRequestRedeem()** > **vaultRequestRedeem**(`params`): `Promise`<[`ISolanaRequestRedeemResult`](#isolanarequestredeemresult)> Request a withdrawal from a Solana vault that has a withdrawal queue. With a queue attached, a vault's shares cannot be redeemed directly: the holder escrows them in a request, waits out the queue's cooldown, then claims with [SolanaAdapter.vaultRedeem](#vaultredeem) and `options.request`, or anyone the request permits (a keeper, by default) claims for them. The payout is priced when the request is claimed, not now, but never below the floor set here: by default the current net quote lowered by 50 bps, so a fee rise or mark-down in between makes the claim fail rather than pay less. A pending request can be cancelled at any time with [SolanaAdapter.vaultCancelRedeemRequest](#vaultcancelredeemrequest), which returns the shares. Signs through the provider's wallet and submits one transaction, which also creates the recipient's deposit-token account when it has none. The holder pays the request account's rent, refunded when it is claimed or cancelled, plus rent for any account created. Use `getVaultAvailableRedemptions` to list requests and see when they can be claimed. RPC: three to four reads, then the send. **Parameters** | Parameter | Type | Description | | --------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | `params` | [`ISolanaRequestRedeemParams`](#isolanarequestredeemparams) | Vault, wallet, shares, and optional recipient, finalizer, request id and floor. See [ISolanaRequestRedeemParams](#isolanarequestredeemparams). | **Returns** `Promise`<[`ISolanaRequestRedeemResult`](#isolanarequestredeemresult)> The signature, the request's address (pass it as `request` to claim or cancel) and its id. **Throws** AugustValidationError for bad input, a vault without an attached queue, a frozen account or too few shares, before signing. **Throws** AugustSDKError when the transaction fails. **Example** ```ts const { request } = await sdk.solana.vaultRequestRedeem({ vault: vaultStateAddress, wallet: wallet.publicKey, amount: 10, // shares, UI units }); // ...once the cooldown has run: await sdk.solana.vaultRedeem(programId, vaultIdl, wallet.publicKey, 0n, undefined, undefined, { request }); ``` ### Interfaces #### ISolanaCancelRedeemRequestParams Input to SolanaAdapter.vaultCancelRedeemRequest. **Properties** | Property | Type | Description | | --------- | ----------------------- | ------------------------------------------------------------------- | | `request` | `string` \| `PublicKey` | The request account's address, as returned by `vaultRequestRedeem`. | | `wallet` | `string` \| `PublicKey` | The holder who made the request; only they may cancel it. | *** #### ISolanaDepositOptions Slippage protection for SolanaAdapter.vaultDeposit. The SDK quotes the shares a deposit should mint from the vault's current state and passes a floor to the program's `deposit_checked` instruction, which reverts with `SlippageExceeded` if the share price moves past it before execution. **Properties** | Property | Type | Default value | Description | | --------------- | -------- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `minSharesOut?` | `bigint` | `undefined` | Explicit floor in raw share units, passed to `deposit_checked` as is. Skips the quote and the single snapshot read it needs. `0n` restores the unguarded behaviour of the plain `deposit` instruction. When the handler's `idl` predates `deposit_checked`, a non-zero floor or any `slippageBps` throws AugustValidationError instead of being silently dropped; with neither, the plain `deposit` is sent. Must be a `bigint` in `0 .. 2^64-1`; anything else throws AugustValidationError before the transaction is built. | | `slippageBps?` | `number` | `50 (0.5%)` | Tolerance below the quoted shares, in basis points (`0` to `10000`). `0` demands the quote exactly. Ignored when `minSharesOut` is given. | *** #### ISolanaRedeemOptions Slippage protection for SolanaAdapter.vaultRedeem. The floor is measured **net of the withdrawal fee**, i.e. on what the wallet actually receives, matching the program's `redeem_checked`. **Properties** | Property | Type | Default value | Description | | --------------- | ----------------------- | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `minAssetsOut?` | `bigint` | `undefined` | Explicit floor in raw deposit-mint units, net of the withdrawal fee, passed to `redeem_checked` as is. Skips the quote. `0n` restores the unguarded behaviour of the plain `redeem` instruction. When the handler's `idl` predates `redeem_checked`, a non-zero floor or any `slippageBps` throws AugustValidationError instead of being silently dropped; with neither, the plain `redeem` is sent. | | `request?` | `string` \| `PublicKey` | `undefined` | Claim this withdrawal request instead of redeeming instantly: the request account's address, as `id` on the entries `getVaultAvailableRedemptions` returns. Its shares, recipient and vault come from the request, so the `redeemShares` and `vaultAddress` arguments are ignored. The queue pays at the share price of the moment it settles, held to the floor the request was made with, so `slippageBps` and `minAssetsOut` must not be set alongside it. Required on a vault with a withdrawal queue attached, which refuses a direct redeem. See SolanaAdapter.vaultRequestRedeem. | | `slippageBps?` | `number` | `50 (0.5%)` | Tolerance below the quoted net payout, in basis points (`0` to `10000`). `0` demands the quote exactly. Ignored when `minAssetsOut` is given. | *** #### ISolanaRequestRedeemParams Input to SolanaAdapter.vaultRequestRedeem. **Properties** | Property | Type | Default value | Description | | --------------- | ----------------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `amount` | `number` \| `bigint` | `undefined` | Shares to escrow: `bigint` in raw share units, or `number` as a UI amount. | | `finalizer?` | `string` \| `PublicKey` | `undefined` | The one key besides the holder that may claim the request, e.g. a keeper. Defaults to anyone, which is what lets a keeper settle requests for holders who do not come back. | | `minAssetsOut?` | `bigint` | `undefined` | Explicit floor on the net payout, in raw deposit-mint units, stored on the request as is. Skips the quote. `0n` means no floor: the claim pays whatever the shares are worth when it lands. Must be a `bigint` in `0 .. 2^64-1`; anything else throws AugustValidationError before the transaction is built. | | `recipient?` | `string` \| `PublicKey` | `undefined` | Wallet to pay when the request is claimed; its deposit-token account is created in the same transaction if it has none, at the holder's expense. Defaults to the holder. | | `requestId?` | `bigint` | `undefined` | The request's id, unique per holder while it is pending. Defaults to a random `u64`; pass one only to choose it yourself. | | `slippageBps?` | `number` | `50 (0.5%)` | Tolerance below the quoted net payout, in basis points (`0` to `10000`). The floor is fixed now and checked when the request is claimed, so it guards against a fee rise or an AUM mark-down in between; yield earned in the meantime only raises the payout. Ignored when `minAssetsOut` is given. | | `vault` | `string` \| `PublicKey` | `undefined` | The vault's `VaultState` account address. | | `wallet` | `string` \| `PublicKey` | `undefined` | The holder, who signs, escrows the shares and pays rent for the request. | *** #### ISolanaRequestRedeemResult What SolanaAdapter.vaultRequestRedeem returns. **Properties** | Property | Type | Description | | ----------- | -------- | ---------------------------------------------------------------------------------------------------------------------------- | | `request` | `string` | The new request account's address: pass it as `request` to claim or cancel. `getVaultAvailableRedemptions` lists it as `id`. | | `requestId` | `string` | The request id, as a decimal string (a `u64`). | | `signature` | `string` | The confirmed transaction's signature. | ### Variables #### Solana > `const` **Solana**: `object` **Type Declaration** | Name | Type | Default value | | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------- | | `actions` | `__module` | `SolanaActions` | | `constants` | `__module` | `SolanaConstants` | | `getters` | `__module` | `SolanaGetters` | | `utils` | `object` | `SolanaUtils` | | `utils.deriveShareMintPda()` | (`vaultProgramId`) => `PublicKey` | - | | `utils.deriveVaultStatePda()` | (`vaultProgramId`) => `PublicKey` | - | | `utils.deriveVaultTokenAtaPda()` | (`vaultProgramId`, `depositMint`, `vaultVersion?`) => `PublicKey` | - | | `utils.fallbackDecimals` | `number` | - | | `utils.fallbackNetwork` | `ISolanaNetwork` | - | | `utils.fetchUserShareBalance()` | (`__namedParameters`) => `Promise`<`number`> | - | | `utils.fetchUserShareBalanceRaw()` | (`__namedParameters`) => `Promise`<{ `amount`: `string`; `decimals`: `number`; }> | - | | `utils.fetchUserTokenBalance()` | (`__namedParameters`) => `Promise`<`string`> | - | | `utils.getBestRpcEndpoint()` | (`__namedParameters`) => `Promise`<`"http://127.0.0.1:8899"` \| `` `https://${string}` ``> | - | | `utils.getExplorerLink()` | (`__namedParameters`) => `string` | - | | `utils.getProgram()` | (`__namedParameters`) => `Program`<`any`> | - | | `utils.getProvider()` | (`__namedParameters`) => `BlockhashConfirmingProvider` | - | | `utils.getReadOnlyProvider()` | (`__namedParameters`) => `AnchorProvider` | - | | `utils.getToken()` | (`__namedParameters`) => `Promise`<{ `address`: `string`; `decimals`: `number`; `image`: `string`; `name`: `string`; `symbol`: `string`; }> | - | | `utils.getTokenSymbol()` | (`__namedParameters`) => `Promise`<`string`> | - | | `utils.getVaultMints()` | (`__namedParameters`) => `Promise`<{ `depositMint`: `string`; `shareMint`: `string`; `vaultVersion`: `number`; }> | - | | `utils.getVaultState()` | (`__namedParameters`) => `Promise`<{ `depositMintDecimals`: `number`; `vaultState`: `unknown`; }> | - | | `utils.getVaultStateReadOnly()` | (`__namedParameters`) => `Promise`<{ `depositMintDecimals`: `number`; `vaultState`: `ISolanaVaultState`; }> | - | | `utils.isSolana()` | (`signature`) => `boolean` | - | | `utils.isSolanaAddress()` | (`address`) => `boolean` | - | | `utils.programIds` | `object` | - | | `utils.programIds.devnet` | `object` | - | | `utils.programIds.devnet.vault` | `string` | `'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt'` | | `utils.programIds.devnet.withdrawalQueue` | `string` | `'upQhC7mgYwmHLVaatRWoGAu394piLT9th9FiQZHnPrW'` | | `utils.programIds.localnet` | `object` | - | | `utils.programIds.localnet.vault` | `string` | `'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt'` | | `utils.programIds.localnet.withdrawalQueue` | `string` | `'upQhC7mgYwmHLVaatRWoGAu394piLT9th9FiQZHnPrW'` | | `utils.programIds.mainnet-beta` | `object` | - | | `utils.programIds.mainnet-beta.vault` | `string` | `'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt'` | | `utils.resolveProgramId()` | (`vaultAddress`, `solanaMetadata?`) => `string` | - |