@augustdigital/sdk 9.6.0 → 9.7.1

package/lib/sdk.d.ts

@@ -15209,15 +15209,10 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
    * Pure and synchronous — no RPC, no I/O — so it is safe to call inside the hot
    * path with no added latency.
    *
-   * Known imprecision — vault shares are transferable ERC-20 receipt tokens, so a
-   * wallet that *received* shares via a direct token transfer (never deposited,
-   * never withdrew) legitimately has `position > 0` with no history records and
-   * will throw `HISTORY_UNAVAILABLE` even though its history loaded fine. This is
-   * not a regression — the pre-guard formula reported that same position as 100%
-   * profit, which was also wrong — but the error message is misleading for that
-   * (rare) path. If receipt-token transfer becomes a real user flow, distinguish
-   * it here (e.g. by checking for a share-transfer event) rather than widening
-   * the guard.
+   * Shares received by a direct token transfer (never deposited, never withdrew)
+   * reach this guard as deposits: {@link getVaultUserLifetimePnl} prices them
+   * with {@link transferCostBasis} first. The guard still throws for such a
+   * wallet when its transfers cannot be read or priced.
    *
    * @param params - See {@link PnlHistoryConsistencyParams}.
    * @returns `void` when the history is consistent.
@@ -15323,9 +15318,10 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
          * token.
          *
          * Backed by `GET /risk/collateral_excess_or_deficit` (60-second server-side
-         * cache), which resolves the subaccount and reads its current health factor,
-         * so an authenticated (admin-scoped) August API key is required. Makes
-         * exactly one HTTP request and no RPC calls.
+         * cache), which resolves the subaccount and reads its current health factor.
+         * The backend serves this route to anonymous callers today, so no August API
+         * key is needed; pass one if you get `AUTH_UNAUTHORIZED`. Makes exactly one
+         * HTTP request and no RPC calls.
          *
          * @param params.subaccount Subaccount (smart-contract wallet) address.
          * @param params.tokenAddress Collateral token address to evaluate.
@@ -15355,9 +15351,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
          * This is a pure, read-only simulation: the backend `POST
          * /risk/collateral_simulation` endpoint (60-second server-side cache)
          * computes required collateral and effective discount factors and changes
-         * no state. It runs against the authenticated backend, so an
-         * (admin-scoped) August API key is required. Makes exactly one HTTP request
-         * and no RPC calls.
+         * no state. The route is public, so no August API key is needed. Makes
+         * exactly one HTTP request and no RPC calls.
          *
          * @param input Simulation parameters — see {@link ICollateralSimulationInput}. `collateral_tokens` and `collateral_token_allocation` must be non-empty and equal length; when `on_platform` is `true`, both `loan_redeployed_token_*` fields are required.
          * @returns The simulated {@link ICollateralSimulationResults}: total debt, required collateral, resulting health factor, and a per-token breakdown.
@@ -15882,6 +15877,7 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                    constructor({ appName, providers, keys, monitoring, analytics, versionCheck, timeoutMs, publicApiBaseUrl, attribution, }: IAugustBase);
                    /**
                     * Verify the configured August API key and mark this instance as authorized.
+                    * Only for SDKs built with `keys.august`; a keyless SDK skips `init()`.
                     * @throws Error when `keys.august` is missing or rejected by the API.
                     */
                    init(): Promise<void>;
@@ -16367,7 +16363,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                     * @param props - Vault address, wallet address, and optional chain ID
                     * @returns Lifetime PnL data including realized and unrealized PnL in both native token and USD
                     * @throws {@link AugustHistoryUnavailableError} (`HISTORY_UNAVAILABLE`) when a
-                        *   live position has no indexed deposits or withdrawals.
+                        *   live position has no indexed deposits, withdrawals or priceable share
+                        *   transfers.
                         * @throws {@link AugustPriceUnavailableError} (`PRICE_UNAVAILABLE`) when the
                             *   vault's underlying asset has no USD price — the USD fields are never
                             *   computed from a stand-in price.
@@ -16593,7 +16590,13 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                      * Subaccount operation class interacting with August Subaccounts
                      * Subaccount is a smart contract wallet that serves as the fundamental infrastructure for August's platform.
                      * It functions as a cross-margin account designed for optimal capital efficiency.
-                     * Most of the operations require a August API key to perform
+                     *
+                     * `getSubaccountSummary`, `getSubaccountHealthFactor`, `getSubaccountLoans`,
+                     * `getSubaccountCefiPositions` and `getSubaccountOtcPositions` work without an
+                     * August API key for subaccounts linked to a vault; `getSubaccountDebank` is
+                     * public. `getSubaccountTransactions` needs a key authorized for the
+                     * subaccount, and `getAllSubaccounts` and `getSubaccountLoanByAddress` need an
+                     * admin key.
                      */
                     export declare class AugustSubAccounts extends AugustBase {
                         private headers;
@@ -17074,7 +17077,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                              * @param props Vault address, wallet address, and optional chain ID
                              * @returns Lifetime PnL data including realized and unrealized PnL
                              * @throws {@link AugustHistoryUnavailableError} (`HISTORY_UNAVAILABLE`) when a
-                                 *   live position has no indexed deposits or withdrawals.
+                                 *   live position has no indexed deposits, withdrawals or priceable share
+                                 *   transfers.
                                  * @throws {@link AugustPriceUnavailableError} (`PRICE_UNAVAILABLE`) when the
                                      *   vault's underlying asset has no USD price.
                                      */
@@ -18580,15 +18584,21 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                     export declare function fetchAugustWithBearer(bearerToken: string, relativeUrl: string, options?: IFetchAugustOptions): Promise<Response>;
 
                                     /**
-                                     * Make authenticated requests to August backend services using API key.
+                                     * Make requests to August backend services, sending an API key when one is
+                                     * configured. Many backend routes — vault-linked sub-account reads, the two
+                                     * collateral risk routes, timelock requests — answer anonymous callers, so a
+                                     * missing key is not an error here: the request goes out without the
+                                     * `x-api-key` header and the backend decides. Routes that do require a key
+                                     * answer `401`, which surfaces as an `AugustAuthError` with code
+                                     * `AUTH_UNAUTHORIZED`.
                                      * Automatically logs errors with correlation IDs for debugging.
-                                     * @param apiKey - August API key for authentication
+                                     * @param apiKey - August API key, or `undefined` for an anonymous request
                                      * @param relativeUrl - Endpoint path relative to base URL
                                      * @param options - Request configuration including method and headers
                                      * @returns Response object if successful
                                      * @throws Error with correlation ID if request fails
                                      */
-                                    export declare function fetchAugustWithKey(apiKey: string, relativeUrl: string, options?: IFetchAugustOptions): Promise<Response>;
+                                    export declare function fetchAugustWithKey(apiKey: string | undefined, relativeUrl: string, options?: IFetchAugustOptions): Promise<Response>;
 
                                     /**
                                      * @deprecated Use fetchVaultDebankResponse for vault-level queries.
@@ -19989,12 +19999,21 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                * from the price server. There is no stand-in price: when none resolves the
                                                * getter throws rather than returning USD values it cannot know.
                                                *
+                                               * Shares received by transfer: when history has no deposit, peer transfers of
+                                               * the share token (see {@link selectPeerTransfers}) are valued at the vault's
+                                               * daily share ratio ({@link transferCostBasis}) — received shares become
+                                               * `totalDeposited`, sent shares add to `totalWithdrawn`. PnL for such a wallet
+                                               * therefore runs from the day its shares arrived. This costs one extra
+                                               * subgraph query, plus one backend timeseries request when transfers exist,
+                                               * and only for wallets with no indexed deposit.
+                                               *
                                                * @param vault - Vault contract address
                                                * @param wallet - User wallet address
                                                * @param options - RPC configuration and service options
                                                * @returns Lifetime PnL data in both native token and USD
                                                * @throws {@link AugustHistoryUnavailableError} (`HISTORY_UNAVAILABLE`) when a
-                                                   *   live position has no indexed deposits or withdrawals.
+                                                   *   live position has no indexed deposits, withdrawals or priceable share
+                                                   *   transfers.
                                                    * @throws {@link AugustPriceUnavailableError} (`PRICE_UNAVAILABLE`) when the
                                                        *   underlying asset has no USD price, or `asset()` cannot be read.
                                                        */
@@ -20180,7 +20199,9 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                     *   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.
+                                                    *   reverts with `SlippageExceeded` if execution would mint fewer. An `idl`
+                                                    *   that predates `deposit_checked` gets the plain `deposit` with no floor,
+                                                    *   unless `options` asks for one — then it throws {@link AugustValidationError}.
                                                     */
                                                    declare function handleSolanaDeposit({ provider, connection, network, vaultProgramId, vaultAddress, depositAmount, publicKey, idl, options, }: {
                                                        vaultProgramId: PublicKey | string;
@@ -20209,6 +20230,9 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                     *   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.
+                                                    *   An `idl` that predates `redeem_checked` gets the plain `redeem` with no
+                                                    *   floor, unless `options` asks for one — then it throws
+                                                    *   {@link AugustValidationError}.
                                                     * @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
@@ -20449,7 +20473,13 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                        providers?: IProvidersConfig;
                                                        solana?: ISolanaConfig;
                                                        stellar?: IStellarConfig;
-                                                       keys: IKeys;
+                                                       /**
+                                                        * Provider keys. Optional: vault reads and vault-linked sub-account reads
+                                                        * work without an August key. Supply `august` for admin and curator methods,
+                                                        * for authenticated-user reads such as `getDiscountFactors`, and for
+                                                        * sub-account reads where the subaccount is not linked to a vault.
+                                                        */
+                                                       keys?: IKeys;
                                                        monitoring?: IMonitoring;
                                                        /** Analytics configuration. Enabled by default (opt-out model). */
                                                        analytics?: IAnalyticsConfig;
@@ -21267,8 +21297,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                        /** Per-request timeout in ms. Defaults to `REQUEST_TIMEOUT_MS`. */
                                                        timeoutMs?: number;
                                                        /**
-                                                        * @deprecated Bypasses the API-key check for legacy unauthenticated endpoints.
-                                                        * Will be removed in a future major version; pass a valid `apiKey` instead.
+                                                        * @deprecated No longer has any effect: an absent `apiKey` already sends an
+                                                        * anonymous request. Will be removed in a future major version; drop it.
                                                         */
                                                        override?: boolean;
                                                    };
@@ -22323,6 +22353,10 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                         * Skips the quote and the single snapshot read it needs. `0n` restores the
                                                         * unguarded behaviour of the plain `deposit` instruction.
                                                         *
+                                                        * When the handler's `idl` predates `deposit_checked`, a non-zero floor or
+                                                        * any `slippageBps` throws {@link AugustValidationError} instead of being
+                                                        * silently dropped; with neither, the plain `deposit` is sent.
+                                                        *
                                                         * Must be a `bigint` in `0 .. 2^64-1`; anything else throws
                                                         * {@link AugustValidationError} before the transaction is built.
                                                         */
@@ -22350,6 +22384,10 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                         * Explicit floor in raw deposit-mint units, net of the withdrawal fee,
                                                         * passed to `redeem_checked` as is. Skips the quote. `0n` restores the
                                                         * unguarded behaviour of the plain `redeem` instruction.
+                                                        *
+                                                        * When the handler's `idl` predates `redeem_checked`, a non-zero floor or
+                                                        * any `slippageBps` throws {@link AugustValidationError} instead of being
+                                                        * silently dropped; with neither, the plain `redeem` is sent.
                                                         */
                                                        minAssetsOut?: bigint;
                                                    }
@@ -24006,6 +24044,11 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                        symbol: string;
                                                        subgraph: string;
                                                        address: string;
+                                                       /**
+                                                        * Subgraph indexing the vault's separate receipt token (evm-2 vaults), when
+                                                        * one is deployed. Absent for vaults whose shares are the vault token itself.
+                                                        */
+                                                       receipt_subgraph?: string;
                                                    }
 
                                                    export declare type IVaultOrderParam = 'asc' | 'desc';
@@ -25153,6 +25196,9 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                        tokenPriceUsd: number;
                                                    }
 
+                                                   /** The receipt-token transfer fields the transfer cost basis reads. */
+                                                   export declare type PnlTransfer = Pick<ISubgraphTransfer, 'from' | 'to' | 'value' | 'timestamp_'>;
+
                                                    /** Multiplier applied to the poll interval after each NOT_FOUND poll. */
                                                    declare const POLL_INTERVAL_BACKOFF = 1.5;
 
@@ -26377,6 +26423,30 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
 
                                                     /* Excluded from this release type: SDKSentrySink */
 
+                                                    /**
+                                                     * Keep the receipt-token transfers that moved shares between `wallet` and
+                                                     * another holder.
+                                                     *
+                                                     * Vault shares are transferable ERC-20 tokens, so a wallet can hold a position
+                                                     * it never deposited into — a migration airdrop, a DEX purchase, a transfer from
+                                                     * another wallet. Mints (from the zero address), burns (to it) and transfers to
+                                                     * or from the vault itself are dropped: those are the deposit and withdrawal
+                                                     * legs the subgraph history already records, and counting them again would
+                                                     * double the cost basis.
+                                                     *
+                                                     * @param transfers - Receipt-token transfers touching `wallet`, as returned by
+                                                     *   the vault's transfer subgraph.
+                                                     * @param wallet - The wallet whose position is being valued.
+                                                     * @param vault - The vault contract address.
+                                                     * @returns The peer-to-peer transfers, in input order. Addresses compare
+                                                     *   case-insensitively.
+                                                     * @example
+                                                     * ```ts
+                                                     * const peer = selectPeerTransfers(transfers, wallet, vault);
+                                                     * ```
+                                                     */
+                                                    export declare function selectPeerTransfers<T extends PnlTransfer>(transfers: T[], wallet: IAddress, vault: IAddress): T[];
+
                                                     /**
                                                      * Fetches the senders whitelist contract address from a whitelisted allocation vault
                                                      * @param signer - signer / provider object
@@ -27464,1056 +27534,1116 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                           */
                                                                          export declare function trackNetworkSwitch(chainId: number): void;
 
