@augustdigital/sdk 9.10.1 → 9.12.0

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 { ISolanaDepositOptions, ISolanaNetwork, ISolanaRedeemOptions, ISolanaRpcEndpoint } from './types';
+import type { ISolanaCancelRedeemRequestParams, ISolanaDepositOptions, ISolanaNetwork, ISolanaRedeemOptions, ISolanaRequestRedeemParams, ISolanaRpcEndpoint } from './types';
 import type { SendTransactionOptions } from '@solana/wallet-adapter-base';
 export declare const Solana: {
     utils: {
@@ -79,12 +79,14 @@ export declare const Solana: {
         programIds: {
             devnet: {
                 vault: string;
+                withdrawalQueue: string;
             };
             "mainnet-beta": {
                 vault: string;
             };
             localnet: {
                 vault: string;
+                withdrawalQueue: string;
             };
         };
         getVaultMints: ({ vaultProgramId, vaultAddress, connection, idl, }: {
@@ -150,16 +152,22 @@ declare class SolanaAdapter {
      * 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 bundled build stamp.
+     *   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 AugustValidationError} if no program id can be resolved
-     *   because this adapter's network has no canonical deployment (e.g.
-     *   `testnet`) and neither `programId` nor a custom IDL address was supplied.
+     *   because the program has no canonical deployment on this adapter's network
+     *   (neither program on `testnet`; the withdrawal queue not yet on
+     *   `mainnet-beta`) and neither `programId` nor a custom IDL address was
+     *   supplied.
      *
      * @example
      * ```ts
@@ -257,18 +265,108 @@ declare class SolanaAdapter {
      * @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 AugustValidationError} for bad input, for a queued vault
+     *   without `options.request`, or for a request the wallet cannot claim yet.
+     * @example
+     * ```ts
+     * // A vault with a withdrawal queue: claim a ready request.
+     * const { pendingRedemptions } = await sdk.getVaultAvailableRedemptions({ vault, wallet });
+     * await sdk.solana.vaultRedeem(programId, vaultIdl, wallet, 0n, undefined, undefined, {
+     *   request: pendingRedemptions[0].id,
+     * });
+     * ```
      */
     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>;
+    /**
+     * 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 AugustValidationError} for bad input, a vault without an
+     *   attached queue, a frozen account or too few shares, before signing.
+     * @throws {@link AugustSDKError} when the transaction fails.
+     * @example
+     * ```ts
+     * const { request } = await sdk.solana.vaultRequestRedeem({
+     *   vault: vaultStateAddress,
+     *   wallet: wallet.publicKey,
+     *   amount: 10, // shares, UI units
+     * });
+     * // ...once the cooldown has run:
+     * await sdk.solana.vaultRedeem(programId, vaultIdl, wallet.publicKey, 0n, undefined, undefined, { request });
+     * ```
+     */
+    vaultRequestRedeem(params: ISolanaRequestRedeemParams): Promise<import("./types").ISolanaRequestRedeemResult>;
+    /**
+     * 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 AugustValidationError} for a missing request, or one this
+     *   wallet did not make, before signing.
+     * @throws {@link AugustSDKError} when the transaction fails.
+     * @example
+     * ```ts
+     * await sdk.solana.vaultCancelRedeemRequest({ wallet: wallet.publicKey, request });
+     * ```
+     */
+    vaultCancelRedeemRequest(params: ISolanaCancelRedeemRequestParams): Promise<string>;
     /**
      * Canonical program id for a program type on this adapter's network.
      *
-     * @param type - Program to look up. Only `'vault'` (august_vault) exists today.
+     * @param type - Program to look up: `'vault'` (august_vault) or
+     *   `'withdrawalQueue'` (august_withdrawal_queue).
      * @returns The base58 program id.
-     * @throws {@link AugustValidationError} if the canonical program is not
-     *   deployed on this adapter's network (e.g. `testnet`). Previously an
-     *   unmapped network threw a bare `TypeError`.
+     * @throws {@link AugustValidationError} if `type` is not one of the two
+     *   program types, or the program is not deployed on this adapter's network:
+     *   neither program on `testnet`, and `'withdrawalQueue'` not yet on
+     *   `mainnet-beta`.
+     * @example
+     * ```ts
+     * const queueProgram = adapter.getProgramId('withdrawalQueue');
+     * ```
      */
-    getProgramId(type: 'vault'): string;
+    getProgramId(type: 'vault' | 'withdrawalQueue'): string;
 }
-export type { ISolanaDepositOptions, ISolanaRedeemOptions } from './types';
+export type { ISolanaCancelRedeemRequestParams, ISolanaDepositOptions, ISolanaRedeemOptions, ISolanaRequestRedeemParams, ISolanaRequestRedeemResult, } from './types';
 export default SolanaAdapter;

package/lib/adapters/solana/index.js

@@ -45,6 +45,7 @@ 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 = {
@@ -137,16 +138,22 @@ class SolanaAdapter {
      * 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 bundled build stamp.
+     *   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 AugustValidationError} if no program id can be resolved
-     *   because this adapter's network has no canonical deployment (e.g.
-     *   `testnet`) and neither `programId` nor a custom IDL address was supplied.
+     *   because the program has no canonical deployment on this adapter's network
+     *   (neither program on `testnet`; the withdrawal queue not yet on
+     *   `mainnet-beta`) and neither `programId` nor a custom IDL address was
+     *   supplied.
      *
      * @example
      * ```ts
@@ -299,8 +306,42 @@ class SolanaAdapter {
      * @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 AugustValidationError} for bad input, for a queued vault
+     *   without `options.request`, or for a request the wallet cannot claim yet.
+     * @example
+     * ```ts
+     * // A vault with a withdrawal queue: claim a ready request.
+     * const { pendingRedemptions } = await sdk.getVaultAvailableRedemptions({ vault, wallet });
+     * await sdk.solana.vaultRedeem(programId, vaultIdl, wallet, 0n, undefined, undefined, {
+     *   request: pendingRedemptions[0].id,
+     * });
+     * ```
      */
     async vaultRedeem(vaultProgramId, idl, publicKey, redeemShares, sendTransaction, vaultAddress, options) {
+        if (options?.request !== undefined) {
+            if (options.slippageBps !== undefined ||
+                options.minAssetsOut !== undefined) {
+                throw new core_1.AugustValidationError('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,
@@ -314,22 +355,106 @@ class SolanaAdapter {
             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 AugustValidationError} for bad input, a vault without an
+     *   attached queue, a frozen account or too few shares, before signing.
+     * @throws {@link AugustSDKError} when the transaction fails.
+     * @example
+     * ```ts
+     * const { request } = await sdk.solana.vaultRequestRedeem({
+     *   vault: vaultStateAddress,
+     *   wallet: wallet.publicKey,
+     *   amount: 10, // shares, UI units
+     * });
+     * // ...once the cooldown has run:
+     * await sdk.solana.vaultRedeem(programId, vaultIdl, wallet.publicKey, 0n, undefined, undefined, { request });
+     * ```
+     */
+    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 AugustValidationError} for a missing request, or one this
+     *   wallet did not make, before signing.
+     * @throws {@link AugustSDKError} 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. Only `'vault'` (august_vault) exists today.
+     * @param type - Program to look up: `'vault'` (august_vault) or
+     *   `'withdrawalQueue'` (august_withdrawal_queue).
      * @returns The base58 program id.
-     * @throws {@link AugustValidationError} if the canonical program is not
-     *   deployed on this adapter's network (e.g. `testnet`). Previously an
-     *   unmapped network threw a bare `TypeError`.
+     * @throws {@link AugustValidationError} if `type` is not one of the two
+     *   program types, or the program is not deployed on this adapter's network:
+     *   neither program on `testnet`, and `'withdrawalQueue'` not yet on
+     *   `mainnet-beta`.
+     * @example
+     * ```ts
+     * const queueProgram = adapter.getProgramId('withdrawalQueue');
+     * ```
      */
     getProgramId(type) {
-        const deployment = (0, constants_1.getDeployedProgramIds)(this._network);
-        if (!deployment) {
-            throw new core_1.AugustValidationError('INVALID_INPUT', `No canonical august_vault deployment for Solana network '${this._network}'. ` +
-                `Deployed networks: ${Object.keys(constants_1.programIds).join(', ')}.`);
+        (0, utils_1.assertSolanaProgramType)(type);
+        const programId = (0, constants_1.getDeployedProgramIds)(this._network)?.[type];
+        if (!programId) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', (0, utils_1.undeployedProgramMessage)(type, this._network));
         }
-        return deployment[type];
+        return programId;
     }
 }
 exports.default = SolanaAdapter;

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

@@ -59,6 +59,11 @@ 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.
  *
@@ -101,6 +106,12 @@ export declare function assetsForRedeem(input: {
  * @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 AugustValidationError 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.
  *

package/lib/adapters/solana/pricing.js

@@ -33,9 +33,11 @@ exports.DEFAULT_SLIPPAGE_BPS = exports.DEFAULT_SHARE_OFFSET = void 0;
 exports.toBigInt = toBigInt;
 exports.resolveShareOffset = resolveShareOffset;
 exports.totalAssetsOf = totalAssetsOf;
+exports.hasSharePrice = hasSharePrice;
 exports.sharesForDeposit = sharesForDeposit;
 exports.assetsForRedeem = assetsForRedeem;
 exports.withdrawalFee = withdrawalFee;
+exports.validateSlippageBps = validateSlippageBps;
 exports.applySlippage = applySlippage;
 exports.quoteDepositFloor = quoteDepositFloor;
 exports.quoteRedeemFloor = quoteRedeemFloor;
@@ -93,10 +95,16 @@ function totalAssetsOf(state) {
     return (toBigInt(state.localAum, 'localAum') +
         toBigInt(state.deployedAum, 'deployedAum'));
 }
+/**
+ * Whether the vault has a share price. Mirrors `SharePriceUndefined`:
+ * outstanding shares against no assets has no price in either direction.
+ */
+function hasSharePrice(supply, totalAssets) {
+    return totalAssets !== 0n || supply === 0n;
+}
 function requireSharePrice(supply, totalAssets) {
-    // Mirrors `SharePriceUndefined`: outstanding shares against no assets has no
-    // price in either direction, and the program would refuse the instruction.
-    if (totalAssets === 0n && supply > 0n) {
+    // The program would refuse the instruction.
+    if (!hasSharePrice(supply, totalAssets)) {
         throw new core_1.AugustValidationError('INVALID_INPUT', 'This vault holds no assets while shares are outstanding, so it has no share price; deposits and redemptions are refused until the operator recapitalises it.');
     }
 }
@@ -151,18 +159,26 @@ function withdrawalFee(assets, feePpm) {
     return (assets * feePpm + FEE_RATE_DENOMINATOR - 1n) / FEE_RATE_DENOMINATOR;
 }
 /**
- * Lower `expected` by `slippageBps` basis points, rounding down.
+ * Refuse a `slippageBps` that is not an integer in `0 .. 10_000`.
  *
- * @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.
+ * @throws AugustValidationError when it is out of range or not an integer.
  */
-function applySlippage(expected, slippageBps) {
+function validateSlippageBps(slippageBps) {
     if (!Number.isInteger(slippageBps) ||
         slippageBps < 0 ||
         slippageBps > Number(BPS_DENOMINATOR)) {
         throw new core_1.AugustValidationError('INVALID_INPUT', `slippageBps must be an integer between 0 and 10000, got ${slippageBps}.`);
     }
+}
+/**
+ * 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.
+ */
+function applySlippage(expected, slippageBps) {
+    validateSlippageBps(slippageBps);
     return (expected * (BPS_DENOMINATOR - BigInt(slippageBps))) / BPS_DENOMINATOR;
 }
 /**

package/lib/adapters/solana/queue.actions.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Write paths for the august_withdrawal_queue program: request a withdrawal,
+ * claim (finalize) a ready one, cancel a pending one.
+ *
+ * Built like the vault's deposit and redeem handlers (`vault.actions.ts`):
+ * every check the SDK can make runs before the wallet is asked to sign, every
+ * account the transaction needs is created inside it with an idempotent
+ * instruction, and failures surface as `AugustValidationError` (bad input or
+ * state the caller can fix) or `AugustSDKError` (the transaction failed, with
+ * the program's reason and the numeric code).
+ */
+import { type AnchorProvider } from '@coral-xyz/anchor';
+import { type Connection, PublicKey } from '@solana/web3.js';
+import type { ISolanaCancelRedeemRequestParams, ISolanaRequestRedeemParams, ISolanaRequestRedeemResult } from './types';
+/** The sentence to append for a queue error the caller can act on, else empty. */
+export declare function queueHint(e: unknown): string;
+/** The request PDA: `["withdrawal_request", queue, owner, request_id as u64 LE]`. */
+export declare function deriveWithdrawalRequestPda(queue: PublicKey, owner: PublicKey, requestId: bigint, queueProgramId: PublicKey): PublicKey;
+/**
+ * Escrow shares in a withdrawal request on a vault with a queue attached.
+ *
+ * Reads the vault state and queue in one call, checks the gate points at the
+ * queue, and submits `request_withdrawal` from the holder's share account. The
+ * recipient's deposit-token account is created in the same transaction when it
+ * has none. Unless `minAssetsOut` is given, the request's floor is the current
+ * net quote lowered by `slippageBps`, the floor `vaultRedeem` would use.
+ *
+ * RPC: one `getMultipleAccountsInfo` (vault state and queue), one
+ * `getAccountInfo` for the share mint (decimals for a UI `amount`, supply for
+ * the default floor) unless `amount` is raw and `minAssetsOut` is given, one
+ * `getParsedTokenAccountsByOwner` for the share account, and one more read for
+ * the payout account (the holder's, or another recipient's ATA, which may be
+ * off-curve), then the send.
+ *
+ * @returns The signature, the new request's address and its id.
+ * @throws AugustValidationError for bad input, a vault without an attached
+ *   queue, a frozen account or too few shares, all before signing.
+ * @throws AugustSDKError when the transaction fails.
+ */
+export declare function handleSolanaRequestRedeem({ provider, connection, queueProgramId, params, }: {
+    provider: AnchorProvider;
+    connection: Connection;
+    queueProgramId: PublicKey;
+    params: ISolanaRequestRedeemParams;
+}): Promise<ISolanaRequestRedeemResult>;
+/**
+ * Claim a request whose cooldown has run: `finalize_withdrawal`, which redeems
+ * the escrowed shares through the vault and pays the request's recipient.
+ *
+ * Anyone the request permits may claim it: the holder always, and anyone else
+ * unless it names a finalizer, in which case only that key. It is refused here,
+ * before signing, when the caller is not permitted, the cooldown has not run,
+ * or the window has closed; the wall clock stands in for the chain's, so at the
+ * boundary the program may still disagree by a slot. The vault's fee-recipient
+ * account is created in the same transaction when it has none, and so is the
+ * request's payout account when it is the holder's own ATA and has been closed
+ * since; any other closed or a frozen payout account is refused before
+ * signing, since the claim could only fail.
+ *
+ * RPC: three reads in turn, each address coming from the account before it
+ * (the request, its queue, then the queue's vault together with the payout
+ * account), then the send.
+ *
+ * @throws AugustValidationError for a missing request or one the caller cannot
+ *   claim yet, before signing.
+ * @throws AugustSDKError when the transaction fails, e.g. `NotEnoughLiquidity`
+ *   while the vault's reserve is deployed; the request stays pending.
+ */
+export declare function handleSolanaClaimRedeem({ provider, connection, vaultProgramId, queueProgramId, wallet, request: requestAddress, nowSeconds, }: {
+    provider: AnchorProvider;
+    connection: Connection;
+    vaultProgramId: PublicKey;
+    queueProgramId: PublicKey;
+    wallet: PublicKey | string;
+    request: PublicKey | string;
+    /** Unix seconds to check eligibility against; defaults to now. */
+    nowSeconds?: number;
+}): Promise<string>;
+/**
+ * Cancel a pending request: `cancel_withdrawal` returns its shares to the
+ * holder's share account (created in the same transaction when they closed
+ * theirs) and closes the request, refunding its rent. Allowed at any time
+ * while the request exists, cooldown or not, expired or not, paused or not.
+ *
+ * RPC: two reads in turn (the request, then its queue), one
+ * `getParsedTokenAccountsByOwner`, then the send.
+ *
+ * @returns The confirmed transaction's signature.
+ * @throws AugustValidationError for a missing request or one `wallet` did not
+ *   make, before signing.
+ * @throws AugustSDKError when the transaction fails.
+ */
+export declare function handleSolanaCancelRedeemRequest({ provider, connection, queueProgramId, params, }: {
+    provider: AnchorProvider;
+    connection: Connection;
+    queueProgramId: PublicKey;
+    params: ISolanaCancelRedeemRequestParams;
+}): Promise<string>;