@augustdigital/sdk 9.3.0 → 9.4.0

package/lib/adapters/evm/getters.js

@@ -6,6 +6,40 @@ const core_1 = require("../../core");
 const utils_1 = require("../../modules/vaults/utils");
 const TokenizedVaultV2_1 = require("../../abis/TokenizedVaultV2");
 const TokenizedVaultV2Receipt_1 = require("../../abis/TokenizedVaultV2Receipt");
+/**
+ * Read the vault's on-chain deposit-pause switch.
+ *
+ * A curator pausing deposits is the only signal that the deposit CTA must be
+ * disabled — without this read the UI offers a deposit that always reverts with
+ * `DepositsPaused` at estimateGas.
+ *
+ * Only a contract **revert** is treated as "getter absent". Transport failures
+ * (rate limit, timeout, network blip) are re-thrown: swallowing them would
+ * render a paused vault as open and send the user into a deposit that reverts
+ * at estimateGas — exactly the failure this read exists to prevent.
+ * @param vaultContract Vault contract instance (v1 lending pool or v2 tokenized vault).
+ * @returns `true` when deposits are paused on-chain; `false` when they are open
+ * OR when the deployment predates the getter — an older vault without
+ * `depositsPaused()` reverts the call, and a reverting read must not drop the
+ * whole vault from the marketplace.
+ * @throws The underlying RPC error when the read fails for a transport reason
+ * rather than a contract revert, so a flaky node cannot masquerade as
+ * "deposits open".
+ */
+const readDepositsPaused = async (vaultContract) => {
+    try {
+        return await vaultContract.depositsPaused();
+    }
+    catch (error) {
+        // Old deployments without `depositsPaused()` revert — treat as open.
+        // Anything else is a transport fault and must surface.
+        const isMissingGetter = (0, core_1.isExpectedRevertError)(error);
+        (0, core_1.logChainError)('readDepositsPaused', error, isMissingGetter);
+        if (isMissingGetter)
+            return false;
+        throw error;
+    }
+};
 /**
  * Fetch EVM vault data for v1 vault contracts (legacy format).
  * Queries on-chain state and combines with backend metadata.
@@ -49,6 +83,9 @@ const getEvmVaultV1 = async (tokenizedVault, options) => {
                 return null;
             }
         }
+        if (f === 'depositsPaused') {
+            return readDepositsPaused(vaultContract);
+        }
         if (f === 'symbol') {
             return (0, core_1.getSymbol)(provider, vault);
         }
@@ -133,6 +170,9 @@ const getEvmVaultV2 = async (tokenizedVault, options) => {
                 return null;
             }
         }
+        if (f === 'depositsPaused') {
+            return readDepositsPaused(vaultContract);
+        }
         return vaultContract[f]();
     }));
     const receiptAddress = vaultContractCalls[core_1.VAULT_FUNCTIONS_V2.length - 1];

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

@@ -1,6 +1,6 @@
-import { type IContractWriteOptions, type INativeDepositOptions, type ApproveResult } from '../../modules/vaults/write.actions';
+import { type IContractWriteOptions, type INativeDepositOptions, type ApproveResult, type IClaimWithdrawalOptions } from '../../modules/vaults/write.actions';
 import type { ISwapAndDepositOptions, ISwapRouterDirectDepositOptions, ISwapRouterNativeDepositOptions, ISwapRouterDepositOptions, ISwapRouterDepositResultOptions } from '../../types';
-import { type IPreviewDepositOptions, type IPreviewRedeemOptions, type IAllowanceOptions, type IBalanceOfOptions, type IMaxDepositOptions } from '../../modules/vaults/read.actions';
+import { type IPreviewDepositOptions, type IPreviewRedeemOptions, type IAllowanceOptions, type IBalanceOfOptions, type IMaxDepositOptions, type IGetIdleLiquidityOptions, type ILagDurationOptions, type IGetWithdrawalEpochOptions, type IWithdrawalEpoch, type IGetBurnableAmountByReceiverOptions, type IGetRequirementByDateOptions, type IGetScheduledTransactionsByDateOptions, type IScheduledTransactionsByDate } from '../../modules/vaults/read.actions';
 import { type CompatibleSigner } from '../../core/helpers/signer';
 import type { IAddress } from '../../types';
 export * from './getters';
@@ -265,6 +265,36 @@ declare class EVMAdapter {
         day: string;
         receiverIndex: string;
     }): Promise<string>;
+    /**
+     * Claim a previously-requested queued withdrawal on an EVM-2 (Tokenized
+     * Vault V2) vault, once its withdrawal epoch has passed. EVM-2 only — v1/v0
+     * vaults use {@link EVMAdapter.vaultRedeem} instead.
+     *
+     * @param options - {@link IClaimWithdrawalOptions}: `target` / `wallet`
+     *   plus the `year` / `month` / `day` tuple returned by
+     *   `vaultRequestRedeem`.
+     * @returns Claim transaction hash.
+     * @throws AugustValidationError on invalid inputs or a non-EVM-2 vault.
+     * @throws AugustSDKError on RPC / contract revert.
+     *
+     * @example
+     * ```ts
+     * const { year, month, day } = await augustSdk.evm.vaultRequestRedeem({
+     *   target: vaultAddress,
+     *   wallet: walletAddress,
+     *   amount: '10',
+     * });
+     * await augustSdk.evm.claimWithdrawal({
+     *   target: vaultAddress,
+     *   wallet: walletAddress,
+     *   year,
+     *   month,
+     *   day,
+     *   wait: true,
+     * });
+     * ```
+     */
+    claimWithdrawal(options: IClaimWithdrawalOptions): Promise<string>;
     sendersWhitelistAddress(options: {
         vault: IAddress;
     }): Promise<`0x${string}`>;
