@augustdigital/sdk 8.6.1 → 8.7.1

package/lib/modules/vaults/main.js

@@ -771,24 +771,34 @@ class AugustVaults extends core_1.AugustBase {
             }
             return formattedStandard;
         };
-        // If vault is provided, return history for that vault
+        // If vault is provided, return history for that vault. This path is
+        // EVM-only (see fetchVaultHistory → getSubgraphUserHistory); a non-EVM
+        // vault address would drive eth_chainId against a Solana/Stellar RPC.
         if (vault) {
-            finalArray = await fetchVaultHistory(vault, chainId);
+            finalArray = (0, ethers_1.isAddress)(vault)
+                ? await fetchVaultHistory(vault, chainId)
+                : [];
         }
         else {
             // Fetch all vaults
             const allVaults = await (0, core_1.fetchTokenizedVaults)(undefined, this.headers, false, false);
-            // If chainId is provided, return history for all vaults on that chain
+            // If chainId is provided, return history for all vaults on that chain.
+            // EVM-only: skip non-EVM (Solana/Stellar) vault addresses.
             if (chainId) {
-                const vaultsPerChain = allVaults.filter((v) => v.chain === chainId);
+                const vaultsPerChain = allVaults.filter((v) => v.chain === chainId && (0, ethers_1.isAddress)(v.address));
                 const vaultResponses = await Promise.all(vaultsPerChain.map((v) => fetchVaultHistory(v.address, v.chain)));
                 const flattened = vaultResponses.flat();
                 finalArray = flattened;
             }
             else {
-                // Else, fetch all history for all vaults across all initialized chains
-                // LayerZero vaults query subgraphs directly and don't need a provider
-                const vaultsPerAvailableProviders = allVaults.filter((v) => this.providers?.[v?.chain] || (0, deposits_1.isLayerZeroVault)(v.address));
+                // Else, fetch all history for all vaults across all initialized chains.
+                // Gate on isAddress(v.address): the Solana provider is registered under
+                // chainId -1, so without this a Solana vault passes `providers?.[v.chain]`
+                // and gets routed into the EVM subgraph path, throwing
+                // "eth_chainId is not available on SOLANA_MAINNET" on every fetch.
+                // LayerZero vaults query subgraphs directly and don't need a provider.
+                const vaultsPerAvailableProviders = allVaults.filter((v) => (0, ethers_1.isAddress)(v.address) &&
+                    (this.providers?.[v?.chain] || (0, deposits_1.isLayerZeroVault)(v.address)));
                 const vaultResponses = await Promise.all(vaultsPerAvailableProviders.map((v) => fetchVaultHistory(v.address, v.chain)));
                 const flattened = vaultResponses.flat();
                 finalArray = flattened;
@@ -905,6 +915,77 @@ class AugustVaults extends core_1.AugustBase {
         core_1.Logger.log.info('getUserTransfers', `${wallet}::${finalArray.length}`);
         return finalArray;
     }
+    /**
+     * Fetch a vault's deposit/withdrawal activity across every participant.
+     *
+     * This is the vault-wide counterpart to {@link getUserHistory}: instead of
+     * filtering the subgraph to one wallet, it returns every deposit,
+     * withdrawal-request, and processed-withdrawal event for the pool. Use it to
+     * answer flow questions ("how many deposits in the last 7 days", "net flow
+     * this week") that point-in-time TVL cannot.
+     *
+     * Rows are read from the Goldsky subgraph, paginated internally so busy
+     * vaults are not truncated at the 1000-row page cap. When `sinceTs` is
+     * supplied the reader stops paging once it passes the window boundary, so a
+     * short lookback stays cheap even on high-volume vaults.
+     *
+     * @param params - Query parameters.
+     * @param params.vault - Vault (pool) address to read activity for.
+     * @param params.chainId - Chain id of the vault; falls back to the active
+     * network when omitted. Required for the subgraph lookup.
+     * @param params.sinceTs - Lower bound (inclusive) as a Unix timestamp in
+     * seconds. Events at or after this time are returned.
+     * @param params.untilTs - Upper bound (inclusive) as a Unix timestamp in
+     * seconds. Events at or before this time are returned.
+     * @param params.types - Restrict to a subset of event types (e.g.
+     * `['deposit']`). Returns all types when omitted.
+     * @returns Activity items sorted oldest-first, each with a normalized
+     * `amount`, actor `address`, `type`, and `transactionHash`.
+     * @throws If `vault` is not a valid address, or no chain id can be resolved.
+     * @example
+     * ```ts
+     * const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86_400;
+     * const deposits = await sdk.getVaultActivity({
+     *   vault: '0x36eDbF0C834591BFdfCaC0Ef9605528c75c406aA',
+     *   chainId: 143,
+     *   sinceTs: weekAgo,
+     *   types: ['deposit'],
+     * });
+     * console.log(`${deposits.length} deposits in the last 7 days`);
+     * ```
+     */
+    async getVaultActivity({ vault, chainId, sinceTs, untilTs, types, }) {
+        if (!(0, ethers_1.isAddress)(vault))
+            throw new Error(`Vault parameter is not an address: ${String(vault)}`);
+        const _chainId = chainId || this.activeNetwork?.chainId;
+        if (!_chainId) {
+            throw new Error('Chain ID is required for getVaultActivity. Pass chainId explicitly or configure an active network.');
+        }
+        const provider = (0, core_1.createProvider)(this.providers?.[_chainId]);
+        const raw = await (0, vaults_1.getSubgraphVaultHistory)(provider, vault, undefined, {
+            sinceTs,
+        });
+        const typeFilter = types?.length ? new Set(types) : undefined;
+        return raw
+            .map((h) => ({
+            timestamp: Number(h.timestamp_),
+            address: h.address,
+            amount: (0, core_1.toNormalizedBn)(BigInt(h.amount), h.decimals),
+            pool: h.contractId_,
+            chainId: _chainId,
+            type: h.type,
+            transactionHash: h.transactionHash_,
+        }))
+            .filter((h) => {
+            if (sinceTs !== undefined && h.timestamp < sinceTs)
+                return false;
+            if (untilTs !== undefined && h.timestamp > untilTs)
+                return false;
+            if (typeFilter && !typeFilter.has(h.type))
+                return false;
+            return true;
+        });
+    }
     /**
      * @function getStakingPositions gets all available reward staking positions
      * @param wallet optionally passed user wallet address

package/lib/modules/vaults/write.actions.d.ts

@@ -1,6 +1,6 @@
 import { type Signer, type Wallet, type TransactionResponse } from 'ethers';
 import type { IAddress } from '../../types';
-import type { ISwapAndDepositOptions, ISwapRouterDirectDepositOptions, ISwapRouterNativeDepositOptions } from '../../types';
+import type { ISwapAndDepositOptions, ISwapRouterDirectDepositOptions, ISwapRouterNativeDepositOptions, ISwapRouterDepositOptions } from '../../types';
 export type IContractWriteOptions = {
     target: IAddress;
     wallet: IAddress;
@@ -76,7 +76,6 @@ export declare function resolveSpender(args: {
     isMultiAssetVault: boolean;
     isAdapterDeposit: boolean;
     adapterWrapperAddress?: IAddress;
-    swapRouterAddress?: IAddress;
 }): IAddress;
 /** @internal */
 export declare function validateAmountPrecision(amount: string | bigint | number): void;
@@ -438,3 +437,53 @@ export declare function depositViaSwapRouter(signer: Signer | Wallet, options: I
  * addresses, or zero amount.
  */
 export declare function depositNativeViaSwapRouter(signer: Signer | Wallet, options: ISwapRouterNativeDepositOptions): Promise<string>;
+/**
+ * Deposit into an August vault through the on-chain `SwapRouter`, selecting the
+ * correct router path from the deposit asset. This is the high-level, explicit
+ * counterpart to the SwapRouter branch inside {@link vaultDeposit}.
+ *
+ * Where `vaultDeposit` decides whether to use the SwapRouter from the
+ * `VAULTS_USING_SWAP_ROUTER` allowlist, this function always routes through the
+ * SwapRouter because the caller asked it to. Making the intent explicit is the
+ * point: a native-deposit vault (e.g. a multi-asset Tokenized Vault V2 whose
+ * non-reference assets are accepted directly) is never accidentally swapped —
+ * the regression that implicit, allowlist-driven routing caused. Use
+ * `vaultDeposit` for native / adapter deposits and this for SwapRouter deposits.
+ *
+ * The vault's reference asset and its decimals are read on-chain (never trusted
+ * from the caller — a wrong reference asset would mis-route the swap). The path
+ * is then chosen from `depositAsset`:
+ *  - equals the reference asset → direct router deposit, no swap
+ *    ({@link depositViaSwapRouter});
+ *  - the zero address → native-token deposit ({@link depositNativeViaSwapRouter}),
+ *    valid only when the reference asset is the chain's wrapped-native token;
+ *  - any other ERC-20 → a swap to the reference asset (Paraswap quote pinned to
+ *    the chain's whitelisted aggregator, fail-closed on router/selector drift)
+ *    bundled into {@link swapAndDeposit}.
+ *
+ * Side effects: reads tokenized-vault metadata, the vault's reference asset and
+ * decimals, and (on the swap path) one Paraswap quote; sends one ERC-20
+ * `approve` to the SwapRouter when allowance is short, then the deposit tx.
+ *
+ * @param signer - ethers `Signer` or `Wallet` that signs the approval + deposit.
+ * @param options - {@link ISwapRouterDepositOptions}.
+ * @returns The transaction hash of the router deposit call.
+ * @throws {@link AugustValidationError} for an unsupported chain (no SwapRouter
+ *   deployment), an invalid vault or deposit-asset address, a missing or zero
+ *   amount, a native deposit into a non-wrapped-native vault, or drift between
+ *   the aggregator quote and the on-chain router whitelist.
+ * @worstCaseRpcCalls 5 on the swap path — tokenized-vault metadata, reference
+ *   asset + decimals, deposit-token decimals, the quote, and the allowance read.
+ * @example
+ * ```ts
+ * // USDT deposited into a USDC-reference vault → swapped to USDC en route.
+ * const hash = await augustSdk.evm.swapRouterDeposit({
+ *   chainId: 1,
+ *   vault: '0xe9b725010a9e419412ed67d0fa5f3a5f40159d32',
+ *   depositAsset: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+ *   amount: '100',
+ *   slippageBps: 50,
+ * });
+ * ```
+ */
+export declare function swapRouterDeposit(signer: Signer | Wallet, options: ISwapRouterDepositOptions): Promise<string>;

package/lib/modules/vaults/write.actions.js

@@ -18,6 +18,7 @@ exports.rwaRedeemAsset = rwaRedeemAsset;
 exports.swapAndDeposit = swapAndDeposit;
 exports.depositViaSwapRouter = depositViaSwapRouter;
 exports.depositNativeViaSwapRouter = depositNativeViaSwapRouter;
+exports.swapRouterDeposit = swapRouterDeposit;
 const ethers_1 = require("ethers");
 const abis_1 = require("../../abis");
 const core_1 = require("../../core");
@@ -64,8 +65,6 @@ async function resolveDepositTokenDecimals(args) {
 }
 /** @internal */
 function resolveSpender(args) {
-    if (args.swapRouterAddress)
-        return args.swapRouterAddress;
     if (args.isMultiAssetVault)
         return args.target;
     if (args.isAdapterDeposit && args.adapterWrapperAddress)
@@ -245,16 +244,11 @@ async function approveCore(signer, options) {
         if (isNativeToken)
             return { kind: 'native' };
         const isAdapterDeposit = actualDepositAsset.toLowerCase() !== underlyingAsset.toLowerCase();
-        const resolvedChainId = options.chainId ?? tokenizedVault?.chain;
-        const swapRouterAddress = resolvedChainId !== undefined && (0, core_1.vaultUsesSwapRouter)(target)
-            ? (0, core_1.getSwapRouterAddress)(resolvedChainId)
-            : undefined;
         const spenderAddress = resolveSpender({
             target,
             isMultiAssetVault,
             isAdapterDeposit,
             adapterWrapperAddress: adapterConfig?.wrapperAddress,
-            swapRouterAddress,
         });
         const depositTokenDecimals = await resolveDepositTokenDecimals({
             actualDepositAsset,
@@ -470,26 +464,12 @@ async function vaultDeposit(signer, options) {
             actualDepositAsset === '0x0000000000000000000000000000000000000000';
         const isAdapterDeposit = actualDepositAsset.toLowerCase() !== underlyingAsset.toLowerCase();
         const isMultiAssetVault = vaultVersion === 'evm-2';
-        const resolvedChainId = chainId ?? tokenizedVault?.chain;
-        const wantsSwapRouter = (0, core_1.vaultUsesSwapRouter)(target);
-        const swapRouterAddress = wantsSwapRouter && resolvedChainId !== undefined
-            ? (0, core_1.getSwapRouterAddress)(resolvedChainId)
-            : undefined;
-        // Legacy adapter uses minAmountOut: 0 (MEV-vulnerable); fall-through is unsafe.
-        if (wantsSwapRouter && !swapRouterAddress) {
-            throw new core_1.AugustValidationError('INVALID_CHAIN', resolvedChainId === undefined
-                ? `vaultDeposit: vault ${target} requires SwapRouter routing but chainId could not be resolved — pass options.chainId or ensure tokenized-vault metadata is loaded`
-                : `vaultDeposit: vault ${target} is registered on SwapRouter but no SwapRouter is deployed for chainId ${resolvedChainId}`, { context: { vault: target, chainId: resolvedChainId } });
-        }
-        // SwapRouter has no permit variant; throw rather than silently drop the signature.
-        if (wantsSwapRouter && options?.isDepositWithPermit) {
-            throw new core_1.AugustValidationError('INVALID_INPUT', `vaultDeposit: isDepositWithPermit is not supported on SwapRouter-routed vaults (${target}). Call vaultDeposit without isDepositWithPermit, or use the legacy vault.deposit path directly.`, { context: { vault: target } });
-        }
-        if (isAdapterDeposit &&
-            !isMultiAssetVault &&
-            !adapterConfig &&
-            !swapRouterAddress) {
-            throw new core_1.AugustValidationError('INVALID_INPUT', `vaultDeposit: depositAsset ${actualDepositAsset} differs from vault underlying ${underlyingAsset} but no adapter is configured for vault ${target}`);
+        // vaultDeposit is the NATIVE path only — it never routes through the
+        // SwapRouter. Any-token swap deposits are the explicit, opt-in job of
+        // {@link swapRouterDeposit}; keeping them out of here is what stops a
+        // natively-accepted asset from being silently swapped.
+        if (isAdapterDeposit && !isMultiAssetVault && !adapterConfig) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `vaultDeposit: depositAsset ${actualDepositAsset} differs from vault underlying ${underlyingAsset} but no adapter is configured for vault ${target}. For an any-token deposit into a SwapRouter-eligible vault, use swapRouterDeposit instead.`);
         }
         const depositTokenDecimals = await resolveDepositTokenDecimals({
             actualDepositAsset,
@@ -507,23 +487,6 @@ async function vaultDeposit(signer, options) {
             },
         });
         const normalizedAmt = (0, core_1.toNormalizedBn)(amount, depositTokenDecimals);
-        if (swapRouterAddress && resolvedChainId !== undefined) {
-            return dispatchViaSwapRouter({
-                signer,
-                routerAddress: swapRouterAddress,
-                chainId: resolvedChainId,
-                target,
-                wallet,
-                receiver: options.receiver,
-                actualDepositAsset,
-                underlyingAsset,
-                isNativeToken,
-                depositTokenDecimals,
-                normalizedAmt,
-                slippageBps: options.slippageBps,
-                wait,
-            });
-        }
         if (!isNativeToken) {
             const spenderAddress = resolveSpender({
                 target,
@@ -1355,4 +1318,146 @@ async function depositNativeViaSwapRouter(signer, options) {
     core_1.Logger.log.info('depositNativeViaSwapRouter:tx_hash', hash);
     return hash;
 }
+/**
+ * Deposit into an August vault through the on-chain `SwapRouter`, selecting the
+ * correct router path from the deposit asset. This is the high-level, explicit
+ * counterpart to the SwapRouter branch inside {@link vaultDeposit}.
+ *
+ * Where `vaultDeposit` decides whether to use the SwapRouter from the
+ * `VAULTS_USING_SWAP_ROUTER` allowlist, this function always routes through the
+ * SwapRouter because the caller asked it to. Making the intent explicit is the
+ * point: a native-deposit vault (e.g. a multi-asset Tokenized Vault V2 whose
+ * non-reference assets are accepted directly) is never accidentally swapped —
+ * the regression that implicit, allowlist-driven routing caused. Use
+ * `vaultDeposit` for native / adapter deposits and this for SwapRouter deposits.
+ *
+ * The vault's reference asset and its decimals are read on-chain (never trusted
+ * from the caller — a wrong reference asset would mis-route the swap). The path
+ * is then chosen from `depositAsset`:
+ *  - equals the reference asset → direct router deposit, no swap
+ *    ({@link depositViaSwapRouter});
+ *  - the zero address → native-token deposit ({@link depositNativeViaSwapRouter}),
+ *    valid only when the reference asset is the chain's wrapped-native token;
+ *  - any other ERC-20 → a swap to the reference asset (Paraswap quote pinned to
+ *    the chain's whitelisted aggregator, fail-closed on router/selector drift)
+ *    bundled into {@link swapAndDeposit}.
+ *
+ * Side effects: reads tokenized-vault metadata, the vault's reference asset and
+ * decimals, and (on the swap path) one Paraswap quote; sends one ERC-20
+ * `approve` to the SwapRouter when allowance is short, then the deposit tx.
+ *
+ * @param signer - ethers `Signer` or `Wallet` that signs the approval + deposit.
+ * @param options - {@link ISwapRouterDepositOptions}.
+ * @returns The transaction hash of the router deposit call.
+ * @throws {@link AugustValidationError} for an unsupported chain (no SwapRouter
+ *   deployment), an invalid vault or deposit-asset address, a missing or zero
+ *   amount, a native deposit into a non-wrapped-native vault, or drift between
+ *   the aggregator quote and the on-chain router whitelist.
+ * @worstCaseRpcCalls 5 on the swap path — tokenized-vault metadata, reference
+ *   asset + decimals, deposit-token decimals, the quote, and the allowance read.
+ * @example
+ * ```ts
+ * // USDT deposited into a USDC-reference vault → swapped to USDC en route.
+ * const hash = await augustSdk.evm.swapRouterDeposit({
+ *   chainId: 1,
+ *   vault: '0xe9b725010a9e419412ed67d0fa5f3a5f40159d32',
+ *   depositAsset: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+ *   amount: '100',
+ *   slippageBps: 50,
+ * });
+ * ```
+ */
+async function swapRouterDeposit(signer, options) {
+    const { chainId, vault, depositAsset, amount, receiver, slippageBps, wait } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `swapRouterDeposit: invalid vault address "${vault}"`);
+    }
+    if (!(0, core_1.checkAddress)(depositAsset, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `swapRouterDeposit: invalid depositAsset address "${depositAsset}"`);
+    }
+    if (amount === undefined || amount === null) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'swapRouterDeposit: amount is required');
+    }
+    validateAmountPrecision(amount);
+    // Explicit opt-in: resolve the router straight from chainId rather than
+    // consulting VAULTS_USING_SWAP_ROUTER, so this path never depends on the
+    // implicit allowlist that could route a native-deposit vault through a swap.
+    const routerAddress = resolveSwapRouterOrThrow(chainId);
+    const eoa = await resolveSignerEOA(signer, 'swapRouterDeposit');
+    // Reference asset + decimals from the vault on-chain. Mirrors vaultDeposit's
+    // metadata resolution so the deposit-token decimals (and therefore the raw
+    // amount) match exactly; kept separate to leave the vaultDeposit money path
+    // untouched.
+    const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault))?.[0];
+    const isMultiAssetVault = (0, core_1.getVaultVersionV2)(tokenizedVault) === 'evm-2';
+    let underlyingAsset;
+    let vaultDecimals;
+    if (isMultiAssetVault) {
+        const poolContract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+        });
+        const [asset, receiptTokenAddr] = await Promise.all([
+            poolContract.asset(),
+            poolContract.lpTokenAddress(),
+        ]);
+        underlyingAsset = asset;
+        const receiptContract = (0, core_1.createContract)({
+            address: receiptTokenAddr,
+            provider: signer,
+            abi: abis_1.ABI_ERC20,
+        });
+        vaultDecimals = Number(await receiptContract.decimals());
+    }
+    else {
+        const poolContract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_LENDING_POOLS,
+        });
+        const [asset, rawDecimals] = await Promise.all([
+            poolContract.asset(),
+            poolContract.decimals(),
+        ]);
+        underlyingAsset = asset;
+        vaultDecimals = Number(rawDecimals);
+    }
+    const isNativeToken = depositAsset === ethers_1.ZeroAddress ||
+        depositAsset === '0x0000000000000000000000000000000000000000';
+    const depositTokenDecimals = await resolveDepositTokenDecimals({
+        actualDepositAsset: depositAsset,
+        underlyingAsset,
+        isNativeToken,
+        isMultiAssetVault,
+        vaultDecimals,
+        readErc20Decimals: async (addr) => {
+            const erc20 = (0, core_1.createContract)({
+                address: addr,
+                provider: signer,
+                abi: abis_1.ABI_ERC20,
+            });
+            return Number(await erc20.decimals());
+        },
+    });
+    const normalizedAmt = (0, core_1.toNormalizedBn)(amount, depositTokenDecimals);
+    if (BigInt(normalizedAmt.raw) === 0n) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'swapRouterDeposit: amount must be greater than zero');
+    }
+    return dispatchViaSwapRouter({
+        signer,
+        routerAddress,
+        chainId,
+        target: vault,
+        wallet: eoa,
+        receiver,
+        actualDepositAsset: depositAsset,
+        underlyingAsset,
+        isNativeToken,
+        depositTokenDecimals,
+        normalizedAmt,
+        slippageBps,
+        wait,
+    });
+}
 //# sourceMappingURL=write.actions.js.map