@augustdigital/sdk 9.3.0 → 9.4.0

package/lib/adapters/solana/vault.actions.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.describeSolanaError = describeSolanaError;
+exports.slippageHint = slippageHint;
 exports.handleSolanaDeposit = handleSolanaDeposit;
 exports.handleSolanaRedeem = handleSolanaRedeem;
 const anchor_1 = require("@coral-xyz/anchor");
 const web3_js_1 = require("@solana/web3.js");
 const spl_token_1 = require("@solana/spl-token");
 const constants_1 = require("./constants");
+const pricing_1 = require("./pricing");
 const utils_1 = require("./utils");
 const core_1 = require("../../core");
 /**
@@ -49,6 +51,113 @@ function describeSolanaError(e) {
         ? str
         : REASONLESS_SOLANA_ERROR;
 }
+/** `SlippageExceeded` in `august_vault`'s error enum (ordinal 18 + Anchor's 6000 offset). */
+const SLIPPAGE_EXCEEDED_CODE = 6018;
+/**
+ * A sentence to append when the program rejected the instruction for
+ * slippage, so the caller learns what to do rather than just what happened.
+ * Empty for every other error.
+ *
+ * Not merely a restatement of the program's reason string. Both checked
+ * instructions share error 6018, whose on-chain message is share-worded —
+ * "Received fewer shares than the caller's minimum" — so on a *redeem*, where
+ * the floor is denominated in assets, the program describes the wrong
+ * quantity. This sentence is what makes that case readable. The numeric code
+ * `describeSolanaError` renders alongside it is kept deliberately: it is the
+ * handle support and telemetry group on, and it survives a reword of the
+ * program's message.
+ */
+function slippageHint(e) {
+    const anchor = e;
+    const code = anchor?.error?.errorCode?.number ?? anchor?.code;
+    const name = anchor?.error?.errorCode?.code;
+    return code === SLIPPAGE_EXCEEDED_CODE || name === 'SlippageExceeded'
+        ? ' The share price moved past your slippage tolerance between the quote and execution; retry, or pass a higher `slippageBps`.'
+        : '';
+}
+/** Largest value Anchor's `u64` encoder can represent. */
+const U64_MAX = 18446744073709551615n;
+/**
+ * Validate a caller-supplied slippage floor before it reaches Anchor's `u64`
+ * encoder.
+ *
+ * Anchor serializes a `BN` to `u64` via `toArrayLike`, which writes the
+ * magnitude and drops the sign — a `-1n` floor would reach the program as a
+ * floor of `1`, inverting the caller's intent instead of failing. Values above
+ * `u64` fare no better: they surface as an untyped "byte array longer than
+ * desired length" from inside the encoder, naming nothing the caller passed.
+ * Both are caught here, at the public-API boundary.
+ *
+ * @param value - The caller's `minSharesOut` / `minAssetsOut`, in raw base units.
+ * @param label - Option name, quoted in the error.
+ * @returns `value`, once known to fit an unsigned 64-bit integer.
+ * @throws {@link AugustValidationError} when it is not a `bigint` in `0 .. 2^64-1`.
+ */
+function validateExplicitFloor(value, label) {
+    if (typeof value !== 'bigint' || value < 0n || value > U64_MAX) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `${label} must be a bigint between 0 and ${U64_MAX} raw base units, got ${String(value)}.`);
+    }
+    return value;
+}
+/**
+ * The vault state and share-mint supply as of a **single slot**.
+ *
+ * Both figures price the quote, so they have to come from one snapshot. Read
+ * independently — even concurrently, as two RPC requests — a deposit or
+ * redemption landing in between combines a supply and an asset total that
+ * never coexisted, and the quote is wrong in whichever direction the
+ * interleaving fell. Seeing a 10% deposit's new assets against the old supply
+ * quotes ~10% high, and the floor then rejects a redemption whose share price
+ * never moved; the opposite ordering quotes low and silently weakens the
+ * protection. `getMultipleAccountsInfo` is served from one slot, so the pair
+ * is always coherent — and it costs one round trip instead of two.
+ *
+ * @param program - Anchor program, used only for its account coder; the
+ *   provider it was built with is irrelevant, so no read-only program is needed.
+ * @param vaultStatePda - Vault state account to decode.
+ * @param shareMintAddr - Share mint whose supply and decimals are read.
+ * @returns The decoded `VaultState`, the share mint's raw `supply`, and its
+ *   `decimals` — all from the same slot.
+ * @throws {@link AugustSDKError} when either account is absent, or is not the
+ *   account type it should be.
+ */
+async function readPricingSnapshot({ connection, program, vaultStatePda, shareMintAddr, }) {
+    const [vaultStateInfo, shareMintInfo] = await connection.getMultipleAccountsInfo([vaultStatePda, shareMintAddr]);
+    if (!vaultStateInfo) {
+        throw new core_1.AugustSDKError('UNKNOWN', `Vault state account ${vaultStatePda.toBase58()} does not exist; it cannot be priced.`);
+    }
+    if (!shareMintInfo) {
+        throw new core_1.AugustSDKError('UNKNOWN', `Share mint ${shareMintAddr.toBase58()} does not exist; it cannot be priced.`);
+    }
+    // `vaultState`, not the IDL's own `VaultState`: `Program` runs the IDL
+    // through `convertIdlToCamelCase`, so its coder only answers to the
+    // camelCase name and the IDL spelling throws `Account not found`. (A coder
+    // built directly from the raw IDL behaves the opposite way — which is why
+    // this has to be checked against a real `Program`, as its test does.)
+    //
+    // Decoded by name rather than `decodeAny`, so a `vaultAddress` pointing at
+    // some other account of this program fails here instead of being decoded as
+    // whatever it happens to be.
+    let vaultStateData;
+    try {
+        vaultStateData = program.coder.accounts.decode('vaultState', vaultStateInfo.data);
+    }
+    catch (e) {
+        throw new core_1.AugustSDKError('UNKNOWN', `Account ${vaultStatePda.toBase58()} is not a vault state account for this program.`, { cause: e });
+    }
+    let mint;
+    try {
+        mint = (0, spl_token_1.unpackMint)(shareMintAddr, shareMintInfo, spl_token_1.TOKEN_PROGRAM_ID);
+    }
+    catch (e) {
+        throw new core_1.AugustSDKError('UNKNOWN', `Account ${shareMintAddr.toBase58()} is not an SPL Token mint.`, { cause: e });
+    }
+    return {
+        vaultStateData,
+        supply: mint.supply,
+        shareDecimals: mint.decimals,
+    };
+}
 /**
  * Pick which token account to hand the vault program for a given mint, and
  * describe how to create it when the user has none.
@@ -65,7 +174,7 @@ function describeSolanaError(e) {
  *   `.preInstructions()` it is atomic with the transfer, so there is no window
  *   in which the vault instruction can reference an account that has not
  *   landed. Sent as its own transaction — as this module used to — it raced
- *   its own confirmation. Observed in production (AUGUST-7221, 2026-08-11):
+ *   its own confirmation. Observed in production (2026-08-11):
  *   a deposit failed with `Simulation failed … Logs: []` while the share-ATA
  *   create was still in flight, then succeeded 17s later on retry. The empty
  *   log array means the transaction never reached program execution, so there
@@ -152,11 +261,13 @@ async function resolveUserTokenAccountPair({ connection, owner, mints, }) {
  *   non-refundable while the account stays open — on top of the network fee.
  *   Callers should ensure the wallet holds enough SOL for both before
  *   prompting the user to sign.
- * @remarks The on-chain `deposit` instruction has no `min_shares_out`
- *   parameter; slippage cannot be enforced on-chain until the program ships
- *   that argument.
+ * @remarks Sends `deposit_checked`, not `deposit`. Unless `options.minSharesOut`
+ *   is given, the vault state and share mint are read to quote the shares this
+ *   deposit should mint, and that quote lowered by `options.slippageBps`
+ *   (default {@link DEFAULT_SLIPPAGE_BPS}) is passed as the floor; the program
+ *   reverts with `SlippageExceeded` if execution would mint fewer.
  */