@@ -349,5 +379,79 @@ declare class EVMAdapter {
      * ```
      */
     maxDeposit(options: IMaxDepositOptions): Promise<bigint>;
+    /**
+     * Read an EVM-2 vault's idle liquidity (`getTotalAssets() -
+     * externalAssets()`) — the balance available to an instant redemption
+     * without a synchronous recall from the settlement module.
+     *
+     * @returns Idle liquidity as a raw `bigint`.
+     *
+     * @example
+     * ```ts
+     * const idle = await augustSdk.evm.getIdleLiquidity({ vault });
+     * ```
+     */
+    getIdleLiquidity(options: IGetIdleLiquidityOptions): Promise<bigint>;
+    /**
+     * Read an EVM-2 vault's queued-withdrawal lag, in seconds.
+     *
+     * @returns Lag duration as a raw `bigint`.
+     *
+     * @example
+     * ```ts
+     * const seconds = await augustSdk.evm.lagDuration({ vault });
+     * ```
+     */
+    lagDuration(options: ILagDurationOptions): Promise<bigint>;
+    /**
+     * Read an EVM-2 vault's current withdrawal epoch by named field
+     * (`year`/`month`/`day`/`claimableEpoch`).
+     *
+     * @returns {@link IWithdrawalEpoch}.
+     *
+     * @example
+     * ```ts
+     * const epoch = await augustSdk.evm.getWithdrawalEpoch({ vault });
+     * ```
+     */
+    getWithdrawalEpoch(options: IGetWithdrawalEpochOptions): Promise<IWithdrawalEpoch>;
+    /**
+     * Read how much of a withdrawal-epoch date's queue a receiver can
+     * currently claim, before calling {@link EVMAdapter.claimWithdrawal}.
+     *
+     * @returns Claimable amount as a raw `bigint`.
+     *
+     * @example
+     * ```ts
+     * const claimable = await augustSdk.evm.getBurnableAmountByReceiver({
+     *   vault, receiver, year, month, day,
+     * });
+     * ```
+     */
+    getBurnableAmountByReceiver(options: IGetBurnableAmountByReceiverOptions): Promise<bigint>;
+    /**
+     * Read the total shares required to settle a withdrawal-epoch date's
+     * entire queue.
+     *
+     * @returns Required shares as a raw `bigint`.
+     *
+     * @example
+     * ```ts
+     * const shares = await augustSdk.evm.getRequirementByDate({ vault, year, month, day });
+     * ```
+     */
+    getRequirementByDate(options: IGetRequirementByDateOptions): Promise<bigint>;
+    /**
+     * Read the scheduled queued-withdrawal volume for a withdrawal-epoch date.
+     *
+     * @returns {@link IScheduledTransactionsByDate}.
+     *
+     * @example
+     * ```ts
+     * const { totalTransactions, executionEpoch } =
+     *   await augustSdk.evm.getScheduledTransactionsByDate({ vault, year, month, day });
+     * ```
+     */
+    getScheduledTransactionsByDate(options: IGetScheduledTransactionsByDateOptions): Promise<IScheduledTransactionsByDate>;
 }
 export default EVMAdapter;

package/lib/adapters/evm/index.js

@@ -332,6 +332,39 @@ class EVMAdapter {
         const signer = await this.getSigner();
         return (0, write_actions_1.vaultRedeem)(signer, options);
     }
+    /**
+     * Claim a previously-requested queued withdrawal on an EVM-2 (Tokenized
+     * Vault V2) vault, once its withdrawal epoch has passed. EVM-2 only — v1/v0
+     * vaults use {@link EVMAdapter.vaultRedeem} instead.
+     *
+     * @param options - {@link IClaimWithdrawalOptions}: `target` / `wallet`
+     *   plus the `year` / `month` / `day` tuple returned by
+     *   `vaultRequestRedeem`.
+     * @returns Claim transaction hash.
+     * @throws AugustValidationError on invalid inputs or a non-EVM-2 vault.
+     * @throws AugustSDKError on RPC / contract revert.
+     *
+     * @example
+     * ```ts
+     * const { year, month, day } = await augustSdk.evm.vaultRequestRedeem({
+     *   target: vaultAddress,
+     *   wallet: walletAddress,
+     *   amount: '10',
+     * });
+     * await augustSdk.evm.claimWithdrawal({
+     *   target: vaultAddress,
+     *   wallet: walletAddress,
+     *   year,
+     *   month,
+     *   day,
+     *   wait: true,
+     * });
+     * ```
+     */
+    async claimWithdrawal(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.claimWithdrawal)(signer, options);
+    }
     async sendersWhitelistAddress(options) {
         const signer = await this.getSigner();
         return (0, read_actions_1.sendersWhitelistAddress)(signer, options);
@@ -429,6 +462,98 @@ class EVMAdapter {
         const signer = await this.getSigner();
         return (0, read_actions_1.maxDeposit)(signer, options);
     }
+    /**
+     * Read an EVM-2 vault's idle liquidity (`getTotalAssets() -
+     * externalAssets()`) — the balance available to an instant redemption
+     * without a synchronous recall from the settlement module.
+     *
+     * @returns Idle liquidity as a raw `bigint`.
+     *
+     * @example
+     * ```ts
+     * const idle = await augustSdk.evm.getIdleLiquidity({ vault });
+     * ```
+     */
+    async getIdleLiquidity(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.getIdleLiquidity)(signer, options);
+    }
+    /**
+     * Read an EVM-2 vault's queued-withdrawal lag, in seconds.
+     *
+     * @returns Lag duration as a raw `bigint`.
+     *
+     * @example
+     * ```ts
+     * const seconds = await augustSdk.evm.lagDuration({ vault });
+     * ```
+     */
+    async lagDuration(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.lagDuration)(signer, options);
+    }
+    /**
+     * Read an EVM-2 vault's current withdrawal epoch by named field
+     * (`year`/`month`/`day`/`claimableEpoch`).
+     *
+     * @returns {@link IWithdrawalEpoch}.
+     *
+     * @example
+     * ```ts
+     * const epoch = await augustSdk.evm.getWithdrawalEpoch({ vault });
+     * ```
+     */
+    async getWithdrawalEpoch(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.getWithdrawalEpoch)(signer, options);
+    }
+    /**
+     * Read how much of a withdrawal-epoch date's queue a receiver can
+     * currently claim, before calling {@link EVMAdapter.claimWithdrawal}.
+     *
+     * @returns Claimable amount as a raw `bigint`.
+     *
+     * @example
+     * ```ts
+     * const claimable = await augustSdk.evm.getBurnableAmountByReceiver({
+     *   vault, receiver, year, month, day,
+     * });
+     * ```
+     */
+    async getBurnableAmountByReceiver(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.getBurnableAmountByReceiver)(signer, options);
+    }
+    /**
+     * Read the total shares required to settle a withdrawal-epoch date's
+     * entire queue.
+     *
+     * @returns Required shares as a raw `bigint`.
+     *
+     * @example
+     * ```ts
+     * const shares = await augustSdk.evm.getRequirementByDate({ vault, year, month, day });
+     * ```
+     */
+    async getRequirementByDate(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.getRequirementByDate)(signer, options);
+    }
+    /**
+     * Read the scheduled queued-withdrawal volume for a withdrawal-epoch date.
+     *
+     * @returns {@link IScheduledTransactionsByDate}.
+     *
+     * @example
+     * ```ts
+     * const { totalTransactions, executionEpoch } =
+     *   await augustSdk.evm.getScheduledTransactionsByDate({ vault, year, month, day });
+     * ```
+     */
+    async getScheduledTransactionsByDate(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.getScheduledTransactionsByDate)(signer, options);
+    }
 }
 exports.default = EVMAdapter;
 //# sourceMappingURL=index.js.map

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

@@ -8,7 +8,7 @@ import * as SolanaGetters from './getters';
 import * as SolanaActions from './vault.actions';
 import type { AnchorProvider, web3 } from '@coral-xyz/anchor';
 import { type Commitment, Connection, PublicKey, type Transaction } from '@solana/web3.js';
-import type { ISolanaNetwork, ISolanaRpcEndpoint } from './types';
+import type { ISolanaDepositOptions, ISolanaNetwork, ISolanaRedeemOptions, ISolanaRpcEndpoint } from './types';
 import type { SendTransactionOptions } from '@solana/wallet-adapter-base';
 export declare const Solana: {
     utils: {
@@ -228,7 +228,7 @@ declare class SolanaAdapter {
     /**
      * Deposit funds into a Solana August vault.
      * @param depositAmount  `bigint` (raw on-chain units) or `number` (UI amount).
-     * @param sendTransaction - **Ignored; scheduled for removal (AUGUST-7221).**
+     * @param sendTransaction - **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.
@@ -237,12 +237,15 @@ declare class SolanaAdapter {
      *   `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.
+     * @param options - 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 {@link ISolanaDepositOptions}.
      */
-    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>;
+    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, options?: ISolanaDepositOptions): Promise<any>;
     /**
      * Redeem vault shares from a Solana August vault.
      * @param redeemShares  `bigint` (raw share units) or `number` (UI amount).
-     * @param sendTransaction - **Ignored; scheduled for removal (AUGUST-7221).**
+     * @param sendTransaction - **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.
@@ -251,8 +254,11 @@ declare class SolanaAdapter {
      *   `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.
+     * @param options - 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 {@link ISolanaRedeemOptions}.
      */
