@upshiftfinance/sdk 0.0.0-stage → 0.1.0

package/lib/adapters/solana/index.js

@@ -0,0 +1,459 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Solana = void 0;
+/**
+ * Solana Adapter for Upshift SDK
+ *
+ * @module SolanaAdapter
+ */
+const SolanaConstants = __importStar(require("./constants"));
+const SolanaGetters = __importStar(require("./getters"));
+const SolanaActions = __importStar(require("./vault.actions"));
+const web3_js_1 = require("@solana/web3.js");
+const utils_1 = require("./utils");
+const vault_actions_1 = require("./vault.actions");
+const queue_actions_1 = require("./queue.actions");
+const constants_1 = require("./constants");
+const core_1 = require("../../core");
+exports.Solana = {
+    utils: utils_1.SolanaUtils,
+    constants: SolanaConstants,
+    actions: SolanaActions,
+    getters: SolanaGetters,
+};
+/**
+ * Solana Adapter for Upshift SDK
+ *
+ * @example
+ * To access the Solana adapter instance
+ * ```
+ * const sdk = new UpshiftSDK()
+ * sdk.solana.getVaultState()
+ * ```
+ */
+class SolanaAdapter {
+    _endpoint;
+    _network;
+    _connection;
+    _provider;
+    /**
+     * @param commitment - 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 `UpshiftSDK`.
+     */
+    constructor(endpoint, network = utils_1.SolanaUtils.fallbackNetwork, commitment = 'finalized') {
+        this._endpoint = endpoint;
+        this._network = network;
+        // Explicit rather than inherited: left unset, web3.js omits the parameter
+        // and the RPC applies its own default, which is the same 'finalized' —
+        // but then nothing ties it to the commitment writes confirm at.
+        const connection = new web3_js_1.Connection(endpoint, commitment);
+        this._connection = connection;
+        this._provider = utils_1.SolanaUtils.getReadOnlyProvider({
+            network: this._network,
+            connection,
+        });
+    }
+    // Getters and setters for private properties
+    get endpoint() {
+        return this._endpoint;
+    }
+    get network() {
+        return this._network;
+    }
+    get connection() {
+        return this._connection;
+    }
+    get provider() {
+        return this._provider;
+    }
+    // Method to set connection with wallet for authenticated operations
+    setWalletProvider(_publicKey, signTransaction) {
+        if (_publicKey && signTransaction) {
+            const publicKey = typeof _publicKey === 'string' ? new web3_js_1.PublicKey(_publicKey) : _publicKey;
+            this._provider = utils_1.SolanaUtils.getProvider({
+                network: this._network,
+                connection: this._connection,
+                publicKey,
+                signTransaction,
+            });
+        }
+        else {
+            this._provider = utils_1.SolanaUtils.getReadOnlyProvider({
+                network: this._network,
+                connection: this._connection,
+            });
+        }
+    }
+    /**
+     * Build an Anchor `Program` bound to this adapter's provider and network.
+     *
+     * The program id is resolved as: explicit `programId` → the `address` carried
+     * by a custom `programIdl` → the canonical deployment for this adapter's
+     * network. A copy of the SDK's bundled `vaultIdl` defers to the network
+     * default (its embedded `address` is a build stamp, not network-aware), so
+     * forwarding it on devnet never silently targets the mainnet program.
+     *
+     * An IDL whose `metadata.name` is `august_withdrawal_queue` resolves against
+     * the withdrawal queue program's network default instead of the vault's.
+     *
+     * @param programIdl - Anchor IDL to bind. Defaults to the SDK's bundled
+     *   `august_vault` IDL. A custom IDL's `address` is honoured when it differs
+     *   from the program's canonical id (the build stamp every bundled copy of
+     *   the vault or queue IDL carries).
+     * @param programId - Base58 program id that overrides both the IDL's address
+     *   and the network default. Use this to target a non-canonical deployment.
+     * @returns An Anchor `Program` for the resolved program id. No RPC is made —
+     *   construction is offline.
+     * @throws {@link UpshiftValidationError} if no program id can be resolved
+     *   because the program has no canonical deployment on this adapter's network
+     *   (neither program on `testnet`) and neither `programId` nor a custom IDL
+     *   address was supplied.
+     *
+     * @example
+     * ```ts
+     * // canonical program on the adapter's network
+     * const program = sdk.solana.getProgram();
+     *
+     * // a different deployment, same interface
+     * const legacy = sdk.solana.getProgram(vaultIdl, '7B8n9vL51b6ibqRAd1adZsi3x3kxtq5NZaondh22Vkyq');
+     * ```
+     */
+    getProgram(programIdl, programId) {
+        return utils_1.SolanaUtils.getProgram({
+            network: this._network,
+            provider: this._provider,
+            idl: programIdl,
+            programId,
+        });
+    }
+    async getVaultState(vaultProgramId, idl, vaultAddress) {
+        return await utils_1.SolanaUtils.getVaultState({
+            network: this._network,
+            provider: this._provider,
+            connection: this._connection,
+            vaultProgramId,
+            vaultAddress,
+            idl,
+        });
+    }
+    async getVaultStateReadOnly(vaultProgramId, idl, vaultAddress) {
+        return await utils_1.SolanaUtils.getVaultStateReadOnly({
+            network: this._network,
+            connection: this._connection,
+            vaultProgramId,
+            vaultAddress,
+            idl,
+        });
+    }
+    async getToken(mintAddress) {
+        return await utils_1.SolanaUtils.getToken({
+            network: this._network,
+            mintAddress,
+            endpoint: this._endpoint,
+        });
+    }
+    async getTokenSymbol(mintAddress) {
+        return await utils_1.SolanaUtils.getTokenSymbol({
+            network: this._network,
+            mintAddress,
+            endpoint: this._endpoint,
+        });
+    }
+    async fetchUserTokenBalance(publicKey, depositMint) {
+        return await utils_1.SolanaUtils.fetchUserTokenBalance({
+            network: this._network,
+            connection: this._connection,
+            publicKey,
+            depositMint,
+        });
+    }
+    async fetchUserShareBalance(publicKey, shareMint) {
+        return await utils_1.SolanaUtils.fetchUserShareBalance({
+            network: this._network,
+            connection: this._connection,
+            publicKey,
+            shareMint,
+        });
+    }
+    /**
+     * BigInt-safe variant of {@link fetchUserShareBalance}. Returns the raw u64
+     * `amount` (as a base-units string) plus the mint's `decimals` (or `null`
+     * when the scale can't be determined — see Returns), so the caller can
+     * produce a correct `INormalizedNumber` without losing precision.
+     *
+     * Prefer this anywhere the result feeds BigInt math — positions, max-
+     * actions, redemption sizing, allowance checks. `fetchUserShareBalance`
+     * returns a JS-number `uiAmount` which silently encodes against 18 decimals
+     * when passed through `toNormalizedBn(value)` without an explicit decimals
+     * argument; that's exactly how the jitoSOL "missing position" regression
+     * manifested.
+     *
+     * RPC cost: 1 `getParsedTokenAccountsByOwner` call. Worst case ~150ms on a
+     * healthy mainnet endpoint.
+     *
+     * @param publicKey   Wallet owner (PublicKey or base58 string).
+     * @param shareMint   The vault's share-token mint (PublicKey or base58).
+     * @returns
+     *   `{ amount, decimals }`. Three observable shapes:
+     *   - `{ amount: '<u64>', decimals: <number> }` — token account exists.
+     *   - `{ amount: '0', decimals: null }` — no token account for this mint
+     *     under this wallet, OR `tokenAmount` was missing from the response,
+     *     OR `publicKey`/`shareMint` was not supplied. Distinguishable from a
+     *     genuine zero-balance account (`decimals` would be set there).
+     *   - `{ amount: '0', decimals: null }` — RPC threw (error is logged).
+     *
+     *   `decimals === null` means "we could not determine the scale" — callers
+     *   that need an `INormalizedNumber` must fall back to a known decimals
+     *   value (typically the deposit mint's decimals from backend metadata)
+     *   before normalizing. Never throws.
+     */
+    async fetchUserShareBalanceRaw(publicKey, shareMint) {
+        return await utils_1.SolanaUtils.fetchUserShareBalanceRaw({
+            network: this._network,
+            connection: this._connection,
+            publicKey,
+            shareMint,
+        });
+    }
+    /**
+     * Deposit funds into a Solana Upshift vault.
+     * @param depositAmount  `bigint` (raw on-chain units) or `number` (UI amount).
+     * @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.
+     *
+     *   **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.
+     * @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, options) {
+        return await (0, vault_actions_1.handleSolanaDeposit)({
+            network: this._network,
+            provider: this._provider,
+            connection: this._connection,
+            vaultProgramId,
+            vaultAddress,
+            idl,
+            publicKey,
+            depositAmount,
+            sendTransaction,
+            options,
+        });
+    }
+    /**
+     * Redeem vault shares from a Solana Upshift vault.
+     * @param redeemShares  `bigint` (raw share units) or `number` (UI amount).
+     * @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.
+     *
+     *   **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.
+     * @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}.
+     *
+     *   **On a vault with a withdrawal queue**, holders cannot redeem directly:
+     *   request with {@link SolanaAdapter.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 The confirmed transaction's signature.
+     * @throws {@link UpshiftValidationError} 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,
+     * });
+     * ```
+     */
+    async vaultRedeem(vaultProgramId, idl, publicKey, redeemShares, sendTransaction, vaultAddress, options) {
+        if (options?.request !== undefined) {
+            if (options.slippageBps !== undefined ||
+                options.minAssetsOut !== undefined) {
+                throw new core_1.UpshiftValidationError('INVALID_INPUT', 'vaultRedeem: a withdrawal-queue claim is held to the floor set when the request was made, not one passed here; leave `slippageBps` and `minAssetsOut` unset when passing `request`.');
+            }
+            return await (0, queue_actions_1.handleSolanaClaimRedeem)({
+                provider: this._provider,
+                connection: this._connection,
+                vaultProgramId: new web3_js_1.PublicKey(vaultProgramId),
+                queueProgramId: new web3_js_1.PublicKey(this.getProgramId('withdrawalQueue')),
+                wallet: publicKey,
+                request: options.request,
+            });
+        }
+        return await (0, vault_actions_1.handleSolanaRedeem)({
+            network: this._network,
+            provider: this._provider,
+            connection: this._connection,
+            vaultProgramId,
+            vaultAddress,
+            idl,
+            publicKey,
+            redeemShares,
+            sendTransaction,
+            options,
+        });
+    }
+    /**
+     * 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 {@link SolanaAdapter.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
+     * {@link SolanaAdapter.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.
+     *
+     * @param params - Vault, wallet, shares, and optional recipient, finalizer,
+     *   request id and floor. See {@link ISolanaRequestRedeemParams}.
+     * @returns The signature, the request's address (pass it as `request` to
+     *   claim or cancel) and its id.
+     * @throws {@link UpshiftValidationError} for bad input, a vault without an
+     *   attached queue, a frozen account or too few shares, before signing.
+     * @throws {@link UpshiftSDKError} 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 });
+     * ```
+     */
+    async vaultRequestRedeem(params) {
+        return await (0, queue_actions_1.handleSolanaRequestRedeem)({
+            provider: this._provider,
+            connection: this._connection,
+            queueProgramId: new web3_js_1.PublicKey(this.getProgramId('withdrawalQueue')),
+            params,
+        });
+    }
+    /**
+     * 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.
+     *
+     * @param params - The holder and the request address. See
+     *   {@link ISolanaCancelRedeemRequestParams}.
+     * @returns The confirmed transaction's signature.
+     * @throws {@link UpshiftValidationError} for a missing request, or one this
+     *   wallet did not make, before signing.
+     * @throws {@link UpshiftSDKError} when the transaction fails.
+     * @example
+     * ```ts
+     * await sdk.solana.vaultCancelRedeemRequest({ wallet: wallet.publicKey, request });
+     * ```
+     */
+    async vaultCancelRedeemRequest(params) {
+        return await (0, queue_actions_1.handleSolanaCancelRedeemRequest)({
+            provider: this._provider,
+            connection: this._connection,
+            queueProgramId: new web3_js_1.PublicKey(this.getProgramId('withdrawalQueue')),
+            params,
+        });
+    }
+    /**
+     * Canonical program id for a program type on this adapter's network.
+     *
+     * @param type - Program to look up: `'vault'` (august_vault) or
+     *   `'withdrawalQueue'` (august_withdrawal_queue).
+     * @returns The base58 program id.
+     * @throws {@link UpshiftValidationError} 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');
+     * ```
+     */
+    getProgramId(type) {
+        (0, utils_1.assertSolanaProgramType)(type);
+        const programId = (0, constants_1.getDeployedProgramIds)(this._network)?.[type];
+        if (!programId) {
+            throw new core_1.UpshiftValidationError('INVALID_INPUT', (0, utils_1.undeployedProgramMessage)(type, this._network));
+        }
+        return programId;
+    }
+}
+exports.default = SolanaAdapter;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,184 @@
+/**
+ * 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 UpshiftSDKError 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 UpshiftSDKError 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;
+/**
+ * Whether the vault has a share price. Mirrors `SharePriceUndefined`:
+ * outstanding shares against no assets has no price in either direction.
+ */
+export declare function hasSharePrice(supply: bigint, totalAssets: bigint): boolean;
+/**
+ * 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 UpshiftValidationError 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 UpshiftValidationError 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;
+/**
+ * Refuse a `slippageBps` that is not an integer in `0 .. 10_000`.
+ *
+ * @throws UpshiftValidationError when it is out of range or not an integer.
+ */
+export declare function validateSlippageBps(slippageBps: number): void;
+/**
+ * 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 UpshiftValidationError 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;