-                                                                         export declare function truncate(s: string, amount?: number): string;
-
-                                                                         /* Excluded from this release type: tryRecoverTxHash */
-
-                                                                         /**
-                                                                          * Vault addresses to exclude from `getTotalDeposited` TVL aggregation.
-                                                                          * Addresses are lowercased so EVM, Solana, Sui and Stellar vaults can be
-                                                                          * checked uniformly (don't wrap them with `getAddress` — non-EVM addresses
-                                                                          * would throw). Add an address here to drop its `latest_reported_tvl` from
-                                                                          * the headline number — e.g. closed pre-deposit vaults, test vaults, or
-                                                                          * migrated v1 pools that are double-counted by a v2 successor.
-                                                                          */
-                                                                         export declare const TVL_EXCLUDED_VAULTS: ReadonlySet<string>;
-
-                                                                         /**
-                                                                          * Validity window for a submitted Soroban invocation (seconds).
-                                                                          *
-                                                                          * This becomes the transaction's `maxTime`. Validators reject a tx whose
-                                                                          * `maxTime` has passed (`txTOO_LATE`), so the window must outlast the slowest
-                                                                          * realistic sign-then-submit path: hardware wallets, careful manual review,
-                                                                          * and institutional approval flows (e.g. Fordefi) that don't sign instantly.
-                                                                          * 10 minutes comfortably covers those while staying well inside the Soroban
-                                                                          * footprint/ledger-entry TTL, so the simulated footprint can't go stale first.
-                                                                          *
-                                                                          * The window is anchored to the *network* clock (see `getNetworkCloseTime` in
-                                                                          * soroban.ts), not the signer's `Date.now()`, so a skewed device clock can't
-                                                                          * make the deadline expire early.
-                                                                          */
-                                                                         declare const TX_TIMEOUT_SECONDS = 600;
-
-                                                                         export declare type TypedContract<TAbi extends Abi> = Omit<BaseContract, 'getFunction' | 'getEvent'> & {
-                                                                             [Method in ExtractAbiFunctionNames<TAbi>]: TypedContractFunction<TAbi, Method>;
-                                                                         } & {
-                                                                             /**
-                                                                              * Return the function for a given name. This is useful when a contract
-                                                                              * method name conflicts with a JavaScript name such as ``prototype`` or
-                                                                              * when using a Contract programatically.
-                                                                              */
-                                                                             getFunction<T extends ExtractAbiFunctionNames<TAbi>>(key: T | TypedFragment<TAbi, T>): TypedContractFunction<TAbi, T>;
-                                                                             /**
-                                                                              * Return the event for a given name. This is useful when a contract
-                                                                              * event name conflicts with a JavaScript name such as ``prototype`` or
-                                                                              * when using a Contract programatically.
-                                                                              */
-                                                                             getEvent<T extends ExtractAbiEventNames<TAbi>>(key: T | EventFragment): TypedContractEvent<TAbi, T>;
-                                                                             /**
-                                                                              * All the Events available on this contract.
-                                                                              */
-                                                                             filters: {
-                                                                                 [EventName in ExtractAbiEventNames<TAbi>]: TypedContractEvent<TAbi, EventName>;
-                                                                             };
-                                                                         };
-
-                                                                         export declare interface TypedContractEvent<TAbi extends Abi, TEventName extends string, TEvent extends ExtractAbiEvents<TAbi> = ExtractAbiEvent<TAbi, TEventName>, TEventArgs extends readonly unknown[] = AsArray<Partial<AbiParametersToPrimitiveTypes<TEvent['inputs']>>>> {
-                                                                             (...args: [...TEventArgs]): DeferredTopicFilter;
-                                                                             /**
-                                                                              * The name of the Contract event.
-                                                                              */
-                                                                             name: TEventName;
-                                                                             /**
-                                                                              * The fragment of the Contract event. This will throw on ambiguous
-                                                                              * method names.
-                                                                              */
-                                                                             fragment: EventFragment;
-                                                                             /**
-                                                                              * Returns the fragment constrained by %%args%%. This can be used to
-                                                                              * resolve ambiguous event names.
-                                                                              */
-                                                                             getFragment(...args: [...TEventArgs]): EventFragment;
-                                                                         }
-
-                                                                         export declare interface TypedContractFunction<TAbi extends Abi, TFunctionName extends string, TFunction extends ExtractAbiFunctions<TAbi> = ExtractAbiFunction<TAbi, TFunctionName>, TInputArgs extends readonly unknown[] = AsArray<AbiParametersToPrimitiveTypes<TFunction['inputs']>>, TResult = TypedContractFunctionResult<TAbi, TFunctionName>, TFragment = TypedFragment<TAbi, TFunctionName>> {
-                                                                             (...args: [...TInputArgs, overrides?: Overrides]): Promise<TFunction['stateMutability'] extends 'view' | 'pure' ? TResult : ContractTransactionResponse>;
-                                                                             /**
-                                                                              * The name of the Contract method.
-                                                                              */
-                                                                             name: TFunctionName;
-                                                                             /**
-                                                                              * The fragment of the Contract method. This will throw on ambiguous
-                                                                              * method names.
-                                                                              */
-                                                                             fragment: TFragment;
-                                                                             /**
-                                                                              * Returns the fragment constrained by %%args%%. This can be used to
-                                                                              * resolve ambiguous method names.
-                                                                              */
-                                                                             getFragment(...args: [...TInputArgs]): TFragment;
-                                                                             /**
-                                                                              * Returns a populated transaction that can be used to perform the
-                                                                              * contract method with %%args%%.
-                                                                              */
-                                                                             populateTransaction(...args: [...TInputArgs, overrides?: Overrides]): Promise<ContractTransaction>;
-                                                                             /**
-                                                                              * Call the contract method with %%args%% and return the value.
-                                                                              *
-                                                                              * If the return value is a single type, it will be dereferenced and
-                                                                              * returned directly, otherwise the full Result will be returned.
-                                                                              */
-                                                                             staticCall(...args: [...TInputArgs, overrides?: Overrides]): Promise<TResult>;
-                                                                             /**
-                                                                              * Send a transaction for the contract method with %%args%%.
-                                                                              */
-                                                                             send(...args: [...TInputArgs, overrides?: Overrides]): Promise<ContractTransactionResponse>;
-                                                                             /**
-                                                                              * Estimate the gas to send the contract method with %%args%%.
-                                                                              */
-                                                                             estimateGas(...args: [...TInputArgs, overrides?: Overrides]): Promise<bigint>;
-                                                                             /**
-                                                                              * Call the contract method with %%args%% and return the Result
-                                                                              * without any dereferencing.
-                                                                              */
-                                                                             staticCallResult(...args: [...TInputArgs, overrides?: Overrides]): Promise<Result>;
+                                                                         /** Asset amounts that peer transfers moved into and out of a position. */
+                                                                         export declare interface TransferCostBasis {
+                                                                             /** Assets the received shares were worth on arrival, raw at vault decimals. */
+                                                                             receivedRaw: bigint;
+                                                                             /** Assets the sent shares were worth when they left, raw at vault decimals. */
+                                                                             sentRaw: bigint;
                                                                          }
 
-                                                                         export declare type TypedContractFunctionResult<TAbi extends Abi, TFunctionName extends string, TOutputArgs = AbiParametersToPrimitiveTypes<ExtractAbiFunction<TAbi, TFunctionName>['outputs']>> = TOutputArgs extends readonly [] ? void : TOutputArgs extends readonly [infer Arg] ? Arg : TOutputArgs;
-
-                                                                         export declare type TypedFragment<TAbi extends Abi, TFunctionName extends string, TFunction extends ExtractAbiFunctions<TAbi> = ExtractAbiFunction<TAbi, TFunctionName>> = Omit<FunctionFragment, 'inputs' | 'outputs' | 'stateMutability' | 'name' | 'type'> & {
-                                                                             name: TFunction['name'];
-                                                                             type: TFunction['type'];
-                                                                             inputs: TFunction['inputs'];
-                                                                             outputs: TFunction['outputs'];
-                                                                             stateMutability: TFunction['stateMutability'];
-                                                                         };
-
-                                                                         export declare function unixToDate(epoch: number): Date;
-
                                                                          /**
-                                                                          * Update the current user identity in Sentry.
-                                                                          * Called when wallet address changes.
+                                                                          * Value peer share transfers in the vault's asset, at the vault's share ratio
+                                                                          * on the day each one happened.
                                                                           *
-                                                                          * @param walletAddress - New wallet address (or undefined to clear)
-                                                                          * @param environment - Current environment
-                                                                          */
-                                                                         export declare function updateUser(walletAddress?: string, environment?: IEnv): void;
-
-                                                                         /* Excluded from this release type: validateAmountPrecision */
-
-                                                                         /**
-                                                                          * Vault adapter configurations mapping vault addresses to their adapter settings
-                                                                          */
-                                                                         export declare const VAULT_ADAPTER_CONFIGS: Record<IAddress, IVaultAdapterConfig>;
-
-                                                                         export declare const VAULT_ADDRESSES: Record<"musd" | "predlp" | "sentusd" | "pregrid" | "repouscc" | "earnxrp" | "tivkbtc" | "tivusdt0" | "supermon" | "earnmon" | "k3europ" | "wmon/ausd" | "wbtc/ausd" | "earnausd_monad" | "sausd" | "farmbold" | "sentuscc" | "sentbtc" | "svusdc" | "apusdc" | "testwethtsa" | "tacusr" | "upinjusdt" | "tac-teth" | "upausd" | "taccbbtc" | "xupusdc" | "uptbtc" | "gteth" | "ageth" | "upusdc" | "hgeth" | "upssylva" | "hbbtc" | "hbhype" | "upazt" | "susdt" | "upedge" | "coreusdc" | "upcusdo" | "shifteth" | "upsusde" | "uplbtc" | "upavax" | "tacrseth" | "earnausd" | "alpineusdcflagship" | "alpinecoinshiftusdc" | "upbtc" | "upstrbtc" | "maxiusr" | "upgammausdc" | "xhype" | "wildusd" | "alpinebtc" | "prenusd" | "upyzusd" | "upnusd" | "hlpe" | "nemo eth yield", `0x${string}`>;
-
-                                                                         /**
-                                                                          * Hardcoded subaccount addresses for specific vaults allocations
-                                                                          */
-                                                                         export declare const VAULT_ALLOCATION_SUBACCOUNTS: {
-                                                                             AgoraAUSD: {
-                                                                                 address: IAddress;
-                                                                                 subaccount: IAddress;
-                                                                                 useDebank: boolean;
-                                                                             };
-                                                                             earnAUSD: {
-                                                                                 address: IAddress;
-                                                                                 subaccount: IAddress;
-                                                                                 useDebank: boolean;
-                                                                             };
-                                                                             MonarqXRP: {
-                                                                                 address: IAddress;
-                                                                                 subaccount: IAddress;
-                                                                                 useDebank: boolean;
-                                                                             };
-                                                                         };
-
-                                                                         /**
-                                                                          * The functions to call on the vault contract
-                                                                          * @returns The functions to call
-                                                                          */
-                                                                         export declare const VAULT_FUNCTIONS_V1: IPoolFunctions[];
-
-                                                                         export declare const VAULT_FUNCTIONS_V2: IPoolFunctions[];
-
-                                                                         export declare const VAULT_FUNCTIONS_V2_RECEIPT: IPoolFunctions[];
-
-                                                                         export declare const VAULT_FUNCTIONS_V2_WHITELISTED_ASSETS: IPoolFunctions[];
-
-                                                                         /**
-                                                                          * Vault Symbols Mapping
-                                                                          * @deprecated use getVaultMetadata to fetch vault symbols from the backend
-                                                                          */
-                                                                         export declare const VAULT_SYMBOLS: Record<IAddress, string>;
-
-                                                                         /**
-                                                                          * Vault Symbols Reverse Mapping
-                                                                          * @deprecated use getVaultMetadata to fetch vault symbols from the backend
-                                                                          */
-                                                                         export declare const VAULT_SYMBOLS_REVERSE: Record<VaultSymbols, IAddress>;
-
-                                                                         /**
-                                                                          * Address type for vault contracts across all supported chains.
-                                                                          * EVM vaults use `0x`-prefixed hex addresses, Solana vaults use base58,
-                                                                          * and Stellar vaults use 56-character base32 addresses (G/C prefix).
+                                                                          * Used by {@link getVaultUserLifetimePnl} when a wallet has no indexed
+                                                                          * deposits: received shares become its cost basis and sent shares count as
+                                                                          * withdrawn, so lifetime PnL for a transfer recipient reads "PnL since the
+                                                                          * shares arrived" rather than failing or reporting the whole position as
+                                                                          * profit. A day with no usable ratio takes the latest earlier day's, and a
+                                                                          * transfer older than the history takes the earliest day's.
                                                                           *
-                                                                          * Use this instead of `IAddress` when the address may belong to any chain.
-                                                                          */
-                                                                         export declare type VaultAddress = string;
-
-                                                                         /**
-                                                                          * allowance checks user's current allowance per pool
-                                                                          * @param signer - signer / provider object
-                                                                          * @param options - object including pool contract address, user wallet address
-                                                                          * @returns normalized number object of the user's current allowance
-                                                                          */
-                                                                         export declare function vaultAllowance(signer: IContractRunner, options: IContractWriteOptions): Promise<INormalizedNumber>;
-
-                                                                         /**
-                                                                          * Approve a vault (or the appropriate adapter wrapper) to spend a token
-                                                                          * ahead of a separate deposit call. Spender routing mirrors
-                                                                          * {@link vaultDeposit} (multi-asset → vault, adapter → wrapper, standard →
-                                                                          * vault). Returns `undefined` when the existing allowance already covers
-                                                                          * `amount` **or** when the deposit asset is native.
-                                                                          *
-                                                                          * @returns Transaction hash when an approval was sent, `undefined` when
-                                                                          *   the existing allowance already covers `amount` or the deposit asset is
-                                                                          *   native (no ERC-20 allowance applies). Use {@link approve} for a
-                                                                          *   discriminated `ApproveResult` if you need to tell those two cases apart.
-                                                                          * @throws AugustValidationError on invalid wallet/target/amount.
-                                                                          *
-                                                                          * @example
-                                                                          * ```ts
-                                                                          * const hash = await augustSdk.evm.vaultApprove({
-                                                                          *   target: '0x...',         // vault contract address
-                                                                          *   wallet: walletAddress,
-                                                                          *   amount: '100',           // 100 of the deposit token (UI units)
-                                                                          *   wait: true,              // wait for the approval to confirm
-                                                                          * });
-                                                                          * if (hash) console.log('approve tx', hash);
-                                                                          * // hash === undefined means the on-chain allowance already covers the
-                                                                          * // amount, or the deposit asset is native (msg.value, no allowance).
-                                                                          * ```
-                                                                          */
-                                                                         export declare function vaultApprove(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string | undefined>;
-
-                                                                         /**
-                                                                          * Deposit underlying token into the specified vault. Auto-routes to the
-                                                                          * correct contract path (single-asset ERC-4626, EVM-2 multi-asset,
-                                                                          * Paraswap adapter, native-token wrapper, depositWithPermit) based on the
-                                                                          * vault version and `depositAsset`.
-                                                                          *
-                                                                          * Amounts are encoded against the **deposit token's** decimals, not the
-                                                                          * vault's share decimals. The SDK reads the appropriate decimals via the
-                                                                          * vault metadata and the asset's ERC-20.
-                                                                          *
-                                                                          * Approval is handled automatically: if the existing allowance doesn't
-                                                                          * cover `amount`, an `approve` is sent and **always waited for** (regardless
-                                                                          * of the caller's `wait` flag) so the deposit tx can't be re-ordered ahead
-                                                                          * of the approval on Monad-style RPCs.
-                                                                          *
-                                                                          * @param signer ethers Signer / Wallet (or viem WalletClient via {@link setSigner})
-                                                                          * @param options Vault address, wallet, amount, optional `depositAsset` for
-                                                                          *   adapter routes, optional `wait` to wait for the deposit receipt.
-                                                                          * @returns Deposit transaction hash.
-                                                                          * @throws AugustValidationError on invalid wallet/target/amount or missing
-                                                                          *   adapter config when `depositAsset` differs from the vault underlying.
-                                                                          * @throws AugustSDKError when the deposit submission or on-chain call fails.
-                                                                          *
-                                                                          * @example
-                                                                          * ```ts
-                                                                          * const hash = await augustSdk.evm.vaultDeposit({
-                                                                          *   target: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32', // vault
-                                                                          *   wallet: walletAddress,
-                                                                          *   amount: '100',         // 100 USDC (UI units)
-                                                                          *   wait: true,            // wait for the deposit receipt
-                                                                          * });
-                                                                          * ```
-                                                                          *
-                                                                          * @example Adapter deposit (different deposit asset than the vault's underlying)
-                                                                          * ```ts
-                                                                          * await augustSdk.evm.vaultDeposit({
-                                                                          *   target: vaultAddress,
-                                                                          *   wallet: walletAddress,
-                                                                          *   amount: '0.5',
-                                                                          *   depositAsset: WETH_ADDRESS,   // swap WETH -> vault underlying via the adapter
-                                                                          *   chainId: 1,
-                                                                          * });
-                                                                          * ```
-                                                                          */
-                                                                         export declare function vaultDeposit(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
-
-                                                                         /**
-                                                                          * Check if vault has adapter support
-                                                                          */
-                                                                         export declare function vaultHasAdapter(vaultAddress: IAddress): boolean;
-
-                                                                         /**
-                                                                          * august_vault program IDL (Anchor).
-                                                                          *
-                                                                          * GENERATED — do not edit by hand. Source of truth is the program repo's build
-                                                                          * artifact: solana-vaults `frontend/idl/august_vault.json` (synced from the
-                                                                          * vendored program by `scripts/sync-idl.sh`). Regenerate from there, NOT with
-                                                                          * `anchor idl fetch`: an Anchor IDL upload is not refreshed by a program
-                                                                          * upgrade, so every IDL published for this program lineage is stale — both
-                                                                          * `up12…` on mainnet (last written 2026-01-21) and the `C8B1…` devnet reference
-                                                                          * (2026-01-23) predate the ProgramConfig build deployed on 2026-08-06.
+                                                                          * Sent shares count only against a received basis. A wallet that sent shares
+                                                                          * but received none gets a zero basis, so the lifetime-PnL history guard still
+                                                                          * decides for it instead of reporting the sent shares as profit.
                                                                           *
-                                                                          * `address` is a build stamp (the mainnet id), NOT network-aware. Never rely on
-                                                                          * it: SolanaAdapter/getProgram resolve the real program id per network from
-                                                                          * programIds, or from an explicit `programId` override.
+                                                                          * Pure and synchronous. Assumes, as the getter does, that shares and assets
+                                                                          * share the vault's decimals.
                                                                           *
-                                                                          * Drift is guarded by tests/vaults/solana-idl-drift.test.ts: the deployed binary
-                                                                          * is pinned, every discriminator declared here must appear in that binary, and
-                                                                          * live VaultState accounts must decode against this file.
-                                                                          */
-                                                                         declare const vaultIdl: {
-                                                                             accounts: {
-                                                                                 discriminator: number[];
-                                                                                 name: string;
-                                                                             }[];
-                                                                             address: string;
-                                                                             errors: {
-                                                                                 code: number;
-                                                                                 msg: string;
-                                                                                 name: string;
-                                                                             }[];
-                                                                             events: {
-                                                                                 discriminator: number[];
-                                                                                 name: string;
-                                                                             }[];
-                                                                             instructions: ({
-                                                                                 accounts: ({
-                                                                                     name: string;
-                                                                                     signer: boolean;
-                                                                                     writable: boolean;
-                                                                                     docs?: undefined;
-                                                                                     pda?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     docs: string[];
-                                                                                     name: string;
-                                                                                     signer: boolean;
-                                                                                     writable: boolean;
-                                                                                     pda?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     docs: string[];
-                                                                                     name: string;
-                                                                                     writable: boolean;
-                                                                                     signer?: undefined;
-                                                                                     pda?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     docs: string[];
-                                                                                     name: string;
-                                                                                     signer?: undefined;
-                                                                                     writable?: undefined;
-                                                                                     pda?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     name: string;
-                                                                                     pda: {
-                                                                                         program: {
-                                                                                             kind: string;
-                                                                                             value: number[];
-                                                                                         };
-                                                                                         seeds: ({
-                                                                                             kind: string;
-                                                                                             value: number[];
-                                                                                             path?: undefined;
-                                                                                         } | {
-                                                                                             kind: string;
-                                                                                             path: string;
-                                                                                             value?: undefined;
-                                                                                         })[];
-                                                                                     };
-                                                                                     writable: boolean;
-                                                                                     signer?: undefined;
-                                                                                     docs?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     address: string;
-                                                                                     name: string;
-                                                                                     signer?: undefined;
-                                                                                     writable?: undefined;
-                                                                                     docs?: undefined;
-                                                                                     pda?: undefined;
-                                                                                 })[];
-                                                                                 args: {
-                                                                                     name: string;
-                                                                                     type: string;
-                                                                                 }[];
-                                                                                 discriminator: number[];
-                                                                                 docs: string[];
-                                                                                 name: string;
-                                                                             } | {
-                                                                                 accounts: ({
-                                                                                     docs: string[];
-                                                                                     name: string;
-                                                                                     pda: {
-                                                                                         seeds: {
-                                                                                             kind: string;
-                                                                                             value: number[];
-                                                                                         }[];
-                                                                                     };
-                                                                                     signer?: undefined;
-                                                                                     writable?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     docs: string[];
-                                                                                     name: string;
-                                                                                     signer: boolean;
-                                                                                     pda?: undefined;
-                                                                                     writable?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     docs: string[];
-                                                                                     name: string;
-                                                                                     signer: boolean;
-                                                                                     writable: boolean;
-                                                                                     pda?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     name: string;
-                                                                                     docs?: undefined;
-                                                                                     pda?: undefined;
-                                                                                     signer?: undefined;
-                                                                                     writable?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     name: string;
-                                                                                     writable: boolean;
-                                                                                     docs?: undefined;
-                                                                                     pda?: undefined;
-                                                                                     signer?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     address: string;
-                                                                                     name: string;
-                                                                                     docs?: undefined;
-                                                                                     pda?: undefined;
-                                                                                     signer?: undefined;
-                                                                                     writable?: undefined;
-                                                                                 })[];
-                                                                                 args: {
-                                                                                     name: string;
-                                                                                     type: string;
-                                                                                 }[];
-                                                                                 discriminator: number[];
-                                                                                 docs: string[];
-                                                                                 name: string;
-                                                                             } | {
-                                                                                 accounts: ({
-                                                                                     docs: string[];
-                                                                                     name: string;
-                                                                                     signer: boolean;
-                                                                                     pda?: undefined;
-                                                                                     writable?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     docs: string[];
-                                                                                     name: string;
-                                                                                     pda: {
-                                                                                         program: {
-                                                                                             kind: string;
-                                                                                             value: number[];
-                                                                                         };
-                                                                                         seeds: {
-                                                                                             kind: string;
-                                                                                             value: number[];
-                                                                                         }[];
-                                                                                     };
-                                                                                     signer?: undefined;
-                                                                                     writable?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     name: string;
-                                                                                     signer: boolean;
-                                                                                     writable: boolean;
-                                                                                     docs?: undefined;
-                                                                                     pda?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     name: string;
-                                                                                     pda: {
-                                                                                         seeds: {
-                                                                                             kind: string;
-                                                                                             value: number[];
-                                                                                         }[];
-                                                                                         program?: undefined;
-                                                                                     };
-                                                                                     writable: boolean;
-                                                                                     docs?: undefined;
-                                                                                     signer?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     address: string;
-                                                                                     name: string;
-                                                                                     docs?: undefined;
-                                                                                     signer?: undefined;
-                                                                                     pda?: undefined;
-                                                                                     writable?: undefined;
-                                                                                 })[];
-                                                                                 args: {
-                                                                                     name: string;
-                                                                                     type: string;
-                                                                                 }[];
-                                                                                 discriminator: number[];
-                                                                                 docs: string[];
-                                                                                 name: string;
-                                                                             } | {
-                                                                                 accounts: ({
-                                                                                     name: string;
-                                                                                     writable: boolean;
-                                                                                     signer?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     name: string;
-                                                                                     writable?: undefined;
-                                                                                     signer?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     name: string;
-                                                                                     signer: boolean;
-                                                                                     writable?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     name: string;
-                                                                                     signer: boolean;
-                                                                                     writable: boolean;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     address: string;
-                                                                                     name: string;
-                                                                                     writable?: undefined;
-                                                                                     signer?: undefined;
-                                                                                 })[];
-                                                                                 args: {
-                                                                                     name: string;
-                                                                                     type: string;
-                                                                                 }[];
-                                                                                 discriminator: number[];
-                                                                                 docs: string[];
-                                                                                 name: string;
-                                                                             } | {
-                                                                                 accounts: ({
-                                                                                     name: string;
-                                                                                     writable: boolean;
-                                                                                     pda?: undefined;
-                                                                                     signer?: undefined;
-                                                                                 } | {
-                                                                                     name: string;
-                                                                                     pda: {
-                                                                                         program: {
-                                                                                             kind: string;
-                                                                                             value: number[];
-                                                                                         };
-                                                                                         seeds: {
-                                                                                             kind: string;
-                                                                                             path: string;
-                                                                                         }[];
-                                                                                     };
-                                                                                     writable: boolean;
-                                                                                     signer?: undefined;
-                                                                                 } | {
-                                                                                     name: string;
-                                                                                     signer: boolean;
-                                                                                     writable?: undefined;
-                                                                                     pda?: undefined;
-                                                                                 } | {
-                                                                                     name: string;
-                                                                                     writable?: undefined;
-                                                                                     pda?: undefined;
-                                                                                     signer?: undefined;
-                                                                                 })[];
-                                                                                 args: {
-                                                                                     name: string;
-                                                                                     type: string;
-                                                                                 }[];
-                                                                                 discriminator: number[];
-                                                                                 docs: string[];
-                                                                                 name: string;
-                                                                             } | {
-                                                                                 accounts: ({
-                                                                                     name: string;
-                                                                                     pda: {
-                                                                                         seeds: {
-                                                                                             kind: string;
-                                                                                             value: number[];
-                                                                                         }[];
-                                                                                     };
-                                                                                     writable: boolean;
-                                                                                     signer?: undefined;
-                                                                                 } | {
-                                                                                     name: string;
-                                                                                     signer: boolean;
-                                                                                     pda?: undefined;
-                                                                                     writable?: undefined;
-                                                                                 })[];
-                                                                                 args: {
-                                                                                     name: string;
-                                                                                     type: string;
-                                                                                 }[];
-                                                                                 discriminator: number[];
-                                                                                 docs: string[];
-                                                                                 name: string;
-                                                                             } | {
-                                                                                 accounts: ({
-                                                                                     docs: string[];
-                                                                                     name: string;
-                                                                                     signer: boolean;
-                                                                                     writable?: undefined;
-                                                                                     pda?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     docs: string[];
-                                                                                     name: string;
-                                                                                     writable: boolean;
-                                                                                     signer?: undefined;
-                                                                                     pda?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     docs: string[];
-                                                                                     name: string;
-                                                                                     signer?: undefined;
-                                                                                     writable?: undefined;
-                                                                                     pda?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     name: string;
-                                                                                     pda: {
-                                                                                         program: {
-                                                                                             kind: string;
-                                                                                             value: number[];
-                                                                                         };
-                                                                                         seeds: ({
-                                                                                             kind: string;
-                                                                                             value: number[];
-                                                                                             path?: undefined;
-                                                                                         } | {
-                                                                                             kind: string;
-                                                                                             path: string;
-                                                                                             value?: undefined;
-                                                                                         })[];
-                                                                                     };
-                                                                                     writable: boolean;
-                                                                                     docs?: undefined;
-                                                                                     signer?: undefined;
-                                                                                     address?: undefined;
-                                                                                 } | {
-                                                                                     address: string;
-                                                                                     name: string;
-                                                                                     docs?: undefined;
-                                                                                     signer?: undefined;
-                                                                                     writable?: undefined;
-                                                                                     pda?: undefined;
-                                                                                 })[];
-                                                                                 args: {
-                                                                                     name: string;
-                                                                                     type: string;
-                                                                                 }[];
-                                                                                 discriminator: number[];
-                                                                                 docs: string[];
-                                                                                 name: string;
-                                                                             })[];
-                                                                             metadata: {
-                                                                                 description: string;
-                                                                                 name: string;
-                                                                                 spec: string;
-                                                                                 version: string;
-                                                                             };
-                                                                             types: ({
-                                                                                 name: string;
-                                                                                 repr: {
-                                                                                     kind: string;
-                                                                                 };
-                                                                                 serialization: string;
-                                                                                 type: {
-                                                                                     fields: {
-                                                                                         name: string;
-                                                                                         type: string;
-                                                                                     }[];
-                                                                                     kind: string;
-                                                                                 };
-                                                                                 docs?: undefined;
-                                                                             } | {
-                                                                                 docs: string[];
-                                                                                 name: string;
-                                                                                 type: {
-                                                                                     fields: ({
-                                                                                         docs: string[];
-                                                                                         name: string;
-                                                                                         type: string;
-                                                                                     } | {
-                                                                                         docs: string[];
-                                                                                         name: string;
-                                                                                         type: {
-                                                                                             array: (string | number)[];
-                                                                                         };
-                                                                                     })[];
-                                                                                     kind: string;
-                                                                                 };
-                                                                                 repr?: undefined;
-                                                                                 serialization?: undefined;
-                                                                             } | {
-                                                                                 name: string;
-                                                                                 type: {
-                                                                                     fields: ({
-                                                                                         name: string;
-                                                                                         type: string;
-                                                                                         docs?: undefined;
-                                                                                     } | {
-                                                                                         name: string;
-                                                                                         type: {
-                                                                                             array: (string | number)[];
-                                                                                         };
-                                                                                         docs?: undefined;
-                                                                                     } | {
-                                                                                         docs: string[];
-                                                                                         name: string;
-                                                                                         type: string;
-                                                                                     } | {
-                                                                                         docs: string[];
-                                                                                         name: string;
-                                                                                         type: {
-                                                                                             array: (string | number)[];
-                                                                                         };
-                                                                                     })[];
-                                                                                     kind: string;
-                                                                                 };
-                                                                                 repr?: undefined;
-                                                                                 serialization?: undefined;
-                                                                                 docs?: undefined;
-                                                                             })[];
-                                                                         };
-
-                                                                         /**
-                                                                          * @description withdraw funds from the specified pool including accrued rewards
-                                                                          * @param signer signer / wallet object
-                                                                          * @param options object including pool contract address, user wallet address, and more
-                                                                          * @returns claim tx hash
-                                                                          */
-                                                                         export declare function vaultRedeem(signer: Signer | Wallet, options: IContractWriteOptions & {
-                                                                             year: string;
-                                                                             month: string;
-                                                                             day: string;
-                                                                             receiverIndex: string;
-                                                                         }): Promise<string>;
-
-                                                                         export declare enum VaultRedemptionStatus {
-                                                                             AWAITING_COOLDOWN = "awaiting_cooldown",
-                                                                             READY_TO_CLAIM = "ready_to_claim"
-                                                                         }
-
-                                                                         /**
-                                                                          * Request to redeem vault shares. For EVM-1 vaults this queues a standard
-                                                                          * redemption (claimable later via `vaultRedeem`). For EVM-2 vaults the queued
-                                                                          * `requestRedeem` escrows the shares in the vault via `transferFrom`, so this
-                                                                          * also approves the receipt token when its allowance is short; the instant
-                                                                          * path (`isInstantRedeem: true`) burns the caller's shares directly and sends
-                                                                          * no approval.
-                                                                          *
-                                                                          * The receipt-token approval (EVM-2 queued path) is always waited on before
-                                                                          * the redeem call, regardless of the caller's `wait` flag.
-                                                                          *
-                                                                          * @param signer ethers Signer / Wallet (or viem WalletClient via {@link setSigner})
-                                                                          * @param options Vault address, wallet, amount, optional `isInstantRedeem`,
-                                                                          *   optional `wait` to wait for the redeem receipt.
-                                                                          * @returns Redeem transaction hash.
-                                                                          * @throws AugustValidationError on invalid wallet/target/amount.
-                                                                          * @throws AugustSDKError when the redeem submission or on-chain call fails.
-                                                                          *
-                                                                          * @example
-                                                                          * ```ts
-                                                                          * const hash = await augustSdk.evm.vaultRequestRedeem({
-                                                                          *   target: vaultAddress,
-                                                                          *   wallet: walletAddress,
-                                                                          *   amount: '10',           // 10 shares (UI units)
-                                                                          *   wait: true,
-                                                                          * });
-                                                                          * ```
-                                                                          *
-                                                                          * @example Instant redemption
-                                                                          * ```ts
-                                                                          * await augustSdk.evm.vaultRequestRedeem({
-                                                                          *   target: vaultAddress,
-                                                                          *   wallet: walletAddress,
-                                                                          *   amount: '10',
-                                                                          *   isInstantRedeem: true,
-                                                                          * });
-                                                                          * ```
-                                                                          */
-                                                                         export declare function vaultRequestRedeem(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
-
-                                                                         /**
-                                                                          * @deprecated Renamed to {@link SWAP_ROUTER_ELIGIBLE_VAULTS} (itself now
-                                                                          * superseded by {@link getSwapRouterEligibleVaults}, the on-chain-derived
-                                                                          * resolver), and the semantics changed: this set no longer drives
-                                                                          * `vaultDeposit` auto-routing (that branch was removed) — it only marks vaults
-                                                                          * whose UI may offer the swap-router deposit surface. Kept as an alias for one
-                                                                          * release; migrate to the async resolver.
-                                                                          */
-                                                                         export declare const VAULTS_USING_SWAP_ROUTER: ReadonlySet<string>;
-
-                                                                         /**
-                                                                          * Vault Receipt Symbol Mapping
-                                                                          * @deprecated use getVaultMetadata to fetch vault symbols from the backend
-                                                                          */
-                                                                         declare type VaultSymbols = 'predlp' | 'sentusd' | 'pregrid' | 'repouscc' | 'earnxrp' | 'tivkbtc' | 'tivusdt0' | 'supermon' | 'earnmon' | 'k3europ' | 'wmon/ausd' | 'wbtc/ausd' | 'earnausd_monad' | 'sausd' | 'farmbold' | 'sentuscc' | 'sentbtc' | 'svusdc' | 'apusdc' | 'testwethtsa' | 'tacusr' | 'upinjusdt' | 'tac-teth' | 'upausd' | 'taccbbtc' | 'xupusdc' | 'uptbtc' | 'gteth' | 'ageth' | 'upusdc' | 'hgeth' | 'upssylva' | 'hbbtc' | 'hbhype' | 'upazt' | 'susdt' | 'upedge' | 'coreusdc' | 'upcusdo' | 'shifteth' | 'upsusde' | 'uplbtc' | 'upavax' | 'tacrseth' | 'musd' | 'earnausd' | 'alpineusdcflagship' | 'alpinecoinshiftusdc' | 'upbtc' | 'upstrbtc' | 'maxiusr' | 'upgammausdc' | 'xhype' | 'wildusd' | 'alpinebtc' | 'prenusd' | 'upyzusd' | 'upnusd' | 'hlpe' | 'nemo eth yield';
-
-                                                                         /**
-                                                                          * @deprecated Renamed to {@link isSwapRouterEligible} (itself now superseded by
-                                                                          * {@link getSwapRouterEligibleVaults}, the on-chain-derived resolver). The
-                                                                          * meaning also changed: it no longer implies `vaultDeposit` routes the vault
-                                                                          * through the SwapRouter (that behavior was removed) — it only reports
-                                                                          * swap-router *eligibility* for the opt-in deposit surface. Kept as an alias
-                                                                          * for one release; migrate to the async resolver.
-                                                                          */
-                                                                         export declare const vaultUsesSwapRouter: typeof isSwapRouterEligible;
-
-                                                                         export declare function verifyAugustKey(key: string): Promise<boolean>;
-
-                                                                         export declare function verifyInfuraKey(key: string): Promise<boolean>;
-
-                                                                         /**
-                                                                          * Convert a viem WalletClient to an ethers-compatible Signer
-                                                                          * Uses the walletClient as a provider and wraps it for ethers compatibility
-                                                                          * @param walletClient Viem WalletClient from wagmi or viem
-                                                                          * @returns Ethers Signer that can be used with the SDK
-                                                                          */
-                                                                         export declare function viemToEthersSigner(walletClient: any): Promise<Signer | Wallet>;
-
-                                                                         /**
-                                                                          * @param walletClient a wagmi-derived client (from useWalletClient)
-                                                                          * @returns An ethers JsonRpcSigner object used in sdk.evm.setSigner
-                                                                          */
-                                                                         export declare function walletClientToSigner(walletClient: WalletClient): Promise<ethers.JsonRpcSigner>;
-
-                                                                         export declare const WEBSERVER_ENDPOINTS: {
-                                                                             default: {
-                                                                                 /** @deprecated No backend route. Removed in the next major release. */
-                                                                                 hello: string;
-                                                                                 protected: string;
-                                                                             };
-                                                                             auth: {
-                                                                                 verify: string;
-                                                                                 sign: string;
-                                                                                 login: string;
-                                                                                 nonce: string;
-                                                                                 refresh: string;
-                                                                             };
-                                                                             subaccount: {
-                                                                                 list: (offset?: number, limit?: number) => string;
-                                                                                 /** @deprecated No backend route. Removed in the next major release. */
-                                                                                 rewards: (subaccount: IAddress) => string;
-                                                                                 tokens: (subaccount: IAddress) => string;
-                                                                                 twap: {
-                                                                                     create: (subaccount: IAddress) => string;
-                                                                                     stop: (subaccount: IAddress, id: string) => string;
-                                                                                     fills: (subaccount: IAddress, id: string) => string;
-                                                                                 };
-                                                                                 debank: (subaccount: IAddress) => string;
-                                                                                 health_factor: (subaccount: IAddress) => string;
-                                                                                 summary: (subaccount: IAddress) => string;
-                                                                                 /** @deprecated No backend route. Removed in the next major release. */
-                                                                                 batch: (subaccount: IAddress) => string;
-                                                                                 loans: (subaccount: IAddress, side?: "BORROWER" | "LENDER" | "BOTH", active?: boolean) => string;
-                                                                                 cefi: (subaccount: IAddress) => string;
-                                                                                 otc_positions: (subaccount: IAddress) => string;
-                                                                                 loanByAddress: (loanAddress: string, chainId: number) => string;
-                                                                                 _: (subaccount: IAddress) => string;
-                                                                             };
-                                                                             transactions: {
-                                                                                 v2: (subaccount: string, startTime?: string, endTime?: string) => string;
-                                                                             };
-                                                                             otc: {
-                                                                                 positions: string;
-                                                                                 marginRequirements: (otcCounterpartyId?: string, payer?: string) => string;
-                                                                             };
-                                                                             curator: {
-                                                                                 vaultSubaccounts: (vaultAddress: string) => string;
-                                                                                 vaultWhitelist: (vaultAddress: string) => string;
-                                                                             };
-                                                                             timelockRequests: (vaultAddress: string, chainId: number, status?: string) => string;
-                                                                             users: {
-                                                                                 get: string;
-                                                                             };
-                                                                             dashboard: {
-                                                                                 loans: string;
-                                                                             };
-                                                                             risk: {
-                                                                                 discountFactors: string;
-                                                                                 collateralExcessOrDeficit: (subaccount: string, tokenAddress: string, tokenChain: number, targetHealthFactor?: number) => string;
-                                                                                 collateralSimulation: string;
-                                                                             };
-                                                                             prices: (symbol: string) => string;
-                                                                             metrics: {
-                                                                                 pnl: (subaccount: IAddress, startTime?: string, endTime?: string) => string;
-                                                                                 vaultPerformanceFees: (params: {
-                                                                                     vaultAddress: string;
-                                                                                     annualizedFeesPct: number;
-                                                                                     nativeDenominated: boolean;
-                                                                                     calculationPeriod: string;
-                                                                                     startDate?: string;
-                                                                                     endDate?: string;
-                                                                                 }) => string;
-                                                                             };
-                                                                             public: {
-                                                                                 integrations: {
-                                                                                     morpho: {
-                                                                                         apy: (subaccount: IAddress, vaultAddress: IAddress) => string;
-                                                                                     };
-                                                                                 };
-                                                                                 tokenizedVault: {
-                                                                                     loans: (vaultAddress: VaultAddress, chainId: number, active: boolean) => string;
-                                                                                     subaccountLoans: (vaultAddress: VaultAddress, chainId: number, active: boolean) => string;
-                                                                                     list: string;
-                                                                                     byVaultAddress: (vaultAddress: VaultAddress) => string;
-                                                                                     historicalApy: (vaultAddress: IAddress) => string;
-                                                                                     historicalTimeseries: (vaultAddress: IAddress, nDays?: number) => string;
-                                                                                     annualizedApy: (vaultAddress: IAddress) => string;
-                                                                                     summary: (vaultAddress: IAddress) => string;
-                                                                                     withdrawals: (chain: string, vaultAddress: IAddress) => string;
-                                                                                     debank: (vaultAddress: IAddress) => string;
-                                                                                     userHistory: (vaultAddress: IAddress, wallet: IAddress) => string;
-                                                                                     archivedVaults: string;
-                                                                                 };
-                                                                                 points: {
-                                                                                     byUserAddress: (userAddress: IAddress) => string;
-                                                                                     register: string;
-                                                                                     leaderboard: string;
-                                                                                 };
-                                                                                 vaults: {
-                                                                                     pendingRedemptions: (vaultAddress: IAddress) => string;
-                                                                                 };
-                                                                                 pnl: {
-                                                                                     unrealizedHistory: (vaultAddress: VaultAddress, limit?: number) => string;
-                                                                                     unrealizedLatest: string;
-                                                                                 };
-                                                                                 revertReason: (txHash: string, chain: number) => string;
-                                                                                 oracleClassification: (vaultAddress: string, chainId: number) => string;
-                                                                                 transparency: {
-                                                                                     positions: (vaultAddress: string, chainId: number) => string;
-                                                                                     historicalAllocations: (vaultAddress: string, chainId: number, startDate?: string, endDate?: string) => string;
-                                                                                     fees: (vaultAddress: string, chainId: number) => string;
-                                                                                     ratioSeries: (vaultAddress: string, startDate?: string, endDate?: string, limit?: number) => string;
-                                                                                     smoothedApy: (vaultAddress: string, daysAgo: number, averagingPeriodDays: number, applySmoothing: boolean) => string;
-                                                                                     governanceRoles: (vaultAddress: string, chainId: number) => string;
-                                                                                     governancePermissions: (vaultAddress: string, chainId: number) => string;
-                                                                                     governanceTimelocks: (vaultAddress: string, chainId: number, status?: string) => string;
-                                                                                     governanceAuditLog: (vaultAddress: string, chainId: number, category?: string, before?: string, limit?: number) => string;
-                                                                                 };
-                                                                             };
-                                                                             upshift: {
-                                                                                 vaults: {
-                                                                                     metadata: string;
-                                                                                 };
-                                                                             };
-                                                                         };
-
-                                                                         export declare const WEBSERVER_URL: {
-                                                                             production: string;
-                                                                             staging: string;
-                                                                             development: string;
-                                                                             localhost: string;
-                                                                             qa: string;
-                                                                             public: string;
-                                                                             upshift: string;
-                                                                         };
-
-                                                                         /**
-                                                                          * Withdrawal request with computed claimable date and current processing status.
-                                                                          * The unique identifier is (receiver, claimableDate).
-                                                                          *
-                                                                          * @interface WithdrawalRequestStatus
-                                                                          */
-                                                                         export declare interface WithdrawalRequestStatus {
-                                                                             /** Transaction hash of the withdrawal request */
-                                                                             transactionHash: string;
-                                                                             /** Block timestamp when the withdrawal was requested (seconds, UTC) */
-                                                                             requestTimestamp: number;
-                                                                             /** Shares amount being redeemed */
-                                                                             shares: bigint;
-                                                                             /** Receiver address for the withdrawal */
-                                                                             receiver: string;
-                                                                             /** Computed claimable date in UTC (year, month, day) */
-                                                                             claimableDate: {
-                                                                                 year: number;
-                                                                                 month: number;
-                                                                                 day: number;
-                                                                             };
-                                                                             /** Epoch timestamp when this withdrawal becomes claimable */
-                                                                             claimableEpoch: number;
-                                                                             /** Current status of the withdrawal */
-                                                                             status: 'pending' | 'ready_to_claim' | 'processed';
-                                                                             /** Transaction hash of the processing transaction (if processed) */
-                                                                             processedTransactionHash?: string;
-                                                                             /** Assets received (if processed) */
-                                                                             assetsReceived?: bigint;
-                                                                         }
-
-                                                                         /**
-                                                                          * Higher-order function to wrap SDK methods with performance tracking.
-                                                                          * Tracks method calls, timing, chain usage, and errors.
-                                                                          *
-                                                                          * @param methodName - Name of the method being wrapped
-                                                                          * @param method - The original async method
-                                                                          * @param getChainId - Function to get current chain ID
-                                                                          * @returns Wrapped method with tracking
-                                                                          */
-                                                                         export declare function withMethodTracking<T extends (...args: unknown[]) => Promise<unknown>>(methodName: string, method: T, getChainId?: () => number | undefined): T;
-
-                                                                         /**
-                                                                          * Wrap async operations with exponential backoff retry logic.
-                                                                          * Retries on network errors with increasing delays between attempts.
-                                                                          * @param fn - Async function to execute with retry logic
-                                                                          * @param maxRetries - Maximum number of retry attempts
-                                                                          * @param baseDelay - Initial delay in milliseconds (doubles each retry)
-                                                                          * @param shouldRetry - Custom function to determine if error is retryable
-                                                                          * @returns Result of successful function execution
-                                                                          * @throws Last error if all retries exhausted
-                                                                          */
-                                                                         export declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number, baseDelay?: number, shouldRetry?: (error: Error) => boolean): Promise<T>;
-
-                                                                         /**
-                                                                          * Higher-order function to wrap synchronous SDK methods with tracking.
-                                                                          * Uses breadcrumbs for tracking since spans require async context.
-                                                                          *
-                                                                          * @param methodName - Name of the method being wrapped
-                                                                          * @param method - The original sync method
-                                                                          * @param getChainId - Function to get current chain ID
-                                                                          * @returns Wrapped method with tracking
-                                                                          */
-                                                                         export declare function withSyncMethodTracking<T extends (...args: unknown[]) => unknown>(methodName: string, method: T, getChainId?: () => number | undefined): T;
-
-                                                                         export declare const WRAPPER_ADAPTOR: {
-                                                                             43114: IAddress;
-                                                                             1: IAddress;
-                                                                         };
-
-                                                                         /**
-                                                                          * Wrap an ethers signer so every transaction it sends carries the active
-                                                                          * ERC-8021 attribution suffix (Base Builder Codes).
-                                                                          *
-                                                                          * Every ethers write in the SDK funnels through the wrapped signer's
-                                                                          * `sendTransaction`, so this single wrap attributes all vault writes. The
-                                                                          * wrapper is a Proxy — the caller's signer object is never mutated, so a
-                                                                          * signer reused outside the SDK sends unattributed transactions. Attribution
-                                                                          * state is read at send time, not wrap time; when no attribution is
-                                                                          * configured (see `IAugustBase.attribution`) the wrapper is a pass-through.
-                                                                          *
-                                                                          * Plain value transfers (no calldata) are never attributed, and calldata
-                                                                          * already ending in the ERC-8021 marker is left untouched. When the
-                                                                          * configured `chains` list requires a chain check and the transaction does
-                                                                          * not carry a `chainId`, the signer's provider network is consulted (one
-                                                                          * cached RPC call); if that lookup fails the transaction is sent
-                                                                          * unattributed.
-                                                                          *
-                                                                          * @param signer Normalized ethers Signer or Wallet.
-                                                                          * @returns A proxied signer with an attribution-aware `sendTransaction`.
-                                                                          */
-                                                                         export declare function wrapSignerWithAttribution<T extends Signer | Wallet>(signer: T): T;
-
-                                                                         export { }
+                                                                          * @param params - See {@link TransferCostBasisParams}.
+                                                                          * @returns The received and sent asset amounts, raw at the vault's decimals;
+                                                                          *   both zero when no shares were received.
+                                                                          * @throws {@link AugustHistoryUnavailableError} (`HISTORY_UNAVAILABLE`) when no
+                                                                              *   day in `history` carries a positive, finite `asset_share_ratio`.
+                                                                              * @example
+                                                                              * ```ts
+                                                                              * const { data } = await fetchVaultHistoricalTimeseries(vault, nDays);
+                                                                              * const { receivedRaw, sentRaw } = transferCostBasis({
+                                                                              *   transfers: selectPeerTransfers(transfers, wallet, vault),
+                                                                              *   wallet,
+                                                                              *   vault,
+                                                                              *   history: data,
+                                                                              * });
+                                                                              * ```
+                                                                              */
+                                                                          export declare function transferCostBasis({ transfers, wallet, vault, history, }: TransferCostBasisParams): TransferCostBasis;
+
+                                                                          /** Inputs {@link transferCostBasis} prices. */
+                                                                          export declare interface TransferCostBasisParams {
+                                                                              /** Peer transfers touching `wallet` — see {@link selectPeerTransfers}. */
+                                                                              transfers: PnlTransfer[];
+                                                                              /** The wallet whose cost basis is being computed. */
+                                                                              wallet: IAddress;
+                                                                              /** The vault contract address, used for the error message and context. */
+                                                                              vault: IAddress;
+                                                                              /**
+                                                                               * The vault's daily history from `fetchVaultHistoricalTimeseries`, keyed by
+                                                                               * UTC date (`YYYY-MM-DD`). Only `asset_share_ratio` (assets per share) is
+                                                                               * read.
+                                                                               */
+                                                                              history: Record<string, Pick<IHistoricalTimeseriesPoint, 'asset_share_ratio'>>;
+                                                                          }
+
+                                                                          export declare function truncate(s: string, amount?: number): string;
+
+                                                                          /* Excluded from this release type: tryRecoverTxHash */
+
+                                                                          /**
+                                                                           * Vault addresses to exclude from `getTotalDeposited` TVL aggregation.
+                                                                           * Addresses are lowercased so EVM, Solana, Sui and Stellar vaults can be
+                                                                           * checked uniformly (don't wrap them with `getAddress` — non-EVM addresses
+                                                                           * would throw). Add an address here to drop its `latest_reported_tvl` from
+                                                                           * the headline number — e.g. closed pre-deposit vaults, test vaults, or
+                                                                           * migrated v1 pools that are double-counted by a v2 successor.
+                                                                           */
+                                                                          export declare const TVL_EXCLUDED_VAULTS: ReadonlySet<string>;
+
+                                                                          /**
+                                                                           * Validity window for a submitted Soroban invocation (seconds).
+                                                                           *
+                                                                           * This becomes the transaction's `maxTime`. Validators reject a tx whose
+                                                                           * `maxTime` has passed (`txTOO_LATE`), so the window must outlast the slowest
+                                                                           * realistic sign-then-submit path: hardware wallets, careful manual review,
+                                                                           * and institutional approval flows (e.g. Fordefi) that don't sign instantly.
+                                                                           * 10 minutes comfortably covers those while staying well inside the Soroban
+                                                                           * footprint/ledger-entry TTL, so the simulated footprint can't go stale first.
+                                                                           *
+                                                                           * The window is anchored to the *network* clock (see `getNetworkCloseTime` in
+                                                                           * soroban.ts), not the signer's `Date.now()`, so a skewed device clock can't
+                                                                           * make the deadline expire early.
+                                                                           */
+                                                                          declare const TX_TIMEOUT_SECONDS = 600;
+
+                                                                          export declare type TypedContract<TAbi extends Abi> = Omit<BaseContract, 'getFunction' | 'getEvent'> & {
+                                                                              [Method in ExtractAbiFunctionNames<TAbi>]: TypedContractFunction<TAbi, Method>;
+                                                                          } & {
+                                                                              /**
+                                                                               * Return the function for a given name. This is useful when a contract
+                                                                               * method name conflicts with a JavaScript name such as ``prototype`` or
+                                                                               * when using a Contract programatically.
+                                                                               */
+                                                                              getFunction<T extends ExtractAbiFunctionNames<TAbi>>(key: T | TypedFragment<TAbi, T>): TypedContractFunction<TAbi, T>;
+                                                                              /**
+                                                                               * Return the event for a given name. This is useful when a contract
+                                                                               * event name conflicts with a JavaScript name such as ``prototype`` or
+                                                                               * when using a Contract programatically.
+                                                                               */
+                                                                              getEvent<T extends ExtractAbiEventNames<TAbi>>(key: T | EventFragment): TypedContractEvent<TAbi, T>;
+                                                                              /**
+                                                                               * All the Events available on this contract.
+                                                                               */
+                                                                              filters: {
+                                                                                  [EventName in ExtractAbiEventNames<TAbi>]: TypedContractEvent<TAbi, EventName>;
+                                                                              };
+                                                                          };
+
+                                                                          export declare interface TypedContractEvent<TAbi extends Abi, TEventName extends string, TEvent extends ExtractAbiEvents<TAbi> = ExtractAbiEvent<TAbi, TEventName>, TEventArgs extends readonly unknown[] = AsArray<Partial<AbiParametersToPrimitiveTypes<TEvent['inputs']>>>> {
+                                                                              (...args: [...TEventArgs]): DeferredTopicFilter;
+                                                                              /**
+                                                                               * The name of the Contract event.
+                                                                               */
+                                                                              name: TEventName;
+                                                                              /**
+                                                                               * The fragment of the Contract event. This will throw on ambiguous
+                                                                               * method names.
+                                                                               */
+                                                                              fragment: EventFragment;
+                                                                              /**
+                                                                               * Returns the fragment constrained by %%args%%. This can be used to
+                                                                               * resolve ambiguous event names.
+                                                                               */
+                                                                              getFragment(...args: [...TEventArgs]): EventFragment;
+                                                                          }
+
+                                                                          export declare interface TypedContractFunction<TAbi extends Abi, TFunctionName extends string, TFunction extends ExtractAbiFunctions<TAbi> = ExtractAbiFunction<TAbi, TFunctionName>, TInputArgs extends readonly unknown[] = AsArray<AbiParametersToPrimitiveTypes<TFunction['inputs']>>, TResult = TypedContractFunctionResult<TAbi, TFunctionName>, TFragment = TypedFragment<TAbi, TFunctionName>> {
+                                                                              (...args: [...TInputArgs, overrides?: Overrides]): Promise<TFunction['stateMutability'] extends 'view' | 'pure' ? TResult : ContractTransactionResponse>;
+                                                                              /**
+                                                                               * The name of the Contract method.
+                                                                               */
+                                                                              name: TFunctionName;
+                                                                              /**
+                                                                               * The fragment of the Contract method. This will throw on ambiguous
+                                                                               * method names.
+                                                                               */
+                                                                              fragment: TFragment;
+                                                                              /**
+                                                                               * Returns the fragment constrained by %%args%%. This can be used to
+                                                                               * resolve ambiguous method names.
+                                                                               */
+                                                                              getFragment(...args: [...TInputArgs]): TFragment;
+                                                                              /**
+                                                                               * Returns a populated transaction that can be used to perform the
+                                                                               * contract method with %%args%%.
+                                                                               */
+                                                                              populateTransaction(...args: [...TInputArgs, overrides?: Overrides]): Promise<ContractTransaction>;
+                                                                              /**
+                                                                               * Call the contract method with %%args%% and return the value.
+                                                                               *
+                                                                               * If the return value is a single type, it will be dereferenced and
+                                                                               * returned directly, otherwise the full Result will be returned.
+                                                                               */
+                                                                              staticCall(...args: [...TInputArgs, overrides?: Overrides]): Promise<TResult>;
+                                                                              /**
+                                                                               * Send a transaction for the contract method with %%args%%.
+                                                                               */
+                                                                              send(...args: [...TInputArgs, overrides?: Overrides]): Promise<ContractTransactionResponse>;
+                                                                              /**
+                                                                               * Estimate the gas to send the contract method with %%args%%.
+                                                                               */
+                                                                              estimateGas(...args: [...TInputArgs, overrides?: Overrides]): Promise<bigint>;
+                                                                              /**
+                                                                               * Call the contract method with %%args%% and return the Result
+                                                                               * without any dereferencing.
+                                                                               */
+                                                                              staticCallResult(...args: [...TInputArgs, overrides?: Overrides]): Promise<Result>;
+                                                                          }
+
+                                                                          export declare type TypedContractFunctionResult<TAbi extends Abi, TFunctionName extends string, TOutputArgs = AbiParametersToPrimitiveTypes<ExtractAbiFunction<TAbi, TFunctionName>['outputs']>> = TOutputArgs extends readonly [] ? void : TOutputArgs extends readonly [infer Arg] ? Arg : TOutputArgs;
+
+                                                                          export declare type TypedFragment<TAbi extends Abi, TFunctionName extends string, TFunction extends ExtractAbiFunctions<TAbi> = ExtractAbiFunction<TAbi, TFunctionName>> = Omit<FunctionFragment, 'inputs' | 'outputs' | 'stateMutability' | 'name' | 'type'> & {
+                                                                              name: TFunction['name'];
+                                                                              type: TFunction['type'];
+                                                                              inputs: TFunction['inputs'];
+                                                                              outputs: TFunction['outputs'];
+                                                                              stateMutability: TFunction['stateMutability'];
+                                                                          };
+
+                                                                          export declare function unixToDate(epoch: number): Date;
+
+                                                                          /**
+                                                                           * Update the current user identity in Sentry.
+                                                                           * Called when wallet address changes.
+                                                                           *
+                                                                           * @param walletAddress - New wallet address (or undefined to clear)
+                                                                           * @param environment - Current environment
+                                                                           */
+                                                                          export declare function updateUser(walletAddress?: string, environment?: IEnv): void;
+
+                                                                          /* Excluded from this release type: validateAmountPrecision */
+
+                                                                          /**
+                                                                           * Vault adapter configurations mapping vault addresses to their adapter settings
+                                                                           */
+                                                                          export declare const VAULT_ADAPTER_CONFIGS: Record<IAddress, IVaultAdapterConfig>;
+
+                                                                          export declare const VAULT_ADDRESSES: Record<"musd" | "predlp" | "sentusd" | "pregrid" | "repouscc" | "earnxrp" | "tivkbtc" | "tivusdt0" | "supermon" | "earnmon" | "k3europ" | "wmon/ausd" | "wbtc/ausd" | "earnausd_monad" | "sausd" | "farmbold" | "sentuscc" | "sentbtc" | "svusdc" | "apusdc" | "testwethtsa" | "tacusr" | "upinjusdt" | "tac-teth" | "upausd" | "taccbbtc" | "xupusdc" | "uptbtc" | "gteth" | "ageth" | "upusdc" | "hgeth" | "upssylva" | "hbbtc" | "hbhype" | "upazt" | "susdt" | "upedge" | "coreusdc" | "upcusdo" | "shifteth" | "upsusde" | "uplbtc" | "upavax" | "tacrseth" | "earnausd" | "alpineusdcflagship" | "alpinecoinshiftusdc" | "upbtc" | "upstrbtc" | "maxiusr" | "upgammausdc" | "xhype" | "wildusd" | "alpinebtc" | "prenusd" | "upyzusd" | "upnusd" | "hlpe" | "nemo eth yield", `0x${string}`>;
+
+                                                                          /**
+                                                                           * Hardcoded subaccount addresses for specific vaults allocations
+                                                                           */
+                                                                          export declare const VAULT_ALLOCATION_SUBACCOUNTS: {
+                                                                              AgoraAUSD: {
+                                                                                  address: IAddress;
+                                                                                  subaccount: IAddress;
+                                                                                  useDebank: boolean;
+                                                                              };
+                                                                              earnAUSD: {
+                                                                                  address: IAddress;
+                                                                                  subaccount: IAddress;
+                                                                                  useDebank: boolean;
+                                                                              };
+                                                                              MonarqXRP: {
+                                                                                  address: IAddress;
+                                                                                  subaccount: IAddress;
+                                                                                  useDebank: boolean;
+                                                                              };
+                                                                          };
+
+                                                                          /**
+                                                                           * The functions to call on the vault contract
+                                                                           * @returns The functions to call
+                                                                           */
+                                                                          export declare const VAULT_FUNCTIONS_V1: IPoolFunctions[];
+
+                                                                          export declare const VAULT_FUNCTIONS_V2: IPoolFunctions[];
+
+                                                                          export declare const VAULT_FUNCTIONS_V2_RECEIPT: IPoolFunctions[];
+
+                                                                          export declare const VAULT_FUNCTIONS_V2_WHITELISTED_ASSETS: IPoolFunctions[];
+
+                                                                          /**
+                                                                           * Vault Symbols Mapping
+                                                                           * @deprecated use getVaultMetadata to fetch vault symbols from the backend
+                                                                           */
+                                                                          export declare const VAULT_SYMBOLS: Record<IAddress, string>;
+
+                                                                          /**
+                                                                           * Vault Symbols Reverse Mapping
+                                                                           * @deprecated use getVaultMetadata to fetch vault symbols from the backend
+                                                                           */
+                                                                          export declare const VAULT_SYMBOLS_REVERSE: Record<VaultSymbols, IAddress>;
+
+                                                                          /**
+                                                                           * Address type for vault contracts across all supported chains.
+                                                                           * EVM vaults use `0x`-prefixed hex addresses, Solana vaults use base58,
+                                                                           * and Stellar vaults use 56-character base32 addresses (G/C prefix).
+                                                                           *
+                                                                           * Use this instead of `IAddress` when the address may belong to any chain.
+                                                                           */
+                                                                          export declare type VaultAddress = string;
+
+                                                                          /**
+                                                                           * allowance checks user's current allowance per pool
+                                                                           * @param signer - signer / provider object
+                                                                           * @param options - object including pool contract address, user wallet address
+                                                                           * @returns normalized number object of the user's current allowance
+                                                                           */
+                                                                          export declare function vaultAllowance(signer: IContractRunner, options: IContractWriteOptions): Promise<INormalizedNumber>;
+
+                                                                          /**
+                                                                           * Approve a vault (or the appropriate adapter wrapper) to spend a token
+                                                                           * ahead of a separate deposit call. Spender routing mirrors
+                                                                           * {@link vaultDeposit} (multi-asset → vault, adapter → wrapper, standard →
+                                                                           * vault). Returns `undefined` when the existing allowance already covers
+                                                                           * `amount` **or** when the deposit asset is native.
+                                                                           *
+                                                                           * @returns Transaction hash when an approval was sent, `undefined` when
+                                                                           *   the existing allowance already covers `amount` or the deposit asset is
+                                                                           *   native (no ERC-20 allowance applies). Use {@link approve} for a
+                                                                           *   discriminated `ApproveResult` if you need to tell those two cases apart.
+                                                                           * @throws AugustValidationError on invalid wallet/target/amount.
+                                                                           *
+                                                                           * @example
+                                                                           * ```ts
+                                                                           * const hash = await augustSdk.evm.vaultApprove({
+                                                                           *   target: '0x...',         // vault contract address
+                                                                           *   wallet: walletAddress,
+                                                                           *   amount: '100',           // 100 of the deposit token (UI units)
+                                                                           *   wait: true,              // wait for the approval to confirm
+                                                                           * });
+                                                                           * if (hash) console.log('approve tx', hash);
+                                                                           * // hash === undefined means the on-chain allowance already covers the
+                                                                           * // amount, or the deposit asset is native (msg.value, no allowance).
+                                                                           * ```
+                                                                           */
+                                                                          export declare function vaultApprove(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string | undefined>;
+
+                                                                          /**
+                                                                           * Deposit underlying token into the specified vault. Auto-routes to the
+                                                                           * correct contract path (single-asset ERC-4626, EVM-2 multi-asset,
+                                                                           * Paraswap adapter, native-token wrapper, depositWithPermit) based on the
+                                                                           * vault version and `depositAsset`.
+                                                                           *
+                                                                           * Amounts are encoded against the **deposit token's** decimals, not the
+                                                                           * vault's share decimals. The SDK reads the appropriate decimals via the
+                                                                           * vault metadata and the asset's ERC-20.
+                                                                           *
+                                                                           * Approval is handled automatically: if the existing allowance doesn't
+                                                                           * cover `amount`, an `approve` is sent and **always waited for** (regardless
+                                                                           * of the caller's `wait` flag) so the deposit tx can't be re-ordered ahead
+                                                                           * of the approval on Monad-style RPCs.
+                                                                           *
+                                                                           * @param signer ethers Signer / Wallet (or viem WalletClient via {@link setSigner})
+                                                                           * @param options Vault address, wallet, amount, optional `depositAsset` for
+                                                                           *   adapter routes, optional `wait` to wait for the deposit receipt.
+                                                                           * @returns Deposit transaction hash.
+                                                                           * @throws AugustValidationError on invalid wallet/target/amount or missing
+                                                                           *   adapter config when `depositAsset` differs from the vault underlying.
+                                                                           * @throws AugustSDKError when the deposit submission or on-chain call fails.
+                                                                           *
+                                                                           * @example
+                                                                           * ```ts
+                                                                           * const hash = await augustSdk.evm.vaultDeposit({
+                                                                           *   target: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32', // vault
+                                                                           *   wallet: walletAddress,
+                                                                           *   amount: '100',         // 100 USDC (UI units)
+                                                                           *   wait: true,            // wait for the deposit receipt
+                                                                           * });
+                                                                           * ```
+                                                                           *
+                                                                           * @example Adapter deposit (different deposit asset than the vault's underlying)
+                                                                           * ```ts
+                                                                           * await augustSdk.evm.vaultDeposit({
+                                                                           *   target: vaultAddress,
+                                                                           *   wallet: walletAddress,
+                                                                           *   amount: '0.5',
+                                                                           *   depositAsset: WETH_ADDRESS,   // swap WETH -> vault underlying via the adapter
+                                                                           *   chainId: 1,
+                                                                           * });
+                                                                           * ```
+                                                                           */
+                                                                          export declare function vaultDeposit(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
+
+                                                                          /**
+                                                                           * Check if vault has adapter support
+                                                                           */
+                                                                          export declare function vaultHasAdapter(vaultAddress: IAddress): boolean;
+
+                                                                          /**
+                                                                           * august_vault program IDL (Anchor).
+                                                                           *
+                                                                           * GENERATED — do not edit by hand. Source of truth is the program repo's build
+                                                                           * artifact: solana-vaults `frontend/idl/august_vault.json` (synced from the
+                                                                           * vendored program by `scripts/sync-idl.sh`). Regenerate from there, NOT with
+                                                                           * `anchor idl fetch`: an Anchor IDL upload is not refreshed by a program
+                                                                           * upgrade, so every IDL published for this program lineage is stale — both
+                                                                           * `up12…` on mainnet (last written 2026-01-21) and the `C8B1…` devnet reference
+                                                                           * (2026-01-23) predate the ProgramConfig build deployed on 2026-08-06.
+                                                                           *
+                                                                           * `address` is a build stamp (the mainnet id), NOT network-aware. Never rely on
+                                                                           * it: SolanaAdapter/getProgram resolve the real program id per network from
+                                                                           * programIds, or from an explicit `programId` override.
+                                                                           *
+                                                                           * Drift is guarded by tests/vaults/solana-idl-drift.test.ts: the deployed binary
+                                                                           * is pinned, every discriminator declared here must appear in that binary, and
+                                                                           * live VaultState accounts must decode against this file.
+                                                                           */
+                                                                          declare const vaultIdl: {
+                                                                              accounts: {
+                                                                                  discriminator: number[];
+                                                                                  name: string;
+                                                                              }[];
+                                                                              address: string;
+                                                                              errors: {
+                                                                                  code: number;
+                                                                                  msg: string;
+                                                                                  name: string;
+                                                                              }[];
+                                                                              events: {
+                                                                                  discriminator: number[];
+                                                                                  name: string;
+                                                                              }[];
+                                                                              instructions: ({
+                                                                                  accounts: ({
+                                                                                      name: string;
+                                                                                      signer: boolean;
+                                                                                      writable: boolean;
+                                                                                      docs?: undefined;
+                                                                                      pda?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      docs: string[];
+                                                                                      name: string;
+                                                                                      signer: boolean;
+                                                                                      writable: boolean;
+                                                                                      pda?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      docs: string[];
+                                                                                      name: string;
+                                                                                      writable: boolean;
+                                                                                      signer?: undefined;
+                                                                                      pda?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      docs: string[];
+                                                                                      name: string;
+                                                                                      signer?: undefined;
+                                                                                      writable?: undefined;
+                                                                                      pda?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      name: string;
+                                                                                      pda: {
+                                                                                          program: {
+                                                                                              kind: string;
+                                                                                              value: number[];
+                                                                                          };
+                                                                                          seeds: ({
+                                                                                              kind: string;
+                                                                                              value: number[];
+                                                                                              path?: undefined;
+                                                                                          } | {
+                                                                                              kind: string;
+                                                                                              path: string;
+                                                                                              value?: undefined;
+                                                                                          })[];
+                                                                                      };
+                                                                                      writable: boolean;
+                                                                                      signer?: undefined;
+                                                                                      docs?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      address: string;
+                                                                                      name: string;
+                                                                                      signer?: undefined;
+                                                                                      writable?: undefined;
+                                                                                      docs?: undefined;
+                                                                                      pda?: undefined;
+                                                                                  })[];
+                                                                                  args: {
+                                                                                      name: string;
+                                                                                      type: string;
+                                                                                  }[];
+                                                                                  discriminator: number[];
+                                                                                  docs: string[];
+                                                                                  name: string;
+                                                                              } | {
+                                                                                  accounts: ({
+                                                                                      docs: string[];
+                                                                                      name: string;
+                                                                                      pda: {
+                                                                                          seeds: {
+                                                                                              kind: string;
+                                                                                              value: number[];
+                                                                                          }[];
+                                                                                      };
+                                                                                      signer?: undefined;
+                                                                                      writable?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      docs: string[];
+                                                                                      name: string;
+                                                                                      signer: boolean;
+                                                                                      pda?: undefined;
+                                                                                      writable?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      docs: string[];
+                                                                                      name: string;
+                                                                                      signer: boolean;
+                                                                                      writable: boolean;
+                                                                                      pda?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      name: string;
+                                                                                      docs?: undefined;
+                                                                                      pda?: undefined;
+                                                                                      signer?: undefined;
+                                                                                      writable?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      name: string;
+                                                                                      writable: boolean;
+                                                                                      docs?: undefined;
+                                                                                      pda?: undefined;
+                                                                                      signer?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      address: string;
+                                                                                      name: string;
+                                                                                      docs?: undefined;
+                                                                                      pda?: undefined;
+                                                                                      signer?: undefined;
+                                                                                      writable?: undefined;
+                                                                                  })[];
+                                                                                  args: {
+                                                                                      name: string;
+                                                                                      type: string;
+                                                                                  }[];
+                                                                                  discriminator: number[];
+                                                                                  docs: string[];
+                                                                                  name: string;
+                                                                              } | {
+                                                                                  accounts: ({
+                                                                                      docs: string[];
+                                                                                      name: string;
+                                                                                      signer: boolean;
+                                                                                      pda?: undefined;
+                                                                                      writable?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      docs: string[];
+                                                                                      name: string;
+                                                                                      pda: {
+                                                                                          program: {
+                                                                                              kind: string;
+                                                                                              value: number[];
+                                                                                          };
+                                                                                          seeds: {
+                                                                                              kind: string;
+                                                                                              value: number[];
+                                                                                          }[];
+                                                                                      };
+                                                                                      signer?: undefined;
+                                                                                      writable?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      name: string;
+                                                                                      signer: boolean;
+                                                                                      writable: boolean;
+                                                                                      docs?: undefined;
+                                                                                      pda?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      name: string;
+                                                                                      pda: {
+                                                                                          seeds: {
+                                                                                              kind: string;
+                                                                                              value: number[];
+                                                                                          }[];
+                                                                                          program?: undefined;
+                                                                                      };
+                                                                                      writable: boolean;
+                                                                                      docs?: undefined;
+                                                                                      signer?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      address: string;
+                                                                                      name: string;
+                                                                                      docs?: undefined;
+                                                                                      signer?: undefined;
+                                                                                      pda?: undefined;
+                                                                                      writable?: undefined;
+                                                                                  })[];
+                                                                                  args: {
+                                                                                      name: string;
+                                                                                      type: string;
+                                                                                  }[];
+                                                                                  discriminator: number[];
+                                                                                  docs: string[];
+                                                                                  name: string;
+                                                                              } | {
+                                                                                  accounts: ({
+                                                                                      name: string;
+                                                                                      writable: boolean;
+                                                                                      signer?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      name: string;
+                                                                                      writable?: undefined;
+                                                                                      signer?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      name: string;
+                                                                                      signer: boolean;
+                                                                                      writable?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      name: string;
+                                                                                      signer: boolean;
+                                                                                      writable: boolean;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      address: string;
+                                                                                      name: string;
+                                                                                      writable?: undefined;
+                                                                                      signer?: undefined;
+                                                                                  })[];
+                                                                                  args: {
+                                                                                      name: string;
+                                                                                      type: string;
+                                                                                  }[];
+                                                                                  discriminator: number[];
+                                                                                  docs: string[];
+                                                                                  name: string;
+                                                                              } | {
+                                                                                  accounts: ({
+                                                                                      name: string;
+                                                                                      writable: boolean;
+                                                                                      pda?: undefined;
+                                                                                      signer?: undefined;
+                                                                                  } | {
+                                                                                      name: string;
+                                                                                      pda: {
+                                                                                          program: {
+                                                                                              kind: string;
+                                                                                              value: number[];
+                                                                                          };
+                                                                                          seeds: {
+                                                                                              kind: string;
+                                                                                              path: string;
+                                                                                          }[];
+                                                                                      };
+                                                                                      writable: boolean;
+                                                                                      signer?: undefined;
+                                                                                  } | {
+                                                                                      name: string;
+                                                                                      signer: boolean;
+                                                                                      writable?: undefined;
+                                                                                      pda?: undefined;
+                                                                                  } | {
+                                                                                      name: string;
+                                                                                      writable?: undefined;
+                                                                                      pda?: undefined;
+                                                                                      signer?: undefined;
+                                                                                  })[];
+                                                                                  args: {
+                                                                                      name: string;
+                                                                                      type: string;
+                                                                                  }[];
+                                                                                  discriminator: number[];
+                                                                                  docs: string[];
+                                                                                  name: string;
+                                                                              } | {
+                                                                                  accounts: ({
+                                                                                      name: string;
+                                                                                      pda: {
+                                                                                          seeds: {
+                                                                                              kind: string;
+                                                                                              value: number[];
+                                                                                          }[];
+                                                                                      };
+                                                                                      writable: boolean;
+                                                                                      signer?: undefined;
+                                                                                  } | {
+                                                                                      name: string;
+                                                                                      signer: boolean;
+                                                                                      pda?: undefined;
+                                                                                      writable?: undefined;
+                                                                                  })[];
+                                                                                  args: {
+                                                                                      name: string;
+                                                                                      type: string;
+                                                                                  }[];
+                                                                                  discriminator: number[];
+                                                                                  docs: string[];
+                                                                                  name: string;
+                                                                              } | {
+                                                                                  accounts: ({
+                                                                                      docs: string[];
+                                                                                      name: string;
+                                                                                      signer: boolean;
+                                                                                      writable?: undefined;
+                                                                                      pda?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      docs: string[];
+                                                                                      name: string;
+                                                                                      writable: boolean;
+                                                                                      signer?: undefined;
+                                                                                      pda?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      docs: string[];
+                                                                                      name: string;
+                                                                                      signer?: undefined;
+                                                                                      writable?: undefined;
+                                                                                      pda?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      name: string;
+                                                                                      pda: {
+                                                                                          program: {
+                                                                                              kind: string;
+                                                                                              value: number[];
+                                                                                          };
+                                                                                          seeds: ({
+                                                                                              kind: string;
+                                                                                              value: number[];
+                                                                                              path?: undefined;
+                                                                                          } | {
+                                                                                              kind: string;
+                                                                                              path: string;
+                                                                                              value?: undefined;
+                                                                                          })[];
+                                                                                      };
+                                                                                      writable: boolean;
+                                                                                      docs?: undefined;
+                                                                                      signer?: undefined;
+                                                                                      address?: undefined;
+                                                                                  } | {
+                                                                                      address: string;
+                                                                                      name: string;
+                                                                                      docs?: undefined;
+                                                                                      signer?: undefined;
+                                                                                      writable?: undefined;
+                                                                                      pda?: undefined;
+                                                                                  })[];
+                                                                                  args: {
+                                                                                      name: string;
+                                                                                      type: string;
+                                                                                  }[];
+                                                                                  discriminator: number[];
+                                                                                  docs: string[];
+                                                                                  name: string;
+                                                                              })[];
+                                                                              metadata: {
+                                                                                  description: string;
+                                                                                  name: string;
+                                                                                  spec: string;
+                                                                                  version: string;
+                                                                              };
+                                                                              types: ({
+                                                                                  name: string;
+                                                                                  repr: {
+                                                                                      kind: string;
+                                                                                  };
+                                                                                  serialization: string;
+                                                                                  type: {
+                                                                                      fields: {
+                                                                                          name: string;
+                                                                                          type: string;
+                                                                                      }[];
+                                                                                      kind: string;
+                                                                                  };
+                                                                                  docs?: undefined;
+                                                                              } | {
+                                                                                  docs: string[];
+                                                                                  name: string;
+                                                                                  type: {
+                                                                                      fields: ({
+                                                                                          docs: string[];
+                                                                                          name: string;
+                                                                                          type: string;
+                                                                                      } | {
+                                                                                          docs: string[];
+                                                                                          name: string;
+                                                                                          type: {
+                                                                                              array: (string | number)[];
+                                                                                          };
+                                                                                      })[];
+                                                                                      kind: string;
+                                                                                  };
+                                                                                  repr?: undefined;
+                                                                                  serialization?: undefined;
+                                                                              } | {
+                                                                                  name: string;
+                                                                                  type: {
+                                                                                      fields: ({
+                                                                                          name: string;
+                                                                                          type: string;
+                                                                                          docs?: undefined;
+                                                                                      } | {
+                                                                                          name: string;
+                                                                                          type: {
+                                                                                              array: (string | number)[];
+                                                                                          };
+                                                                                          docs?: undefined;
+                                                                                      } | {
+                                                                                          docs: string[];
+                                                                                          name: string;
+                                                                                          type: string;
+                                                                                      } | {
+                                                                                          docs: string[];
+                                                                                          name: string;
+                                                                                          type: {
+                                                                                              array: (string | number)[];
+                                                                                          };
+                                                                                      })[];
+                                                                                      kind: string;
+                                                                                  };
+                                                                                  repr?: undefined;
+                                                                                  serialization?: undefined;
+                                                                                  docs?: undefined;
+                                                                              })[];
+                                                                          };
+
+                                                                          /**
+                                                                           * @description withdraw funds from the specified pool including accrued rewards
+                                                                           * @param signer signer / wallet object
+                                                                           * @param options object including pool contract address, user wallet address, and more
+                                                                           * @returns claim tx hash
+                                                                           */
+                                                                          export declare function vaultRedeem(signer: Signer | Wallet, options: IContractWriteOptions & {
+                                                                              year: string;
+                                                                              month: string;
+                                                                              day: string;
+                                                                              receiverIndex: string;
+                                                                          }): Promise<string>;
+
+                                                                          export declare enum VaultRedemptionStatus {
+                                                                              AWAITING_COOLDOWN = "awaiting_cooldown",
+                                                                              READY_TO_CLAIM = "ready_to_claim"
+                                                                          }
+
+                                                                          /**
+                                                                           * Request to redeem vault shares. For EVM-1 vaults this queues a standard
+                                                                           * redemption (claimable later via `vaultRedeem`). For EVM-2 vaults the queued
+                                                                           * `requestRedeem` escrows the shares in the vault via `transferFrom`, so this
+                                                                           * also approves the receipt token when its allowance is short; the instant
+                                                                           * path (`isInstantRedeem: true`) burns the caller's shares directly and sends
+                                                                           * no approval.
+                                                                           *
+                                                                           * The receipt-token approval (EVM-2 queued path) is always waited on before
+                                                                           * the redeem call, regardless of the caller's `wait` flag.
+                                                                           *
+                                                                           * @param signer ethers Signer / Wallet (or viem WalletClient via {@link setSigner})
+                                                                           * @param options Vault address, wallet, amount, optional `isInstantRedeem`,
+                                                                           *   optional `wait` to wait for the redeem receipt.
+                                                                           * @returns Redeem transaction hash.
+                                                                           * @throws AugustValidationError on invalid wallet/target/amount.
+                                                                           * @throws AugustSDKError when the redeem submission or on-chain call fails.
+                                                                           *
+                                                                           * @example
+                                                                           * ```ts
+                                                                           * const hash = await augustSdk.evm.vaultRequestRedeem({
+                                                                           *   target: vaultAddress,
+                                                                           *   wallet: walletAddress,
+                                                                           *   amount: '10',           // 10 shares (UI units)
+                                                                           *   wait: true,
+                                                                           * });
+                                                                           * ```
+                                                                           *
+                                                                           * @example Instant redemption
+                                                                           * ```ts
+                                                                           * await augustSdk.evm.vaultRequestRedeem({
+                                                                           *   target: vaultAddress,
+                                                                           *   wallet: walletAddress,
+                                                                           *   amount: '10',
+                                                                           *   isInstantRedeem: true,
+                                                                           * });
+                                                                           * ```
+                                                                           */
+                                                                          export declare function vaultRequestRedeem(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
+
+                                                                          /**
+                                                                           * @deprecated Renamed to {@link SWAP_ROUTER_ELIGIBLE_VAULTS} (itself now
+                                                                           * superseded by {@link getSwapRouterEligibleVaults}, the on-chain-derived
+                                                                           * resolver), and the semantics changed: this set no longer drives
+                                                                           * `vaultDeposit` auto-routing (that branch was removed) — it only marks vaults
+                                                                           * whose UI may offer the swap-router deposit surface. Kept as an alias for one
+                                                                           * release; migrate to the async resolver.
+                                                                           */
+                                                                          export declare const VAULTS_USING_SWAP_ROUTER: ReadonlySet<string>;
+
+                                                                          /**
+                                                                           * Vault Receipt Symbol Mapping
+                                                                           * @deprecated use getVaultMetadata to fetch vault symbols from the backend
+                                                                           */
+                                                                          declare type VaultSymbols = 'predlp' | 'sentusd' | 'pregrid' | 'repouscc' | 'earnxrp' | 'tivkbtc' | 'tivusdt0' | 'supermon' | 'earnmon' | 'k3europ' | 'wmon/ausd' | 'wbtc/ausd' | 'earnausd_monad' | 'sausd' | 'farmbold' | 'sentuscc' | 'sentbtc' | 'svusdc' | 'apusdc' | 'testwethtsa' | 'tacusr' | 'upinjusdt' | 'tac-teth' | 'upausd' | 'taccbbtc' | 'xupusdc' | 'uptbtc' | 'gteth' | 'ageth' | 'upusdc' | 'hgeth' | 'upssylva' | 'hbbtc' | 'hbhype' | 'upazt' | 'susdt' | 'upedge' | 'coreusdc' | 'upcusdo' | 'shifteth' | 'upsusde' | 'uplbtc' | 'upavax' | 'tacrseth' | 'musd' | 'earnausd' | 'alpineusdcflagship' | 'alpinecoinshiftusdc' | 'upbtc' | 'upstrbtc' | 'maxiusr' | 'upgammausdc' | 'xhype' | 'wildusd' | 'alpinebtc' | 'prenusd' | 'upyzusd' | 'upnusd' | 'hlpe' | 'nemo eth yield';
+
+                                                                          /**
+                                                                           * @deprecated Renamed to {@link isSwapRouterEligible} (itself now superseded by
+                                                                           * {@link getSwapRouterEligibleVaults}, the on-chain-derived resolver). The
+                                                                           * meaning also changed: it no longer implies `vaultDeposit` routes the vault
+                                                                           * through the SwapRouter (that behavior was removed) — it only reports
+                                                                           * swap-router *eligibility* for the opt-in deposit surface. Kept as an alias
+                                                                           * for one release; migrate to the async resolver.
+                                                                           */
+                                                                          export declare const vaultUsesSwapRouter: typeof isSwapRouterEligible;
+
+                                                                          export declare function verifyAugustKey(key: string): Promise<boolean>;
+
+                                                                          export declare function verifyInfuraKey(key: string): Promise<boolean>;
+
+                                                                          /**
+                                                                           * Convert a viem WalletClient to an ethers-compatible Signer
+                                                                           * Uses the walletClient as a provider and wraps it for ethers compatibility
+                                                                           * @param walletClient Viem WalletClient from wagmi or viem
+                                                                           * @returns Ethers Signer that can be used with the SDK
+                                                                           */
+                                                                          export declare function viemToEthersSigner(walletClient: any): Promise<Signer | Wallet>;
+
+                                                                          /**
+                                                                           * @param walletClient a wagmi-derived client (from useWalletClient)
+                                                                           * @returns An ethers JsonRpcSigner object used in sdk.evm.setSigner
+                                                                           */
+                                                                          export declare function walletClientToSigner(walletClient: WalletClient): Promise<ethers.JsonRpcSigner>;
+
+                                                                          export declare const WEBSERVER_ENDPOINTS: {
+                                                                              default: {
+                                                                                  /** @deprecated No backend route. Removed in the next major release. */
+                                                                                  hello: string;
+                                                                                  protected: string;
+                                                                              };
+                                                                              auth: {
+                                                                                  verify: string;
+                                                                                  sign: string;
+                                                                                  login: string;
+                                                                                  nonce: string;
+                                                                                  refresh: string;
+                                                                              };
+                                                                              subaccount: {
+                                                                                  list: (offset?: number, limit?: number) => string;
+                                                                                  /** @deprecated No backend route. Removed in the next major release. */
+                                                                                  rewards: (subaccount: IAddress) => string;
+                                                                                  tokens: (subaccount: IAddress) => string;
+                                                                                  twap: {
+                                                                                      create: (subaccount: IAddress) => string;
+                                                                                      stop: (subaccount: IAddress, id: string) => string;
+                                                                                      fills: (subaccount: IAddress, id: string) => string;
+                                                                                  };
+                                                                                  debank: (subaccount: IAddress) => string;
+                                                                                  health_factor: (subaccount: IAddress) => string;
+                                                                                  summary: (subaccount: IAddress) => string;
+                                                                                  /** @deprecated No backend route. Removed in the next major release. */
+                                                                                  batch: (subaccount: IAddress) => string;
+                                                                                  loans: (subaccount: IAddress, side?: "BORROWER" | "LENDER" | "BOTH", active?: boolean) => string;
+                                                                                  cefi: (subaccount: IAddress) => string;
+                                                                                  otc_positions: (subaccount: IAddress) => string;
+                                                                                  loanByAddress: (loanAddress: string, chainId: number) => string;
+                                                                                  _: (subaccount: IAddress) => string;
+                                                                              };
+                                                                              transactions: {
+                                                                                  v2: (subaccount: string, startTime?: string, endTime?: string) => string;
+                                                                              };
+                                                                              otc: {
+                                                                                  positions: string;
+                                                                                  marginRequirements: (otcCounterpartyId?: string, payer?: string) => string;
+                                                                              };
+                                                                              curator: {
+                                                                                  vaultSubaccounts: (vaultAddress: string) => string;
+                                                                                  vaultWhitelist: (vaultAddress: string) => string;
+                                                                              };
+                                                                              timelockRequests: (vaultAddress: string, chainId: number, status?: string) => string;
+                                                                              users: {
+                                                                                  get: string;
+                                                                              };
+                                                                              dashboard: {
+                                                                                  loans: string;
+                                                                              };
+                                                                              risk: {
+                                                                                  discountFactors: string;
+                                                                                  collateralExcessOrDeficit: (subaccount: string, tokenAddress: string, tokenChain: number, targetHealthFactor?: number) => string;
+                                                                                  collateralSimulation: string;
+                                                                              };
+                                                                              prices: (symbol: string) => string;
+                                                                              metrics: {
+                                                                                  pnl: (subaccount: IAddress, startTime?: string, endTime?: string) => string;
+                                                                                  vaultPerformanceFees: (params: {
+                                                                                      vaultAddress: string;
+                                                                                      annualizedFeesPct: number;
+                                                                                      nativeDenominated: boolean;
+                                                                                      calculationPeriod: string;
+                                                                                      startDate?: string;
+                                                                                      endDate?: string;
+                                                                                  }) => string;
+                                                                              };
+                                                                              public: {
+                                                                                  integrations: {
+                                                                                      morpho: {
+                                                                                          apy: (subaccount: IAddress, vaultAddress: IAddress) => string;
+                                                                                      };
+                                                                                  };
+                                                                                  tokenizedVault: {
+                                                                                      loans: (vaultAddress: VaultAddress, chainId: number, active: boolean) => string;
+                                                                                      subaccountLoans: (vaultAddress: VaultAddress, chainId: number, active: boolean) => string;
+                                                                                      list: string;
+                                                                                      byVaultAddress: (vaultAddress: VaultAddress) => string;
+                                                                                      historicalApy: (vaultAddress: IAddress) => string;
+                                                                                      historicalTimeseries: (vaultAddress: IAddress, nDays?: number) => string;
+                                                                                      annualizedApy: (vaultAddress: IAddress) => string;
+                                                                                      summary: (vaultAddress: IAddress) => string;
+                                                                                      withdrawals: (chain: string, vaultAddress: IAddress) => string;
+                                                                                      debank: (vaultAddress: IAddress) => string;
+                                                                                      userHistory: (vaultAddress: IAddress, wallet: IAddress) => string;
+                                                                                      archivedVaults: string;
+                                                                                  };
+                                                                                  points: {
+                                                                                      byUserAddress: (userAddress: IAddress) => string;
+                                                                                      register: string;
+                                                                                      leaderboard: string;
+                                                                                  };
+                                                                                  vaults: {
+                                                                                      pendingRedemptions: (vaultAddress: IAddress) => string;
+                                                                                  };
+                                                                                  pnl: {
+                                                                                      unrealizedHistory: (vaultAddress: VaultAddress, limit?: number) => string;
+                                                                                      unrealizedLatest: string;
+                                                                                  };
+                                                                                  revertReason: (txHash: string, chain: number) => string;
+                                                                                  oracleClassification: (vaultAddress: string, chainId: number) => string;
+                                                                                  transparency: {
+                                                                                      positions: (vaultAddress: string, chainId: number) => string;
+                                                                                      historicalAllocations: (vaultAddress: string, chainId: number, startDate?: string, endDate?: string) => string;
+                                                                                      fees: (vaultAddress: string, chainId: number) => string;
+                                                                                      ratioSeries: (vaultAddress: string, startDate?: string, endDate?: string, limit?: number) => string;
+                                                                                      smoothedApy: (vaultAddress: string, daysAgo: number, averagingPeriodDays: number, applySmoothing: boolean) => string;
+                                                                                      governanceRoles: (vaultAddress: string, chainId: number) => string;
+                                                                                      governancePermissions: (vaultAddress: string, chainId: number) => string;
+                                                                                      governanceTimelocks: (vaultAddress: string, chainId: number, status?: string) => string;
+                                                                                      governanceAuditLog: (vaultAddress: string, chainId: number, category?: string, before?: string, limit?: number) => string;
+                                                                                  };
+                                                                              };
+                                                                              upshift: {
+                                                                                  vaults: {
+                                                                                      metadata: string;
+                                                                                  };
+                                                                              };
+                                                                          };
+
+                                                                          export declare const WEBSERVER_URL: {
+                                                                              production: string;
+                                                                              staging: string;
+                                                                              development: string;
+                                                                              localhost: string;
+                                                                              qa: string;
+                                                                              public: string;
+                                                                              upshift: string;
+                                                                          };
+
+                                                                          /**
+                                                                           * Withdrawal request with computed claimable date and current processing status.
+                                                                           * The unique identifier is (receiver, claimableDate).
+                                                                           *
+                                                                           * @interface WithdrawalRequestStatus
+                                                                           */
+                                                                          export declare interface WithdrawalRequestStatus {
+                                                                              /** Transaction hash of the withdrawal request */
+                                                                              transactionHash: string;
+                                                                              /** Block timestamp when the withdrawal was requested (seconds, UTC) */
+                                                                              requestTimestamp: number;
+                                                                              /** Shares amount being redeemed */
+                                                                              shares: bigint;
+                                                                              /** Receiver address for the withdrawal */
+                                                                              receiver: string;
+                                                                              /** Computed claimable date in UTC (year, month, day) */
+                                                                              claimableDate: {
+                                                                                  year: number;
+                                                                                  month: number;
+                                                                                  day: number;
+                                                                              };
+                                                                              /** Epoch timestamp when this withdrawal becomes claimable */
+                                                                              claimableEpoch: number;
+                                                                              /** Current status of the withdrawal */
+                                                                              status: 'pending' | 'ready_to_claim' | 'processed';
+                                                                              /** Transaction hash of the processing transaction (if processed) */
+                                                                              processedTransactionHash?: string;
+                                                                              /** Assets received (if processed) */
+                                                                              assetsReceived?: bigint;
+                                                                          }
+
+                                                                          /**
+                                                                           * Higher-order function to wrap SDK methods with performance tracking.
+                                                                           * Tracks method calls, timing, chain usage, and errors.
+                                                                           *
+                                                                           * @param methodName - Name of the method being wrapped
+                                                                           * @param method - The original async method
+                                                                           * @param getChainId - Function to get current chain ID
+                                                                           * @returns Wrapped method with tracking
+                                                                           */
+                                                                          export declare function withMethodTracking<T extends (...args: unknown[]) => Promise<unknown>>(methodName: string, method: T, getChainId?: () => number | undefined): T;
+
+                                                                          /**
+                                                                           * Wrap async operations with exponential backoff retry logic.
+                                                                           * Retries on network errors with increasing delays between attempts.
+                                                                           * @param fn - Async function to execute with retry logic
+                                                                           * @param maxRetries - Maximum number of retry attempts
+                                                                           * @param baseDelay - Initial delay in milliseconds (doubles each retry)
+                                                                           * @param shouldRetry - Custom function to determine if error is retryable
+                                                                           * @returns Result of successful function execution
+                                                                           * @throws Last error if all retries exhausted
+                                                                           */
+                                                                          export declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number, baseDelay?: number, shouldRetry?: (error: Error) => boolean): Promise<T>;
+
+                                                                          /**
+                                                                           * Higher-order function to wrap synchronous SDK methods with tracking.
+                                                                           * Uses breadcrumbs for tracking since spans require async context.
+                                                                           *
+                                                                           * @param methodName - Name of the method being wrapped
+                                                                           * @param method - The original sync method
+                                                                           * @param getChainId - Function to get current chain ID
+                                                                           * @returns Wrapped method with tracking
+                                                                           */
+                                                                          export declare function withSyncMethodTracking<T extends (...args: unknown[]) => unknown>(methodName: string, method: T, getChainId?: () => number | undefined): T;
+
+                                                                          export declare const WRAPPER_ADAPTOR: {
+                                                                              43114: IAddress;
+                                                                              1: IAddress;
+                                                                          };
+
+                                                                          /**
+                                                                           * Wrap an ethers signer so every transaction it sends carries the active
+                                                                           * ERC-8021 attribution suffix (Base Builder Codes).
+                                                                           *
+                                                                           * Every ethers write in the SDK funnels through the wrapped signer's
+                                                                           * `sendTransaction`, so this single wrap attributes all vault writes. The
+                                                                           * wrapper is a Proxy — the caller's signer object is never mutated, so a
+                                                                           * signer reused outside the SDK sends unattributed transactions. Attribution
+                                                                           * state is read at send time, not wrap time; when no attribution is
+                                                                           * configured (see `IAugustBase.attribution`) the wrapper is a pass-through.
+                                                                           *
+                                                                           * Plain value transfers (no calldata) are never attributed, and calldata
+                                                                           * already ending in the ERC-8021 marker is left untouched. When the
+                                                                           * configured `chains` list requires a chain check and the transaction does
+                                                                           * not carry a `chainId`, the signer's provider network is consulted (one
+                                                                           * cached RPC call); if that lookup fails the transaction is sent
+                                                                           * unattributed.
+                                                                           *
+                                                                           * @param signer Normalized ethers Signer or Wallet.
+                                                                           * @returns A proxied signer with an attribution-aware `sendTransaction`.
+                                                                           */
+                                                                          export declare function wrapSignerWithAttribution<T extends Signer | Wallet>(signer: T): T;
+
+                                                                          export { }