-    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>;
+    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, options?: ISolanaRedeemOptions): Promise<any>;
     /**
      * Canonical program id for a program type on this adapter's network.
      *
@@ -264,4 +270,5 @@ declare class SolanaAdapter {
      */
     getProgramId(type: 'vault'): string;
 }
+export type { ISolanaDepositOptions, ISolanaRedeemOptions } from './types';
 export default SolanaAdapter;

package/lib/adapters/solana/index.js

@@ -257,7 +257,7 @@ class SolanaAdapter {
     /**
      * Deposit funds into a Solana August vault.
      * @param depositAmount  `bigint` (raw on-chain units) or `number` (UI amount).
-     * @param sendTransaction - **Ignored; scheduled for removal (AUGUST-7221).**
+     * @param sendTransaction - **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.
@@ -266,8 +266,11 @@ class SolanaAdapter {
      *   `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.
+     * @param options - 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 {@link ISolanaDepositOptions}.
      */
-    async vaultDeposit(vaultProgramId, idl, publicKey, depositAmount, sendTransaction, vaultAddress) {
+    async vaultDeposit(vaultProgramId, idl, publicKey, depositAmount, sendTransaction, vaultAddress, options) {
         return await (0, vault_actions_1.handleSolanaDeposit)({
             network: this._network,
             provider: this._provider,
@@ -278,12 +281,13 @@ class SolanaAdapter {
             publicKey,
             depositAmount,
             sendTransaction,
+            options,
         });
     }
     /**
      * Redeem vault shares from a Solana August vault.
      * @param redeemShares  `bigint` (raw share units) or `number` (UI amount).
-     * @param sendTransaction - **Ignored; scheduled for removal (AUGUST-7221).**
+     * @param sendTransaction - **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.
@@ -292,8 +296,11 @@ class SolanaAdapter {
      *   `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.
+     * @param options - 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 {@link ISolanaRedeemOptions}.
      */
-    async vaultRedeem(vaultProgramId, idl, publicKey, redeemShares, sendTransaction, vaultAddress) {
+    async vaultRedeem(vaultProgramId, idl, publicKey, redeemShares, sendTransaction, vaultAddress, options) {
         return await (0, vault_actions_1.handleSolanaRedeem)({
             network: this._network,
             provider: this._provider,
@@ -304,6 +311,7 @@ class SolanaAdapter {
             publicKey,
             redeemShares,
             sendTransaction,
+            options,
         });
     }
     /**

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

@@ -0,0 +1,173 @@
+/**
+ * Off-chain mirror of the `august_vault` pricing math.
+ *
+ * Used to quote what a deposit or redeem is expected to return so a slippage
+ * floor can be handed to `deposit_checked` / `redeem_checked`. Mirrors
+ * `VaultState::shares_for_deposit_with_offset` and
+ * `assets_for_redeem_with_offset` (`programs/august-vault/src/state/vault.rs`):
+ * `u128` intermediates, a per-vault virtual-share offset defaulting to
+ * `EXTRA_SHARES = 1_000_000`, a pro-rata floor (deposit) or cap (redeem),
+ * every division rounded down; plus the withdrawal fee `redeem_checked` takes,
+ * `ceil(assets * fee / 1e6)` at `FEE_RATE_DENOMINATOR_VALUE = 1_000_000`.
+ *
+ * A quote is only a quote. The program prices at execution, against state
+ * that may have moved since the read; the floor derived here is what protects
+ * the caller when the two differ.
+ *
+ * This mirror cannot validate itself — agreeing with its own tests proves
+ * nothing about the program — so every claim below about program behaviour is
+ * cited to its handler in `fractal-protocol/solana-upshift-vault-programs`, by
+ * file and function rather than line. Verified against that repo at 3b91c86.
+ * Do not "fix" the math here against intuition; re-read the handler.
+ *
+ * Adapter-internal. These functions are exported for `vault.actions.ts` and
+ * the unit tests only — deliberately absent from the `adapters/solana` barrel,
+ * so they are not public SDK surface and carry no benchmark or telemetry
+ * taxonomy obligation. Promoting one to the barrel means taking both on.
+ *
+ * @packageDocumentation
+ */
+/** What the program uses when a vault stores `share_offset == 0` (vaults created before the field existed). */
+export declare const DEFAULT_SHARE_OFFSET = 1000000n;
+/** Slippage tolerance applied when a caller gives neither `slippageBps` nor an explicit floor. */
+export declare const DEFAULT_SLIPPAGE_BPS = 50;
+/**
+ * Coerce an on-chain integer as Anchor decodes it (`BN`, `number`, decimal
+ * string, or `bigint`) to `bigint`.
+ *
+ * @param value - The decoded field.
+ * @param label - Named in the error when the value is not a non-negative integer.
+ * @throws AugustSDKError when the value cannot be read as a non-negative integer.
+ */
+export declare function toBigInt(value: unknown, label: string): bigint;
+/**
+ * The vault's effective share offset. A stored zero (or a state decoded from
+ * an IDL that predates the field) resolves to the program default, exactly as
+ * `VaultState::share_offset()` does on-chain.
+ *
+ * @param raw - `VaultState.shareOffset` as decoded, or `undefined`.
+ */
+export declare function resolveShareOffset(raw: unknown): bigint;
+/**
+ * `localAum + deployedAum`, the `total_assets()` the program prices against.
+ *
+ * @param state - Decoded `VaultState`.
+ * @throws AugustSDKError when either field is missing, which means the state
+ *   was decoded with an IDL this SDK cannot price against.
+ */
+export declare function totalAssetsOf(state: {
+    localAum?: unknown;
+    deployedAum?: unknown;
+}): bigint;
+/**
+ * Shares minted for depositing `amount` base units.
+ *
+ * `floor(max(amount * (supply + offset) / (totalAssets + offset), amount * supply / totalAssets))`.
+ * Above par the offset term is the larger and binds; below par the pro-rata
+ * floor binds so a depositor never hands value to incumbents on arrival.
+ *
+ * @param input - Share supply, total assets and the vault's resolved offset,
+ *   all in raw base units.
+ * @throws AugustValidationError when the vault has no share price.
+ */
+export declare function sharesForDeposit(input: {
+    supply: bigint;
+    totalAssets: bigint;
+    amount: bigint;
+    offset: bigint;
+}): bigint;
+/**
+ * Assets paid, before the withdrawal fee, for burning `shares`.
+ *
+ * `floor(min(shares * (totalAssets + offset) / (supply + offset), shares * totalAssets / supply))`.
+ * The mirror of {@link sharesForDeposit}: above par the offset term binds,
+ * below par the pro-rata cap does, so no redeemer takes more than its share.
+ *
+ * @param input - Share supply, total assets and the vault's resolved offset,
+ *   all in raw base units.
+ * @throws AugustValidationError when the vault has no share price.
+ */
+export declare function assetsForRedeem(input: {
+    supply: bigint;
+    totalAssets: bigint;
+    shares: bigint;
+    offset: bigint;
+}): bigint;
+/**
+ * The withdrawal fee the program takes from a gross redemption:
+ * `ceil(assets * feePpm / 1e6)`, rounded **up** as on-chain.
+ *
+ * @param assets - Gross assets from {@link assetsForRedeem}.
+ * @param feePpm - `VaultState.withdrawalFee`, parts per million.
+ */
+export declare function withdrawalFee(assets: bigint, feePpm: bigint): bigint;
+/**
+ * Lower `expected` by `slippageBps` basis points, rounding down.
+ *
+ * @param expected - The quoted output in raw base units.
+ * @param slippageBps - Integer basis points, `0` to `10_000`.
+ * @throws AugustValidationError when `slippageBps` is out of range or not an integer.
+ */
+export declare function applySlippage(expected: bigint, slippageBps: number): bigint;
+/**
+ * The `min_shares_out` to pass to `deposit_checked`: the quoted shares for
+ * `amount`, lowered by `slippageBps`.
+ *
+ * Nothing is netted out, because there is no deposit-side fee. In
+ * `instructions/deposit.rs::handler_checked` the comparison is
+ * `require!(shares >= min_shares_out, SlippageExceeded)` directly on the
+ * `shares_for_deposit` result, with no fee term anywhere in the handler.
+ * Structurally too: `VaultState` carries exactly one fee field,
+ * `withdrawal_fee`, and `deposit_checked` takes no `fee_recipient_account`
+ * among its accounts (`redeem_checked` does), so it has no account to pay one
+ * to. Gross and net are the same quantity here.
+ *
+ * Quoting from state read *before* the transaction is correct despite the
+ * handler transferring the deposit in first: `transfer_in_ctx` moves SPL
+ * tokens into the vault ATA, but `total_assets()` sums the stored `local_aum`
+ * and `deployed_aum` fields, and `local_aum` is incremented only *after*
+ * `shares_for_deposit` has been computed. Supply is likewise read before the
+ * mint. The handler prices against the same pre-deposit figures this quote
+ * does.
+ *
+ * @param input - Vault state, deposit amount and tolerance.
+ */
+export declare function quoteDepositFloor(input: {
+    supply: bigint;
+    totalAssets: bigint;
+    amount: bigint;
+    offset: bigint;
+    slippageBps: number;
+}): bigint;
+/**
+ * The `min_assets_out` to pass to `redeem_checked`: the quoted payout for
+ * `shares` **net of the withdrawal fee** — which is what `redeem_checked`
+ * compares against — lowered by `slippageBps`.
+ *
+ * Net rather than gross is the hinge of the whole guarantee, so it is pinned
+ * here rather than left to be re-derived. In
+ * `instructions/redeem.rs::handler_checked` the program computes the gross
+ * `assets`, subtracts `fees` — the `ceil_div` of `assets * withdrawal_fee`
+ * over `FEE_RATE_DENOMINATOR_VALUE` — and compares `min_assets_out` against
+ * that difference, which is the figure the caller actually receives.
+ * `Redeem::ceil_div` is `(n + d - 1) / d`, which is what
+ * {@link withdrawalFee} reproduces.
+ *
+ * Getting this wrong fails quietly in the dangerous direction. Quote against
+ * the gross payout and the floor sits a whole fee above what the program
+ * measures, so it binds early and reverts healthy redemptions. Net it twice —
+ * or drop the fee from a vault that charges one — and the floor sits below the
+ * real payout by the fee, leaving protection weaker than the advertised
+ * `slippageBps` instead of visibly broken. `withdrawal_fee` is capped just
+ * under 10% (`set_withdrawal_fee`), which bounds that silent gap.
+ *
+ * @param input - Vault state, shares to burn, fee and tolerance.
+ */
+export declare function quoteRedeemFloor(input: {
+    supply: bigint;
+    totalAssets: bigint;
+    shares: bigint;
+    offset: bigint;
+    feePpm: bigint;
+    slippageBps: number;
+}): bigint;