@augustdigital/sdk 9.11.0 → 9.12.0

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

@@ -2,6 +2,14 @@ import type { ISolanaNetwork } from '../../types';
 import { vaultIdl } from './idl/vault-idl';
 declare const fallbackDecimals = 8;
 declare const fallbackNetwork: ISolanaNetwork;
+/**
+ * Program ids deployed on one Solana network. `withdrawalQueue` is absent where
+ * the queue program is not deployed yet (currently mainnet-beta).
+ */
+type ISolanaProgramIds = {
+    vault: string;
+    withdrawalQueue?: string;
+};
 declare const fallbackRpcEndpoints: {
     readonly devnet: "https://api.devnet.solana.com";
     readonly mainnet: "https://api.mainnet-beta.solana.com";
@@ -11,12 +19,14 @@ declare const fallbackRpcEndpoints: {
 declare const programIds: {
     devnet: {
         vault: string;
+        withdrawalQueue: string;
     };
     "mainnet-beta": {
         vault: string;
     };
     localnet: {
         vault: string;
+        withdrawalQueue: string;
     };
 };
 /** Solana networks the canonical august_vault program is actually deployed on. */
@@ -26,8 +36,6 @@ type ISolanaDeployedNetwork = keyof typeof programIds;
  * deployment there (currently `testnet`). Callers must handle `undefined` —
  * silently substituting a default would hand back a dead address.
  */
-declare function getDeployedProgramIds(network: ISolanaNetwork): {
-    vault: string;
-} | undefined;
+declare function getDeployedProgramIds(network: ISolanaNetwork): ISolanaProgramIds | undefined;
 export { fallbackDecimals, fallbackNetwork, fallbackRpcEndpoints, getDeployedProgramIds, programIds, vaultIdl, };
-export type { ISolanaDeployedNetwork };
+export type { ISolanaDeployedNetwork, ISolanaProgramIds };

package/lib/adapters/solana/constants.js

@@ -8,9 +8,6 @@ const fallbackDecimals = 8;
 exports.fallbackDecimals = fallbackDecimals;
 const fallbackNetwork = 'mainnet-beta';
 exports.fallbackNetwork = fallbackNetwork;
-// ============================================================================
-// SOLANA CONFIGURATION
-// ============================================================================
 const fallbackRpcEndpoints = {
     devnet: 'https://api.devnet.solana.com',
     mainnet: 'https://api.mainnet-beta.solana.com',
@@ -29,15 +26,23 @@ exports.fallbackRpcEndpoints = fallbackRpcEndpoints;
 // transaction. Unmapped networks throw from `getProgram`/`getProgramId` instead.
 // `satisfies` keeps the literal ids in the generated docs while checking keys
 // against ISolanaNetwork, so `testnet` is absent from the type, not optional.
+//
+// `withdrawalQueue` is the august_withdrawal_queue program. Its id is fixed (the
+// vault binary hardcodes it as `WITHDRAWAL_QUEUE_PROGRAM_ID`), but it is mapped
+// only where deployed: devnet and localnet. Mainnet-beta still runs the pre-queue
+// vault build, which the bundled vault IDL stays compatible with; add the entry
+// there once the mainnet upgrade deploys the queue.
 const programIds = {
     devnet: {
         vault: 'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt',
+        withdrawalQueue: 'upQhC7mgYwmHLVaatRWoGAu394piLT9th9FiQZHnPrW',
     },
     ['mainnet-beta']: {
         vault: 'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt',
     },
     localnet: {
         vault: 'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt',
+        withdrawalQueue: 'upQhC7mgYwmHLVaatRWoGAu394piLT9th9FiQZHnPrW',
     },
 };
 exports.programIds = programIds;

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

@@ -4,6 +4,11 @@ import type { IVaultBaseOptions } from '../../modules/vaults/types';
  * Fetch Solana vault data from on-chain program state.
  * Falls back to backend-only data when Solana RPC is unavailable,
  * ensuring vaults always appear in the list even without on-chain access.
+ *
+ * When the vault has a withdrawal queue, `withdrawalQueue` carries its live
+ * summary, at the cost of one extra `getMultipleAccountsInfo` (the queue and a
+ * fresh read of the vault state, for `enabled`). A failed queue read is
+ * logged and leaves the field out rather than failing the vault.
  * @param tokenizedVault Vault metadata from backend
  * @param options RPC configuration with Solana service
  * @returns Formatted vault object with Solana-specific fields

package/lib/adapters/solana/getters.js

@@ -39,10 +39,16 @@ const utils_1 = require("./utils");
 const SolanaConstants = __importStar(require("./constants"));
 const core_1 = require("../../core");
 const utils_2 = require("../../modules/vaults/utils");
+const withdrawal_queue_1 = require("./withdrawal-queue");
 /**
  * Fetch Solana vault data from on-chain program state.
  * Falls back to backend-only data when Solana RPC is unavailable,
  * ensuring vaults always appear in the list even without on-chain access.
+ *
+ * When the vault has a withdrawal queue, `withdrawalQueue` carries its live
+ * summary, at the cost of one extra `getMultipleAccountsInfo` (the queue and a
+ * fresh read of the vault state, for `enabled`). A failed queue read is
+ * logged and leaves the field out rather than failing the vault.
  * @param tokenizedVault Vault metadata from backend
  * @param options RPC configuration with Solana service
  * @returns Formatted vault object with Solana-specific fields
@@ -101,6 +107,7 @@ const getSolanaVault = async (tokenizedVault, options) => {
     // Prefer vaultState.shareMint (correct for multi-vault programs like jitoSOL);
     // fall back to deriveShareMintPda(programId) for legacy single-vault programs.
     let totalSupply = (0, core_1.toNormalizedBn)(0, decimals);
+    let shareDecimals = decimals;
     if (onChainAvailable) {
         try {
             const shareMintFromState = vaultState?.vaultState?.shareMint;
@@ -112,6 +119,7 @@ const getSolanaVault = async (tokenizedVault, options) => {
                 const parsedData = shareMintAccountInfo.value.data;
                 const { supply, decimals: mintDecimals } = parsedData.parsed.info;
                 totalSupply = (0, core_1.toNormalizedBn)(BigInt(supply), mintDecimals);
+                shareDecimals = mintDecimals;
             }
         }
         catch (error) {
@@ -152,8 +160,31 @@ const getSolanaVault = async (tokenizedVault, options) => {
             vault: tokenizedVault.address,
         });
     }
+    let withdrawalQueue;
+    const solanaService = options.solanaService;
+    if (onChainAvailable && vaultState?.vaultState && solanaService) {
+        try {
+            const queueProgramId = (0, withdrawal_queue_1.resolveQueueProgramId)(solanaService);
+            withdrawalQueue = queueProgramId
+                ? await (0, withdrawal_queue_1.getSolanaWithdrawalQueueSummary)({
+                    connection: solanaService.connection,
+                    queueProgramId,
+                    vaultState: solanaMetadata?.vault_state_pda
+                        ? new web3_js_1.PublicKey(solanaMetadata.vault_state_pda)
+                        : utils_1.SolanaUtils.deriveVaultStatePda(programId),
+                    shareDecimals,
+                })
+                : undefined;
+        }
+        catch (error) {
+            core_1.Logger.log.warn('getSolanaVault', 'Withdrawal queue read failed', {
+                vault: tokenizedVault.address,
+                error,
+            });
+        }
+    }
     // Build unified vault object combining on-chain and backend data
-    return (0, utils_2.buildBackendVault)(tokenizedVault, {
+    const vault = (0, utils_2.buildBackendVault)(tokenizedVault, {
         chainId: core_1.SPECIAL_CHAINS.solana.chainId,
         version: 'sol-0',
         name: tokenizedVault.vault_name || 'Solana Program',
@@ -167,6 +198,9 @@ const getSolanaVault = async (tokenizedVault, options) => {
         },
         programId,
     });
+    if (withdrawalQueue)
+        vault.withdrawalQueue = withdrawalQueue;
+    return vault;
 };
 exports.getSolanaVault = getSolanaVault;
 //# sourceMappingURL=getters.js.map

package/lib/adapters/solana/idl/vault-idl.d.ts

@@ -2,8 +2,10 @@
  * august_vault program IDL (Anchor).
  *
  * GENERATED — do not edit by hand. Source of truth is the program repo's build
- * artifact: solana-vaults `frontend/idl/august_vault.json` (synced from the
- * vendored program by `scripts/sync-idl.sh`). Regenerate from there, NOT with
+ * artifact: `target/idl/august_vault.json` from
+ * fractal-protocol/solana-upshift-vault-programs, built at the release the SDK
+ * targets (solana-vaults' `frontend/idl/august_vault.json` is a copy of the same
+ * artifact, synced from its vendored submodule). Regenerate from there, NOT with
  * `anchor idl fetch`: an Anchor IDL upload is not refreshed by a program
  * upgrade, so every IDL published for this program lineage is stale — both
  * `up12…` on mainnet (last written 2026-01-21) and the `C8B1…` devnet reference
@@ -13,6 +15,22 @@
  * it: SolanaAdapter/getProgram resolve the real program id per network from
  * programIds, or from an explicit `programId` override.
  *
+ * Writability: generated from the withdrawal-queue release build (#34). Later
+ * builds (devnet runs #41) drop `mut` from accounts they only read. Do not
+ * regenerate from one of those until mainnet runs it: mainnet's build rejects
+ * those accounts arriving read-only, while every build accepts them writable.
+ * Guarded by tests/adapters/solana-idl.test.ts. Built with the doc-only fix
+ * from program PR #48 applied (`SubaccountDelegationMissing` is 6027), so it
+ * differs from #34's artifact in doc strings alone.
+ *
+ * One hand edit after generation: `operator_token_account` in `operator_deposit`
+ * and `operator_withdraw` carries no `pda`. The program derives it as the ATA of
+ * the registered subaccount's stored `address`, or of the operator when there is
+ * none, which Anchor's IDL cannot express: the generated seed names the
+ * `subaccount` account itself, so Anchor would silently resolve the wrong ATA.
+ * Without the `pda`, callers must pass the account, and a missing one throws.
+ * Pinned by tests/adapters/solana-idl.test.ts; reapply it on every regeneration.
+ *
  * Drift is guarded by tests/vaults/solana-idl-drift.test.ts: the deployed binary
  * is pinned, every discriminator declared here must appear in that binary, and
  * live VaultState accounts must decode against this file.
@@ -33,6 +51,32 @@ export declare const vaultIdl: {
         name: string;
     }[];
     instructions: ({
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+            docs?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            signer?: undefined;
+            docs?: undefined;
+        } | {
+            name: string;
+            signer: boolean;
+            writable?: undefined;
+            docs?: undefined;
+        } | {
+            docs: string[];
+            name: string;
+            writable?: undefined;
+            signer?: undefined;
+        })[];
+        args: any[];
+        discriminator: number[];
+        docs: string[];
+        name: string;
+    } | {
         accounts: ({
             name: string;
             signer: boolean;
@@ -97,6 +141,75 @@ export declare const vaultIdl: {
         discriminator: number[];
         docs: string[];
         name: string;
+    } | {
+        accounts: ({
+            name: string;
+            writable: boolean;
+            pda?: undefined;
+            signer?: undefined;
+        } | {
+            name: string;
+            pda: {
+                seeds: ({
+                    kind: string;
+                    value: number[];
+                    path?: undefined;
+                    account?: undefined;
+                } | {
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                    account?: undefined;
+                } | {
+                    account: string;
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                })[];
+            };
+            writable: boolean;
+            signer?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            pda?: undefined;
+            signer?: undefined;
+        } | {
+            name: string;
+            signer: boolean;
+            writable: boolean;
+            pda?: undefined;
+        })[];
+        args: any[];
+        discriminator: number[];
+        docs: string[];
+        name: string;
+    } | {
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+            docs?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            signer?: undefined;
+            docs?: undefined;
+        } | {
+            name: string;
+            signer: boolean;
+            writable?: undefined;
+            docs?: undefined;
+        } | {
+            docs: string[];
+            name: string;
+            signer: boolean;
+            writable?: undefined;
+        })[];
+        args: any[];
+        discriminator: number[];
+        docs: string[];
+        name: string;
     } | {
         accounts: ({
             docs: string[];
@@ -246,13 +359,163 @@ export declare const vaultIdl: {
         discriminator: number[];
         docs: string[];
         name: string;
+    } | {
+        accounts: ({
+            name: string;
+            writable: boolean;
+            docs?: undefined;
+            signer?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+        } | {
+            docs: string[];
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+        } | {
+            docs: string[];
+            name: string;
+            signer: boolean;
+            writable?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            docs?: undefined;
+            signer?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+        } | {
+            docs: string[];
+            name: string;
+            optional: boolean;
+            pda: {
+                seeds: ({
+                    kind: string;
+                    value: number[];
+                    path?: undefined;
+                    account?: undefined;
+                } | {
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                    account?: undefined;
+                } | {
+                    account: string;
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                })[];
+            };
+            writable: boolean;
+            signer?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: string;
+        }[];
+        discriminator: number[];
+        docs: string[];
+        name: string;
+    } | {
+        accounts: ({
+            name: string;
+            writable: boolean;
+            docs?: undefined;
+            signer?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+        } | {
+            docs: string[];
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+        } | {
+            name: string;
+            signer: boolean;
+            writable?: undefined;
+            docs?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            docs?: undefined;
+            signer?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+        } | {
+            docs: string[];
+            name: string;
+            optional: boolean;
+            pda: {
+                seeds: ({
+                    kind: string;
+                    value: number[];
+                    path?: undefined;
+                    account?: undefined;
+                } | {
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                    account?: undefined;
+                } | {
+                    account: string;
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                })[];
+            };
+            writable: boolean;
+            signer?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: string;
+        }[];
+        discriminator: number[];
+        docs: string[];
+        name: string;
     } | {
         accounts: ({
             name: string;
             writable: boolean;
             pda?: undefined;
+            docs?: undefined;
             signer?: undefined;
+            address?: undefined;
         } | {
+            name: string;
+            pda: {
+                seeds: ({
+                    kind: string;
+                    value: number[];
+                    path?: undefined;
+                } | {
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                })[];
+                program?: undefined;
+            };
+            writable: boolean;
+            docs?: undefined;
+            signer?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            pda?: undefined;
+            docs?: undefined;
+            signer?: undefined;
+            address?: undefined;
+        } | {
+            docs: string[];
             name: string;
             pda: {
                 program: {
@@ -264,17 +527,22 @@ export declare const vaultIdl: {
                     path: string;
                 }[];
             };
-            writable: boolean;
+            writable?: undefined;
             signer?: undefined;
+            address?: undefined;
         } | {
+            docs: string[];
             name: string;
             signer: boolean;
-            writable?: undefined;
+            writable: boolean;
             pda?: undefined;
+            address?: undefined;
         } | {
+            address: string;
             name: string;
             writable?: undefined;
             pda?: undefined;
+            docs?: undefined;
             signer?: undefined;
         })[];
         args: {
@@ -286,20 +554,67 @@ export declare const vaultIdl: {
         name: string;
     } | {
         accounts: ({
+            name: string;
+            writable: boolean;
+            pda?: undefined;
+            docs?: undefined;
+            signer?: undefined;
+        } | {
             name: string;
             pda: {
-                seeds: {
+                seeds: ({
                     kind: string;
                     value: number[];
-                }[];
+                    path?: undefined;
+                    account?: undefined;
+                } | {
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                    account?: undefined;
+                } | {
+                    account: string;
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                })[];
+                program?: undefined;
             };
             writable: boolean;
+            docs?: undefined;
             signer?: undefined;
         } | {
             name: string;
-            signer: boolean;
+            writable?: undefined;
             pda?: undefined;
+            docs?: undefined;
+            signer?: undefined;
+        } | {
+            docs: string[];
+            name: string;
+            pda: {
+                program: {
+                    kind: string;
+                    value: number[];
+                };
+                seeds: ({
+                    account: string;
+                    kind: string;
+                    path: string;
+                } | {
+                    kind: string;
+                    path: string;
+                    account?: undefined;
+                })[];
+            };
+            writable?: undefined;
+            signer?: undefined;
+        } | {
+            name: string;
+            signer: boolean;
             writable?: undefined;
+            pda?: undefined;
+            docs?: undefined;
         })[];
         args: {
             name: string;
@@ -435,5 +750,17 @@ export declare const vaultIdl: {
         repr?: undefined;
         serialization?: undefined;
         docs?: undefined;
+    } | {
+        docs: string[];
+        name: string;
+        type: {
+            fields: {
+                name: string;
+                type: string;
+            }[];
+            kind: string;
+        };
+        repr?: undefined;
+        serialization?: undefined;
     })[];
 };