-async function handleSolanaDeposit({ provider, connection, network = constants_1.fallbackNetwork, vaultProgramId, vaultAddress, depositAmount, publicKey, idl, }) {
+async function handleSolanaDeposit({ provider, connection, network = constants_1.fallbackNetwork, vaultProgramId, vaultAddress, depositAmount, publicKey, idl, options = {}, }) {
     try {
         if (!publicKey)
             throw new core_1.AugustValidationError('INVALID_INPUT', 'handleSolanaDeposit: wallet not connected');
@@ -167,6 +278,9 @@ async function handleSolanaDeposit({ provider, connection, network = constants_1
             throw new core_1.AugustValidationError('INVALID_INPUT', 'handleSolanaDeposit: depositAmount is required and must be > 0');
         if (!vaultProgramId)
             throw new core_1.AugustValidationError('INVALID_INPUT', 'handleSolanaDeposit: vaultProgramId is required');
+        // Before any RPC: an unusable floor should cost the caller nothing.
+        if (options.minSharesOut !== undefined)
+            validateExplicitFloor(options.minSharesOut, 'minSharesOut');
         const { depositMint, shareMint, vaultVersion } = await utils_1.SolanaUtils.getVaultMints({
             network,
             connection,
@@ -279,9 +393,33 @@ async function handleSolanaDeposit({ provider, connection, network = constants_1
         core_1.Logger.log.info('handleSolanaDeposit', 'Share mint', shareMintAddr.toBase58());
         core_1.Logger.log.info('handleSolanaDeposit', 'Deposit mint', _depositMint?.toBase58());
         core_1.Logger.log.info('handleSolanaDeposit', 'Signer', _publicKey.toBase58());
-        // TODO(slippage): pass `min_shares_out` here when the program ships it.
+        let minSharesOut;
+        if (options.minSharesOut !== undefined) {
+            minSharesOut = options.minSharesOut;
+        }
+        else {
+            // One read the unguarded `deposit` never needed: the vault state (assets
+            // and offset) and the share mint (supply) in a single snapshot, since
+            // pricing against a mismatched pair is worse than not quoting at all —
+            // see `readPricingSnapshot`. A caller already holding a quote can pass
+            // `minSharesOut` and skip it.
+            const { vaultStateData, supply } = await readPricingSnapshot({
+                connection,
+                program,
+                vaultStatePda,
+                shareMintAddr,
+            });
+            minSharesOut = (0, pricing_1.quoteDepositFloor)({
+                supply,
+                totalAssets: (0, pricing_1.totalAssetsOf)(vaultStateData),
+                amount: BigInt(depositAmountRaw.toString()),
+                offset: (0, pricing_1.resolveShareOffset)(vaultStateData.shareOffset),
+                slippageBps: options.slippageBps ?? pricing_1.DEFAULT_SLIPPAGE_BPS,
+            });
+        }
+        core_1.Logger.log.info('handleSolanaDeposit', 'Min shares out (raw)', minSharesOut.toString());
         const tx = await program.methods
-            .deposit(depositAmountRaw)
+            .depositChecked(depositAmountRaw, new anchor_1.BN(minSharesOut.toString()))
             .accounts({
             vaultState: vaultStatePda,
             vaultTokenAta: vaultTokenAtaPda,
@@ -320,7 +458,7 @@ async function handleSolanaDeposit({ provider, connection, network = constants_1
             vaultAddress: vaultAddress ? String(vaultAddress) : undefined,
             depositAmount: depositAmountForLog,
         });
-        throw new core_1.AugustSDKError('UNKNOWN', `Solana deposit failed: ${describeSolanaError(e)}`, {
+        throw new core_1.AugustSDKError('UNKNOWN', `Solana deposit failed: ${describeSolanaError(e)}${slippageHint(e)}`, {
             cause: e,
             context: {
                 vaultProgramId: String(vaultProgramId),
@@ -334,8 +472,12 @@ async function handleSolanaDeposit({ provider, connection, network = constants_1
  * Redeem vault shares back into the underlying mint on a Solana August vault.
  *
  * @param redeemShares  `bigint` is treated as raw share-token units;
- *   `number` is treated as a UI amount. See {@link handleSolanaDeposit} for
- *   the same caveat about the missing on-chain slippage guard.
+ *   `number` is treated as a UI amount.
+ * @remarks Sends `redeem_checked`, not `redeem`. Unless `options.minAssetsOut`
+ *   is given, the payout is quoted from the vault state and share supply the
+ *   handler already reads, **net of the withdrawal fee**, and that quote
+ *   lowered by `options.slippageBps` (default {@link DEFAULT_SLIPPAGE_BPS}) is
+ *   passed as the floor; the program reverts with `SlippageExceeded` below it.
  * @throws AugustValidationError on missing wallet/programId or invalid amount,
  *   or when the wallet holds fewer shares than `redeemShares`.
  * @throws AugustSDKError when a candidate token account's balance cannot be
@@ -347,7 +489,7 @@ async function handleSolanaDeposit({ provider, connection, network = constants_1
  *   non-refundable, on top of the network fee. Callers should ensure the
  *   wallet holds enough SOL for all of it before prompting the user to sign.
  */
-async function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultAddress, publicKey, redeemShares, idl, }) {
+async function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultAddress, publicKey, redeemShares, idl, options = {}, }) {
     try {
         if (!publicKey)
             throw new core_1.AugustValidationError('INVALID_INPUT', 'handleSolanaRedeem: wallet not connected');
@@ -358,6 +500,9 @@ async function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultA
             throw new core_1.AugustValidationError('INVALID_INPUT', 'handleSolanaRedeem: redeemShares is required and must be > 0');
         if (!vaultProgramId)
             throw new core_1.AugustValidationError('INVALID_INPUT', 'handleSolanaRedeem: vaultProgramId is required');
+        // Before any RPC: an unusable floor should cost the caller nothing.
+        if (options.minAssetsOut !== undefined)
+            validateExplicitFloor(options.minAssetsOut, 'minAssetsOut');
         const { depositMint, shareMint, vaultVersion } = await utils_1.SolanaUtils.getVaultMints({
             network: provider.connection.rpcEndpoint.includes('devnet')
                 ? 'devnet'
@@ -385,13 +530,16 @@ async function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultA
         // Use on-chain share mint from vault state instead of deriving a PDA,
         // since PDA derivation assumes one share mint per program (single-vault only).
         const shareMintAddr = new web3_js_1.PublicKey(shareMint);
-        // Get share mint info to handle decimals
-        const shareMintInfo = await connection.getParsedAccountInfo(shareMintAddr);
-        if (!shareMintInfo.value) {
-            throw new Error('Could not fetch share mint info');
-        }
-        const shareDecimals = shareMintInfo.value.data.parsed.info
-            .decimals;
+        // Share-mint decimals and supply plus the vault state, from one slot. This
+        // replaces a `getParsedAccountInfo` here and a `vaultState.fetch` further
+        // down — one round trip rather than two, and supply and assets can no
+        // longer be read either side of someone else's deposit.
+        const { vaultStateData, supply: shareSupply, shareDecimals, } = await readPricingSnapshot({
+            connection,
+            program,
+            vaultStatePda,
+            shareMintAddr,
+        });
         let redeemSharesRaw;
         if (typeof redeemShares === 'bigint') {
             redeemSharesRaw = new anchor_1.BN(redeemShares.toString());
@@ -447,14 +595,22 @@ async function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultA
                 'so it cannot receive the redemption proceeds.');
         }
         const senderTokenAccount = payoutAccount.address;
-        // Get the fee recipient from vault state
-        const readOnlyProvider = utils_1.SolanaUtils.getReadOnlyProvider({ connection });
-        const readOnlyProgram = utils_1.SolanaUtils.getProgram({
-            provider: readOnlyProvider,
-            idl,
-            programId: _vaultProgramId.toBase58(),
-        });
-        const vaultStateData = await readOnlyProgram.account.vaultState.fetch(vaultStatePda);
+        // No extra reads here: the share mint (supply) and vault state (assets,
+        // offset, fee, fee recipient) came from the snapshot above.
+        let minAssetsOut;
+        if (options.minAssetsOut !== undefined) {
+            minAssetsOut = options.minAssetsOut;
+        }
+        else {
+            minAssetsOut = (0, pricing_1.quoteRedeemFloor)({
+                supply: shareSupply,
+                totalAssets: (0, pricing_1.totalAssetsOf)(vaultStateData),
+                shares: BigInt(redeemSharesRaw.toString()),
+                offset: (0, pricing_1.resolveShareOffset)(vaultStateData.shareOffset),
+                feePpm: (0, pricing_1.toBigInt)(vaultStateData.withdrawalFee, 'withdrawalFee'),
+                slippageBps: options.slippageBps ?? pricing_1.DEFAULT_SLIPPAGE_BPS,
+            });
+        }
         // Get the fee recipient's token account
         const feeRecipientTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(_depositMint, vaultStateData.feeRecipient);
         // Every account this handler might have to create is created in the same
@@ -483,8 +639,9 @@ async function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultA
         core_1.Logger.log.info('handleSolanaRedeem', 'Share mint:', shareMintAddr.toBase58());
         core_1.Logger.log.info('handleSolanaRedeem', 'Deposit mint:', _depositMint?.toBase58());
         core_1.Logger.log.info('handleSolanaRedeem', 'Signer:', _publicKey.toBase58());
+        core_1.Logger.log.info('handleSolanaRedeem', 'Min assets out, net of fee (raw):', minAssetsOut.toString());
         const tx = await program.methods
-            .redeem(redeemSharesRaw)
+            .redeemChecked(redeemSharesRaw, new anchor_1.BN(minAssetsOut.toString()))
             .accounts({
             vaultState: vaultStatePda,
             vaultDepositAta: vaultTokenAtaPda,
@@ -516,7 +673,7 @@ async function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultA
             vaultAddress: vaultAddress ? String(vaultAddress) : undefined,
             redeemShares: redeemSharesForLog,
         });
-        throw new core_1.AugustSDKError('UNKNOWN', `Solana redeem failed: ${describeSolanaError(e)}`, {
+        throw new core_1.AugustSDKError('UNKNOWN', `Solana redeem failed: ${describeSolanaError(e)}${slippageHint(e)}`, {
             cause: e,
             context: {
                 vaultProgramId: String(vaultProgramId),

package/lib/adapters/stellar/actions.d.ts

@@ -25,8 +25,8 @@ export declare function handleStellarDeposit(params: IStellarDepositParams): Pro
  * Side effect on failure: when the *vault* cannot serve the redemption — it
  * rejected the call, or its ledger state needs restoring — the failure is
  * reported to that vault's curator. Stellar vaults are instant-redeem only, so
- * this is the curator's only signal that their depositors cannot get out
- * (AUGUST-7162). Fire-and-forget and deduped; see
+ * this is the curator's only signal that their depositors cannot get out.
+ * Fire-and-forget and deduped; see
  * {@link reportRedeemFailure} and {@link REPORTED_BUILD_STAGES}.
  *
  * Note this includes a caller-caused rejection such as redeeming more shares

package/lib/adapters/stellar/actions.js

@@ -81,8 +81,8 @@ async function handleStellarDeposit(params) {
  * Side effect on failure: when the *vault* cannot serve the redemption — it
  * rejected the call, or its ledger state needs restoring — the failure is
  * reported to that vault's curator. Stellar vaults are instant-redeem only, so
- * this is the curator's only signal that their depositors cannot get out
- * (AUGUST-7162). Fire-and-forget and deduped; see
+ * this is the curator's only signal that their depositors cannot get out.
+ * Fire-and-forget and deduped; see
  * {@link reportRedeemFailure} and {@link REPORTED_BUILD_STAGES}.
  *
  * Note this includes a caller-caused rejection such as redeeming more shares

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

@@ -32,7 +32,7 @@ export declare const getStellarVault: (tokenizedVault: ITokenizedVault, options:
  * (e.g. 13). A consumer that sizes a redeem trusting a silent fallback 7 would
  * under-redeem by `10^offset`. Callers that settle a redeem from this position
  * MUST refuse (surface an error) when `decimalsFromFallback` is `true` rather
- * than trusting `decimals`. See AUGUST-6381 (follow-up to AUGUST-6380).
+ * than trusting `decimals`.
  *
  * @param vaultAddress - Stellar vault contract ID (C… address)
  * @param walletAddress - User's Stellar account (G… address); validated upfront

package/lib/adapters/stellar/getters.js

@@ -22,7 +22,7 @@ const soroban_1 = require("./soroban");
  * Returns `{ decimals, fromFallback }`. When the `decimals()` retval is missing
  * or unparseable, `decimals` is STELLAR_FALLBACK_DECIMALS (7) and `fromFallback`
  * is `true` — the signal callers need to avoid trusting a fabricated scale (a
- * silent 7 under-redeems ERC4626 offset vaults; see AUGUST-6381). A successful
+ * silent 7 under-redeems ERC4626 offset vaults). A successful
  * parse returns the on-chain value with `fromFallback: false`.
  */
 function parseDecimals(scVal, context, vaultAddress) {
@@ -172,7 +172,7 @@ exports.getStellarVault = getStellarVault;
  * (e.g. 13). A consumer that sizes a redeem trusting a silent fallback 7 would
  * under-redeem by `10^offset`. Callers that settle a redeem from this position
  * MUST refuse (surface an error) when `decimalsFromFallback` is `true` rather
- * than trusting `decimals`. See AUGUST-6381 (follow-up to AUGUST-6380).
+ * than trusting `decimals`.
  *
  * @param vaultAddress - Stellar vault contract ID (C… address)
  * @param walletAddress - User's Stellar account (G… address); validated upfront

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

@@ -112,7 +112,7 @@ export declare class StellarAdapter {
      * @returns The position `{ shares, decimals, decimalsFromFallback }`, or null
      * if the balance read fails. When `decimalsFromFallback` is `true` the
      * `decimals()` read failed and `decimals` is the fallback (7) — callers sizing
-     * a redeem MUST refuse rather than trust it (see AUGUST-6381).
+     * a redeem MUST refuse rather than trust it.
      */
     getUserPosition(vaultAddress: string, walletAddress: string): Promise<IStellarUserPosition | null>;
     /**

package/lib/adapters/stellar/index.js

@@ -167,7 +167,7 @@ class StellarAdapter {
      * @returns The position `{ shares, decimals, decimalsFromFallback }`, or null
      * if the balance read fails. When `decimalsFromFallback` is `true` the
      * `decimals()` read failed and `decimals` is the fallback (7) — callers sizing
-     * a redeem MUST refuse rather than trust it (see AUGUST-6381).
+     * a redeem MUST refuse rather than trust it.
      */
     async getUserPosition(vaultAddress, walletAddress) {
         return StellarGetters.getStellarUserPosition(vaultAddress, walletAddress, this._network, this._sorobanRpcUrl);

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

@@ -37,8 +37,7 @@ export interface IStellarRedeemParams {
  * (7) and `decimalsFromFallback` is set to `true`. Callers that size a redeem
  * from this position MUST check `decimalsFromFallback` and refuse to settle
  * when it is `true` — trusting a fabricated 7 against an ERC4626 offset vault
- * (share decimals = asset + offset) under-redeems by `10^offset`. See
- * AUGUST-6381.
+ * (share decimals = asset + offset) under-redeems by `10^offset`.
  */
 export interface IStellarUserPosition {
     /** Raw share balance in smallest unit, as a non-negative integer string */

package/lib/core/analytics/method-taxonomy.js

@@ -64,6 +64,9 @@ exports.METHOD_CATEGORIES = {
     getVaultWithdrawals: 'read.redemption',
     getWithdrawalRequestsWithStatus: 'read.redemption',
     previewRedemption: 'read.redemption',
+    getBurnableAmountByReceiver: 'read.redemption',
+    getRequirementByDate: 'read.redemption',
+    getScheduledTransactionsByDate: 'read.redemption',
     getPrice: 'read.price',
     getUserPoints: 'read.points',
     fetchPointsLeaderboard: 'read.points',
@@ -111,6 +114,9 @@ exports.METHOD_CATEGORIES = {
     allowance: 'read.evm',
     balanceOf: 'read.evm',
     maxDeposit: 'read.vault',
+    getIdleLiquidity: 'read.vault',
+    lagDuration: 'read.vault',
+    getWithdrawalEpoch: 'read.vault',
     vaultDeposit: 'write.deposit',
     depositNative: 'write.deposit',
     swapAndDeposit: 'write.deposit',
@@ -118,6 +124,7 @@ exports.METHOD_CATEGORIES = {
     depositNativeViaSwapRouter: 'write.deposit',
     swapRouterDeposit: 'write.deposit',
     vaultRedeem: 'write.redeem',
+    claimWithdrawal: 'write.redeem',
     vaultRequestRedeem: 'write.redeem',
     rwaRedeemAsset: 'write.redeem',
     vaultApprove: 'write.approve',

package/lib/core/analytics/version.d.ts

@@ -3,4 +3,4 @@
  * Generated during publish from package.json version
  * This file is gitignored and created at publish time
  */
-export declare const SDK_VERSION = "9.3.0";
+export declare const SDK_VERSION = "9.4.0";

package/lib/core/analytics/version.js

@@ -6,5 +6,5 @@ exports.SDK_VERSION = void 0;
  * Generated during publish from package.json version
  * This file is gitignored and created at publish time
  */
-exports.SDK_VERSION = '9.3.0';
+exports.SDK_VERSION = '9.4.0';
 //# sourceMappingURL=version.js.map

package/lib/core/base.class.d.ts

@@ -148,8 +148,8 @@ export declare class AugustBase {
      */
     constructor({ appName, providers, keys, monitoring, analytics, versionCheck, timeoutMs, publicApiBaseUrl, attribution, }: IAugustBase);
     /**
-     * Verify API keys and authorize SDK usage.
-     * TODO: initialize class with appropriate keys and verify august key
+     * Verify the configured August API key and mark this instance as authorized.
+     * @throws Error when `keys.august` is missing or rejected by the API.
      */
     init(): Promise<void>;
     /**

package/lib/core/base.class.js

@@ -87,8 +87,8 @@ class AugustBase {
         });
     }
     /**
-     * Verify API keys and authorize SDK usage.
-     * TODO: initialize class with appropriate keys and verify august key
+     * Verify the configured August API key and mark this instance as authorized.
+     * @throws Error when `keys.august` is missing or rejected by the API.
      */
     async init() {
         const [augustCheck] = await Promise.all([

package/lib/core/constants/core.d.ts

@@ -3,10 +3,24 @@
  */
 import type { IAddress, VaultAddress } from '../../types';
 /**
- * Request timeout in milliseconds.
- * Set to 90 seconds to accommodate slow API responses.
+ * Default per-request timeout, in milliseconds, for every August HTTP fetcher
+ * (`fetchAugustPublic`, `fetchAugustWithKey`, `fetchAugustWithBearer`).
+ *
+ * Previously 90s. That was longer than any realistic caller was willing to
+ * wait: server-rendered integrations run inside serverless functions whose own
+ * execution budget is well under 90s, so the request had already been abandoned
+ * upstream by the time the abort fired — the timeout only ever garbage-collected
+ * a dead request, while the socket stayed open holding backend capacity and
+ * amplifying the stall for every concurrent caller.
+ *
+ * 15s is above the p99 of a healthy August API response and below every common
+ * upstream budget (Vercel/Lambda defaults, browser patience, upstream gateway
+ * timeouts), so a stalled request now fails fast and frees its connection.
+ *
+ * Callers that genuinely need longer override per-request via
+ * `IFetchAugustOptions.timeoutMs`, or process-wide via `setSdkRequestTimeout`.
  */
-export declare const REQUEST_TIMEOUT_MS = 90000;
+export declare const REQUEST_TIMEOUT_MS = 15000;
 export declare const PRICE_SERVER_URL = "https://prices.augustdigital.io";
 export declare const WEBSERVER_URL: {
     production: string;

package/lib/core/constants/core.js

@@ -33,10 +33,24 @@ function subaccountSegment(subaccount) {
         : encodeURIComponent(subaccount);
 }
 /**
- * Request timeout in milliseconds.
- * Set to 90 seconds to accommodate slow API responses.
+ * Default per-request timeout, in milliseconds, for every August HTTP fetcher
+ * (`fetchAugustPublic`, `fetchAugustWithKey`, `fetchAugustWithBearer`).
+ *
+ * Previously 90s. That was longer than any realistic caller was willing to
+ * wait: server-rendered integrations run inside serverless functions whose own
+ * execution budget is well under 90s, so the request had already been abandoned
+ * upstream by the time the abort fired — the timeout only ever garbage-collected
+ * a dead request, while the socket stayed open holding backend capacity and
+ * amplifying the stall for every concurrent caller.
+ *
+ * 15s is above the p99 of a healthy August API response and below every common
+ * upstream budget (Vercel/Lambda defaults, browser patience, upstream gateway
+ * timeouts), so a stalled request now fails fast and frees its connection.
+ *
+ * Callers that genuinely need longer override per-request via
+ * `IFetchAugustOptions.timeoutMs`, or process-wide via `setSdkRequestTimeout`.
  */
-exports.REQUEST_TIMEOUT_MS = 90000;
+exports.REQUEST_TIMEOUT_MS = 15000;
 exports.PRICE_SERVER_URL = 'https://prices.augustdigital.io';
 exports.WEBSERVER_URL = {
     production: 'https://backend.fractalprotocol.org',

package/lib/core/constants/vaults.js

@@ -103,6 +103,7 @@ exports.VAULT_FUNCTIONS_V1 = [
     'withdrawalFee',
     'lagDuration',
     'withdrawalsPaused',
+    'depositsPaused',
     'maxDepositAmount',
 ];
 exports.VAULT_FUNCTIONS_V2 = [
@@ -113,7 +114,10 @@ exports.VAULT_FUNCTIONS_V2 = [
     'maxDepositAmount',
     'lagDuration',
     'withdrawalsPaused',
+    'depositsPaused',
     'depositCap',
+    // MUST stay last: `getEvmVaultV2` reads the receipt token positionally as
+    // the final entry of this list.
     'lpTokenAddress',
 ];
 exports.VAULT_FUNCTIONS_V2_RECEIPT = [