@augustdigital/sdk 8.11.0 → 8.12.0

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

@@ -1,5 +1,5 @@
 import { type IContractWriteOptions, type INativeDepositOptions, type ApproveResult } from '../../modules/vaults/write.actions';
-import type { ISwapAndDepositOptions, ISwapRouterDirectDepositOptions, ISwapRouterNativeDepositOptions, ISwapRouterDepositOptions } from '../../types';
+import type { ISwapAndDepositOptions, ISwapRouterDirectDepositOptions, ISwapRouterNativeDepositOptions, ISwapRouterDepositOptions, ISwapRouterDepositResultOptions } from '../../types';
 import { type IPreviewDepositOptions, type IPreviewRedeemOptions, type IAllowanceOptions, type IBalanceOfOptions, type IMaxDepositOptions } from '../../modules/vaults/read.actions';
 import { type CompatibleSigner } from '../../core/helpers/signer';
 import type { IAddress } from '../../types';
@@ -214,6 +214,22 @@ declare class EVMAdapter {
      * ```
      */
     swapRouterDeposit(options: ISwapRouterDepositOptions): Promise<string>;
+    /**
+     * Resolves the real, post-execution outcome of a SwapRouter deposit from
+     * its mined receipt — the actual amount that reached the vault (and shares
+     * minted), decoded from the vault's own `Deposit` event, rather than the
+     * pre-trade quote shown before submission.
+     *
+     * @param options - {@link ISwapRouterDepositResultOptions}.
+     * @returns The decoded {@link ISwapRouterDepositResult}, or `null` if the
+     *   receipt isn't found yet or carries no matching `Deposit` log.
+     * @example
+     * ```ts
+     * const hash = await augustSdk.evm.swapRouterDeposit({ ... });
+     * const result = await augustSdk.evm.getSwapRouterDepositResult({ txHash: hash, vault });
+     * ```
+     */
+    getSwapRouterDepositResult(options: ISwapRouterDepositResultOptions): Promise<import("../../types").ISwapRouterDepositResult>;
     /**
      * Claim assets from a matured redemption request on a dated-redemption
      * (RWA-style) vault. The `year`, `month`, `day`, and `receiverIndex` tuple

package/lib/adapters/evm/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const write_actions_1 = require("../../modules/vaults/write.actions");
+const swap_router_1 = require("../../core/helpers/swap-router");
 const read_actions_1 = require("../../modules/vaults/read.actions");
 const signer_1 = require("../../core/helpers/signer");
 __exportStar(require("./getters"), exports);
@@ -277,6 +278,25 @@ class EVMAdapter {
         const signer = await this.getSigner();
         return (0, write_actions_1.swapRouterDeposit)(signer, options);
     }
+    /**
+     * Resolves the real, post-execution outcome of a SwapRouter deposit from
+     * its mined receipt — the actual amount that reached the vault (and shares
+     * minted), decoded from the vault's own `Deposit` event, rather than the
+     * pre-trade quote shown before submission.
+     *
+     * @param options - {@link ISwapRouterDepositResultOptions}.
+     * @returns The decoded {@link ISwapRouterDepositResult}, or `null` if the
+     *   receipt isn't found yet or carries no matching `Deposit` log.
+     * @example
+     * ```ts
+     * const hash = await augustSdk.evm.swapRouterDeposit({ ... });
+     * const result = await augustSdk.evm.getSwapRouterDepositResult({ txHash: hash, vault });
+     * ```
+     */
+    async getSwapRouterDepositResult(options) {
+        const signer = await this.getSigner();
+        return (0, swap_router_1.getSwapRouterDepositResult)(signer, options);
+    }
     /**
      * Claim assets from a matured redemption request on a dated-redemption
      * (RWA-style) vault. The `year`, `month`, `day`, and `receiverIndex` tuple

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

@@ -39,6 +39,7 @@ exports.METHOD_CATEGORIES = {
     getVaultBorrowerHealthFactor: 'read.vault',
     getYieldLastRealizedOn: 'read.vault',
     getVaultActivity: 'read.vault',
+    getSwapRouterDepositResult: 'read.vault',
     getVaultPositions: 'read.position',
     getVaultUserHistory: 'read.position',
     getUserHistory: 'read.position',

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

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

package/lib/core/analytics/version.js

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

package/lib/core/constants/swap-router.d.ts

@@ -105,4 +105,6 @@ export declare const SWAP_ROUTER_DEX_AGGREGATOR: Readonly<Record<number, {
     router: IAddress;
     contractMethod: string;
     selector: `0x${string}`;
+    /** Human-readable aggregator name — for display; never derive routing logic from it. */
+    name: string;
 }>>;

package/lib/core/constants/swap-router.js

@@ -119,6 +119,7 @@ exports.SWAP_ROUTER_DEX_AGGREGATOR = {
         router: '0x6A000F20005980200259B80c5102003040001068',
         contractMethod: 'swapExactAmountIn',
         selector: '0xe3ead59e',
+        name: 'ParaSwap',
     },
 };
 //# sourceMappingURL=swap-router.js.map

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

@@ -47,6 +47,25 @@ export declare const ORACLE_CONTRACTS: {
 };
 export declare const NETWORKS: Record<IChainId, IChainObj>;
 export declare const AVAILABLE_CHAINS: IChainId[];
+/**
+ * Canonical [Multicall3](https://github.com/mds1/multicall) address, deployed
+ * via the deterministic deployer to the same address on most EVM chains.
+ * @internal
+ */
+export declare const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+/**
+ * Chains where the canonical Multicall3 deployment was **verified on-chain**
+ * (`eth_getCode` returned the 3808-byte runtime at {@link MULTICALL3_ADDRESS};
+ * checked per chain on 2026-07-14, Tempo checked separately on 2026-07-15) —
+ * deterministic-deployer presence is NOT assumed. Chains outside this set
+ * keep the per-call read path.
+ *
+ * Deliberately excluded from `NETWORKS`:
+ * - 4114 (Citrea) — `eth_getCode` returned `0x` (not deployed).
+ * - -1 (Solana), -3 (Stellar) — non-EVM, no Multicall3.
+ * @internal
+ */
+export declare const MULTICALL3_VERIFIED_CHAINS: ReadonlySet<number>;
 /**
  * Fallbacks
  */

package/lib/core/constants/web3.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FALLBACK_RPC_URLS = exports.FALLBACK_CHAINID = exports.FALLBACK_DECIMALS = exports.AVAILABLE_CHAINS = exports.NETWORKS = exports.ORACLE_CONTRACTS = exports.MIN_ABIS = exports.EVM_NATIVE_DECIMALS = exports.NATIVE_ADDRESS = exports.SPECIAL_CHAINS = void 0;
+exports.FALLBACK_RPC_URLS = exports.FALLBACK_CHAINID = exports.FALLBACK_DECIMALS = exports.MULTICALL3_VERIFIED_CHAINS = exports.MULTICALL3_ADDRESS = exports.AVAILABLE_CHAINS = exports.NETWORKS = exports.ORACLE_CONTRACTS = exports.MIN_ABIS = exports.EVM_NATIVE_DECIMALS = exports.NATIVE_ADDRESS = exports.SPECIAL_CHAINS = void 0;
 // Special Chains
 exports.SPECIAL_CHAINS = {
     solana: {
@@ -141,6 +141,42 @@ exports.NETWORKS = {
     },
 };
 exports.AVAILABLE_CHAINS = Object.keys(exports.NETWORKS).map((c) => Number(c));
+/**
+ * Canonical [Multicall3](https://github.com/mds1/multicall) address, deployed
+ * via the deterministic deployer to the same address on most EVM chains.
+ * @internal
+ */
+exports.MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+/**
+ * Chains where the canonical Multicall3 deployment was **verified on-chain**
+ * (`eth_getCode` returned the 3808-byte runtime at {@link MULTICALL3_ADDRESS};
+ * checked per chain on 2026-07-14, Tempo checked separately on 2026-07-15) —
+ * deterministic-deployer presence is NOT assumed. Chains outside this set
+ * keep the per-call read path.
+ *
+ * Deliberately excluded from `NETWORKS`:
+ * - 4114 (Citrea) — `eth_getCode` returned `0x` (not deployed).
+ * - -1 (Solana), -3 (Stellar) — non-EVM, no Multicall3.
+ * @internal
+ */
+exports.MULTICALL3_VERIFIED_CHAINS = new Set([
+    1, // Ethereum
+    42161, // Arbitrum One
+    8453, // Base
+    43114, // Avalanche
+    137, // Polygon
+    56, // BNB Smart Chain
+    999, // HyperEVM
+    130, // Unichain
+    31612, // Mezo
+    143, // Monad
+    9745, // Plasma
+    57073, // Ink
+    14, // Flare
+    747474, // Katana
+    25363, // Fluent
+    4217, // Tempo
+]);
 /**
  * Fallbacks
  */

package/lib/core/helpers/multicall.d.ts

@@ -0,0 +1,68 @@
+import { type InterfaceAbi } from 'ethers';
+import type { IAddress, IContractRunner } from '../../types';
+/**
+ * One read to fold into a Multicall3 `aggregate3` batch.
+ * @internal
+ */
+export interface IMulticall3Request {
+    /** Contract to call. */
+    target: IAddress;
+    /** ABI containing `functionName` (full or minimal fragment). */
+    abi: InterfaceAbi;
+    /** View function to encode. */
+    functionName: string;
+    /** Positional arguments for the function. */
+    args?: unknown[];
+}
+/**
+ * Per-call result of an `aggregate3` batch. `success: false` means that one
+ * call reverted (or its chunk failed at the transport level) — it never
+ * implies anything about the other calls in the batch.
+ * @internal
+ */
+export interface IMulticall3Result {
+    success: boolean;
+    /** First decoded return value; `undefined` when `success` is `false`. */
+    value?: unknown;
+}
+/**
+ * Calls per `aggregate3` chunk. Mirrors the `batchMaxCount: 10` cap on
+ * `createProvider` — some RPC providers (e.g. rpc.hypurrscan.io) enforce
+ * their own batch/response-size limits, so an unbounded batch for a wallet
+ * with many vaults risks exceeding response-size or `eth_call` gas ceilings.
+ * @internal
+ */
+export declare const MULTICALL3_BATCH_SIZE = 10;
+/**
+ * Whether Multicall3 read-aggregation is enabled for a chain. Only chains in
+ * {@link MULTICALL3_VERIFIED_CHAINS} (deployment verified via `eth_getCode`,
+ * never assumed) qualify — callers must fall back to individual reads for
+ * every other chain.
+ * @internal
+ */
+export declare function isMulticall3Supported(chainId: number | undefined): boolean;
+/**
+ * Aggregate independent view calls into chunked Multicall3 `aggregate3`
+ * batches (`allowFailure: true` per call).
+ *
+ * Failure semantics — the load-bearing detail:
+ * - A reverting inner call (paused/deprecated vault) yields `success: false`
+ *   for that call only; every other call in the batch decodes normally.
+ * - A transport-level failure of one chunk degrades that chunk's calls to
+ *   `success: false` instead of throwing, so a caller can always fall back
+ *   to its per-call path. This function never rejects for RPC reasons.
+ *
+ * RPC cost: `ceil(calls.length / batchSize)` `eth_call`s, versus
+ * `calls.length` without aggregation.
+ *
+ * @param provider Provider for the target chain.
+ * @param chainId Chain the provider is connected to — must be in the
+ *   verified allowlist; gate with {@link isMulticall3Supported} first.
+ * @param calls Reads to aggregate, in order.
+ * @param batchSize Max calls per `aggregate3` chunk.
+ * @returns One {@link IMulticall3Result} per request, index-aligned.
+ * @throws AugustValidationError when `chainId` is not on the verified
+ *   allowlist — programming error, not a runtime condition to swallow.
+ * @internal
+ */
+export declare function multicall3Aggregate(provider: IContractRunner, chainId: number, calls: IMulticall3Request[], batchSize?: number): Promise<IMulticall3Result[]>;

package/lib/core/helpers/multicall.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MULTICALL3_BATCH_SIZE = void 0;
+exports.isMulticall3Supported = isMulticall3Supported;
+exports.multicall3Aggregate = multicall3Aggregate;
+const ethers_1 = require("ethers");
+const Multicall3_1 = require("../../abis/Multicall3");
+const web3_1 = require("../constants/web3");
+const errors_1 = require("../errors");
+const logger_1 = require("../logger");
+/**
+ * Calls per `aggregate3` chunk. Mirrors the `batchMaxCount: 10` cap on
+ * `createProvider` — some RPC providers (e.g. rpc.hypurrscan.io) enforce
+ * their own batch/response-size limits, so an unbounded batch for a wallet
+ * with many vaults risks exceeding response-size or `eth_call` gas ceilings.
+ * @internal
+ */
+exports.MULTICALL3_BATCH_SIZE = 10;
+/**
+ * Whether Multicall3 read-aggregation is enabled for a chain. Only chains in
+ * {@link MULTICALL3_VERIFIED_CHAINS} (deployment verified via `eth_getCode`,
+ * never assumed) qualify — callers must fall back to individual reads for
+ * every other chain.
+ * @internal
+ */
+function isMulticall3Supported(chainId) {
+    return typeof chainId === 'number' && web3_1.MULTICALL3_VERIFIED_CHAINS.has(chainId);
+}
+/**
+ * Aggregate independent view calls into chunked Multicall3 `aggregate3`
+ * batches (`allowFailure: true` per call).
+ *
+ * Failure semantics — the load-bearing detail:
+ * - A reverting inner call (paused/deprecated vault) yields `success: false`
+ *   for that call only; every other call in the batch decodes normally.
+ * - A transport-level failure of one chunk degrades that chunk's calls to
+ *   `success: false` instead of throwing, so a caller can always fall back
+ *   to its per-call path. This function never rejects for RPC reasons.
+ *
+ * RPC cost: `ceil(calls.length / batchSize)` `eth_call`s, versus
+ * `calls.length` without aggregation.
+ *
+ * @param provider Provider for the target chain.
+ * @param chainId Chain the provider is connected to — must be in the
+ *   verified allowlist; gate with {@link isMulticall3Supported} first.
+ * @param calls Reads to aggregate, in order.
+ * @param batchSize Max calls per `aggregate3` chunk.
+ * @returns One {@link IMulticall3Result} per request, index-aligned.
+ * @throws AugustValidationError when `chainId` is not on the verified
+ *   allowlist — programming error, not a runtime condition to swallow.
+ * @internal
+ */
+async function multicall3Aggregate(provider, chainId, calls, batchSize = exports.MULTICALL3_BATCH_SIZE) {
+    if (!isMulticall3Supported(chainId)) {
+        throw new errors_1.AugustValidationError('INVALID_INPUT', `multicall3Aggregate: Multicall3 deployment is not verified on chain ${chainId} — use the per-call read path instead`);
+    }
+    if (calls.length === 0)
+        return [];
+    const encoded = calls.map((c) => {
+        const iface = new ethers_1.Interface(c.abi);
+        return {
+            target: c.target,
+            allowFailure: true,
+            callData: iface.encodeFunctionData(c.functionName, c.args ?? []),
+            iface,
+            functionName: c.functionName,
+        };
+    });
+    const chunks = [];
+    for (let i = 0; i < encoded.length; i += batchSize) {
+        chunks.push(encoded.slice(i, i + batchSize));
+    }
+    const multicall = new ethers_1.Contract(web3_1.MULTICALL3_ADDRESS, Multicall3_1.ABI_MULTICALL3, provider);
+    const chunkResults = await Promise.all(chunks.map(async (chunk) => {
+        try {
+            const returned = (await multicall.aggregate3(chunk.map((c) => ({
+                target: c.target,
+                allowFailure: c.allowFailure,
+                callData: c.callData,
+            }))));
+            return chunk.map((c, i) => {
+                const r = returned[i];
+                if (!r?.success || !r.returnData || r.returnData === '0x') {
+                    return { success: false, value: undefined };
+                }
+                try {
+                    const decoded = c.iface.decodeFunctionResult(c.functionName, r.returnData);
+                    return { success: true, value: decoded[0] };
+                }
+                catch (decodeError) {
+                    logger_1.Logger.log.warn('multicall3Aggregate', `failed to decode ${c.functionName} result for ${c.target}`, decodeError);
+                    return { success: false, value: undefined };
+                }
+            });
+        }
+        catch (chunkError) {
+            logger_1.Logger.log.warn('multicall3Aggregate', `aggregate3 chunk failed on chain ${chainId} (${chunk.length} calls) — callers fall back to per-call reads`, chunkError);
+            return chunk.map(() => ({ success: false, value: undefined }));
+        }
+    }));
+    return chunkResults.flat();
+}
+//# sourceMappingURL=multicall.js.map

package/lib/core/helpers/swap-router.d.ts

@@ -1,4 +1,5 @@
-import type { IAddress } from '../../types';
+import { type Signer, type Wallet } from 'ethers';
+import type { IAddress, ISwapRouterDepositResult, ISwapRouterDepositResultOptions } from '../../types';
 /**
  * Resolve the `SwapRouter` address for a chain.
  *
@@ -46,3 +47,37 @@ export declare const vaultUsesSwapRouter: typeof isSwapRouterEligible;
  * @throws {@link AugustValidationError} when `provided` is not a 32-byte hex string.
  */
 export declare function resolveOriginCode(provided?: `0x${string}`): `0x${string}`;
+/**
+ * Resolves the real, post-execution outcome of a SwapRouter deposit from its
+ * mined transaction receipt. The SwapRouter contract itself emits no
+ * deposit/amount-out event — only the vault does, via its own `Deposit` event
+ * — so this decodes that log directly rather than trusting the pre-trade quote
+ * a UI shows before the user submits (the true post-swap amount depends on
+ * execution-time price and can differ from that estimate).
+ *
+ * Works for both vault generations without the caller resolving the version
+ * first: evm-1 (ERC-4626-style `Deposit(sender, owner, assets, shares)`) and
+ * evm-2 (`Deposit(assetIn, amountIn, shares, senderAddr, receiverAddr)`) have
+ * different event signatures (different topic0), so both are registered and
+ * whichever matches the vault's actual log is decoded.
+ *
+ * @param signer - ethers `Signer` or `Wallet` connected to a provider (used
+ *   read-only here — no transaction is sent).
+ * @param options - {@link ISwapRouterDepositResultOptions}.
+ * @returns The decoded {@link ISwapRouterDepositResult}, or `null` if the
+ *   receipt isn't found yet or carries no `Deposit` log from `vault` (e.g. the
+ *   hash is wrong, or the tx hasn't mined).
+ * @throws {@link AugustValidationError} if `signer` has no connected provider.
+ * @worstCaseRpcCalls 1 — a single `getTransactionReceipt` call; decoding is
+ *   local.
+ * @example
+ * ```ts
+ * const hash = await augustSdk.evm.swapRouterDeposit({ ... });
+ * const result = await augustSdk.evm.getSwapRouterDepositResult({
+ *   txHash: hash,
+ *   vault: '0x74ad2f789ed583dbd141bbdafc673fe1f033718b',
+ * });
+ * // result?.amountOut — actual reference-asset amount received after the swap
+ * ```
+ */
+export declare function getSwapRouterDepositResult(signer: Signer | Wallet, { txHash, vault }: ISwapRouterDepositResultOptions): Promise<ISwapRouterDepositResult | null>;

package/lib/core/helpers/swap-router.js

@@ -4,6 +4,8 @@ exports.vaultUsesSwapRouter = void 0;
 exports.getSwapRouterAddress = getSwapRouterAddress;
 exports.isSwapRouterEligible = isSwapRouterEligible;
 exports.resolveOriginCode = resolveOriginCode;
+exports.getSwapRouterDepositResult = getSwapRouterDepositResult;
+const ethers_1 = require("ethers");
 const swap_router_1 = require("../constants/swap-router");
 const errors_1 = require("../errors");
 /**
@@ -64,4 +66,82 @@ function resolveOriginCode(provided) {
     }
     return provided;
 }
+/**
+ * Resolves the real, post-execution outcome of a SwapRouter deposit from its
+ * mined transaction receipt. The SwapRouter contract itself emits no
+ * deposit/amount-out event — only the vault does, via its own `Deposit` event
+ * — so this decodes that log directly rather than trusting the pre-trade quote
+ * a UI shows before the user submits (the true post-swap amount depends on
+ * execution-time price and can differ from that estimate).
+ *
+ * Works for both vault generations without the caller resolving the version
+ * first: evm-1 (ERC-4626-style `Deposit(sender, owner, assets, shares)`) and
+ * evm-2 (`Deposit(assetIn, amountIn, shares, senderAddr, receiverAddr)`) have
+ * different event signatures (different topic0), so both are registered and
+ * whichever matches the vault's actual log is decoded.
+ *
+ * @param signer - ethers `Signer` or `Wallet` connected to a provider (used
+ *   read-only here — no transaction is sent).
+ * @param options - {@link ISwapRouterDepositResultOptions}.
+ * @returns The decoded {@link ISwapRouterDepositResult}, or `null` if the
+ *   receipt isn't found yet or carries no `Deposit` log from `vault` (e.g. the
+ *   hash is wrong, or the tx hasn't mined).
+ * @throws {@link AugustValidationError} if `signer` has no connected provider.
+ * @worstCaseRpcCalls 1 — a single `getTransactionReceipt` call; decoding is
+ *   local.
+ * @example
+ * ```ts
+ * const hash = await augustSdk.evm.swapRouterDeposit({ ... });
+ * const result = await augustSdk.evm.getSwapRouterDepositResult({
+ *   txHash: hash,
+ *   vault: '0x74ad2f789ed583dbd141bbdafc673fe1f033718b',
+ * });
+ * // result?.amountOut — actual reference-asset amount received after the swap
+ * ```
+ */
+async function getSwapRouterDepositResult(signer, { txHash, vault }) {
+    const provider = signer.provider;
+    if (!provider) {
+        throw new errors_1.AugustValidationError('INVALID_INPUT', 'getSwapRouterDepositResult: signer has no connected provider');
+    }
+    const receipt = await provider.getTransactionReceipt(txHash);
+    if (!receipt)
+        return null;
+    const iface = new ethers_1.ethers.Interface([
+        'event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares)',
+        'event Deposit(address assetIn, uint256 amountIn, uint256 shares, address indexed senderAddr, address indexed receiverAddr)',
+    ]);
+    for (const log of receipt.logs) {
+        if (log.address.toLowerCase() !== vault.toLowerCase())
+            continue;
+        let parsed;
+        try {
+            parsed = iface.parseLog(log);
+        }
+        catch {
+            continue;
+        }
+        if (parsed?.name !== 'Deposit')
+            continue;
+        // Discriminate on the matched event fragment, not on probing a
+        // possibly-absent named arg. Only the evm-2 signature declares `assetIn`,
+        // so its presence in the fragment inputs uniquely identifies the version.
+        // (Reading `parsed.args.assetIn` on the evm-1 log would couple correctness
+        // to ethers' `Result`-proxy behavior for unknown names.)
+        const isEvm2 = parsed.fragment.inputs.some((i) => i.name === 'assetIn');
+        if (isEvm2) {
+            // evm-2 TokenizedVault: Deposit(assetIn, amountIn, shares, sender, receiver)
+            return {
+                amountOut: BigInt(parsed.args.amountIn),
+                sharesOut: BigInt(parsed.args.shares),
+            };
+        }
+        // evm-1 ERC-4626-style: Deposit(sender, owner, assets, shares)
+        return {
+            amountOut: BigInt(parsed.args.assets),
+            sharesOut: BigInt(parsed.args.shares),
+        };
+    }
+    return null;
+}
 //# sourceMappingURL=swap-router.js.map

package/lib/core/helpers/vault-version.d.ts

@@ -2,4 +2,7 @@ import type { ITokenizedVault, IVaultVersion, ChainType } from '../../types';
 /** Classify an address by chain family (evm / solana / stellar / sui). */
 export declare function getAddressChainType(address: string): ChainType;
 export declare function getVaultVersion(vault: string): IVaultVersion | undefined;
-export declare function getVaultVersionV2(vault: ITokenizedVault): IVaultVersion | undefined;
+export declare function getVaultVersionV2(vault: (Pick<ITokenizedVault, 'address'> & {
+    chain_type?: string;
+    internal_type?: string;
+}) | undefined | null): IVaultVersion | undefined;

package/lib/core/helpers/vaults.d.ts

@@ -8,7 +8,7 @@ export declare const isBadVault: (address?: string) => boolean;
 import { getAddressChainType, getVaultVersion, getVaultVersionV2 } from './vault-version';
 export { getAddressChainType, getVaultVersion, getVaultVersionV2 };
 export declare const REWARD_DISTRIBUTOR_ADDRESS: (chainId: number) => string[];
-export declare const AVAX_PRICE_FEED_ADDRESS: (chainId: number) => "0xFF3EEb22B5E3dE6e705b44749C2559d704923FD7" | "0x";
+export declare const AVAX_PRICE_FEED_ADDRESS: (chainId: number) => "0x" | "0xFF3EEb22B5E3dE6e705b44749C2559d704923FD7";
 export declare function getVaultSymbol(vault: IAddress, provider: IContractRunner): Promise<string | undefined>;
 /**
  * @deprecated

package/lib/core/index.d.ts

@@ -11,6 +11,7 @@ export * from './constants/web3';
 export * from './constants/vaults';
 export * from './constants/swap-router';
 export * from './helpers/web3';
+export * from './helpers/multicall';
 export * from './helpers/vaults';
 export * from './helpers/chain-error';
 export * from './helpers/core';

package/lib/core/index.js

@@ -27,6 +27,7 @@ __exportStar(require("./constants/web3"), exports);
 __exportStar(require("./constants/vaults"), exports);
 __exportStar(require("./constants/swap-router"), exports);
 __exportStar(require("./helpers/web3"), exports);
+__exportStar(require("./helpers/multicall"), exports);
 __exportStar(require("./helpers/vaults"), exports);
 __exportStar(require("./helpers/chain-error"), exports);
 __exportStar(require("./helpers/core"), exports);

package/lib/modules/vaults/getters.d.ts

@@ -53,12 +53,22 @@ export declare function getVaultSubaccountLoans(vault: VaultAddress | IVault, op
  * @returns Detailed allocation data with exposure categorization
  */
 export declare function getVaultAllocations(vault: IAddress, options: IVaultBaseOptions): Promise<IVaultAllocations>;
-export declare function getVaultAvailableRedemptions({ vault, wallet, options, }: {
+export declare function getVaultAvailableRedemptions({ vault, wallet, options, prefetchedReads, }: {
     vault: IAddress;
     wallet?: IAddress;
     options: IVaultBaseOptions & {
         verbose?: boolean;
     };
+    /**
+     * Values already read via a Multicall3 batch (see
+     * `modules/vaults/prefetch.ts`). When `lagDuration` is present the
+     * per-vault `lagDuration()` RPC is skipped; when omitted, behavior is
+     * exactly the pre-batching per-call path.
+     * @internal
+     */
+    prefetchedReads?: {
+        lagDuration?: number;
+    };
 }): Promise<{
     processedWithdrawals: ISubgraphWithdrawProccessed[];
     requestedWithdrawals: import("../../types").ISubgraphWithdrawRequest[];
@@ -71,15 +81,28 @@ export declare function getVaultRedemptionHistory({ vault, wallet, lookbackBlock
     lookbackBlocks?: number;
     options: IVaultBaseOptions;
 }): Promise<IVaultRedemptionHistoryItem[]>;
+export { getSwapRouterDepositResult } from '../../core/helpers/swap-router';
 /**
  * Vault Positions
  */
-export declare function getVaultPositions({ vault, wallet, solanaWallet, stellarWallet, options, }: {
+export declare function getVaultPositions({ vault, wallet, solanaWallet, stellarWallet, options, prefetchedReads, }: {
     vault: IAddress;
     wallet?: IAddress;
     solanaWallet?: string;
     stellarWallet?: string;
     options: IVaultBaseOptions;
+    /**
+     * Per-vault values already read via a Multicall3 batch at the fan-out call
+     * sites (see `modules/vaults/prefetch.ts`). Supplied fields skip the
+     * corresponding `balanceOf` / `lagDuration` RPC for the vault matching the
+     * `vault` parameter; when omitted, behavior is exactly the pre-batching
+     * per-call path.
+     * @internal
+     */
+    prefetchedReads?: {
+        balance?: bigint;
+        lagDuration?: number;
+    };
 }): Promise<IVaultPosition[]>;
 /**
  * @deprecated use getVaultHistoricalTimeseries instead