@augustdigital/sdk 6.0.1 → 7.0.0

package/lib/evm/methods/crossChainVault.js

@@ -50,6 +50,7 @@ exports.getAvailableChains = getAvailableChains;
 exports.formatCrossChainError = formatCrossChainError;
 exports.getLayerZeroScanUrl = getLayerZeroScanUrl;
 const core_1 = require("../../core");
+const crossChain_1 = require("../types/crossChain");
 const OFT_1 = require("../../abis/OFT");
 const LZ_RECEIVE_OPTION_HEX = '010011010000000000000000000000000007a120';
 const DEFAULT_FEE_BUFFER_PERCENT = 50;
@@ -99,10 +100,23 @@ async function generateOVaultInputsWithOverride(input, config, hubPublicClient,
     patchLock = new Promise((r) => {
         unlock = r;
     });
-    await Promise.race([
-        prev,
-        new Promise((resolve) => setTimeout(resolve, PATCH_LOCK_TIMEOUT_MS)),
-    ]);
+    let timeoutHandle;
+    try {
+        await Promise.race([
+            prev,
+            new Promise((_resolve, reject) => {
+                timeoutHandle = setTimeout(() => reject(new Error(`crossChainVault patch lock timed out after ${PATCH_LOCK_TIMEOUT_MS}ms — a prior call may be hung`)), PATCH_LOCK_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    catch (err) {
+        unlock();
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+        throw err;
+    }
+    if (timeoutHandle)
+        clearTimeout(timeoutHandle);
     const Builder = OVaultSyncMessageBuilder;
     const origGetOutputAmount = Builder.getOutputAmount;
     const origQuoteOVaultOutput = Builder.quoteOVaultOutput;
@@ -188,19 +202,45 @@ async function buildCrossChainVaultTx(props) {
                 error: 'Hub chain and source chain are required',
             };
         }
+        const supportedChains = [
+            config.hubChainId,
+            ...Object.keys(config.layerZeroEids.spokes).map((k) => Number(k)),
+        ];
+        const supportedChainsList = supportedChains.join(', ');
+        if (props.destinationChainId !== undefined &&
+            props.destinationChainId !== config.hubChainId &&
+            !config.layerZeroEids.spokes[props.destinationChainId]) {
+            return {
+                success: false,
+                error: `Destination chain ${props.destinationChainId} is not configured for this vault. Supported chains: ${supportedChainsList}.`,
+            };
+        }
+        if (props.operation === 'DEPOSIT' &&
+            props.userChainId !== config.hubChainId &&
+            !config.layerZeroEids.spokes[props.userChainId]) {
+            return {
+                success: false,
+                error: `Source chain ${props.userChainId} is not configured for this vault. Supported chains: ${supportedChainsList}.`,
+            };
+        }
+        const resolveDstEid = (chainId) => {
+            if (chainId === undefined)
+                return undefined;
+            if (chainId === config.hubChainId)
+                return config.layerZeroEids.hub;
+            return config.layerZeroEids.spokes[chainId];
+        };
         let srcEid;
         let dstEid;
         let tokenAddress;
         let oftAddress;
         switch (props.operation) {
             case 'DEPOSIT': {
+                const resolvedSrc = resolveDstEid(props.userChainId);
                 srcEid =
-                    config.layerZeroEids.spokes[props.userChainId] ||
-                        config.layerZeroEids.hub;
-                dstEid = props.destinationChainId
-                    ? config.layerZeroEids.spokes[props.destinationChainId] ||
-                        config.layerZeroEids.hub
-                    : srcEid;
+                    resolvedSrc !== undefined ? resolvedSrc : config.layerZeroEids.hub;
+                const resolved = resolveDstEid(props.destinationChainId);
+                dstEid = resolved !== undefined ? resolved : srcEid;
                 tokenAddress = config.contracts.assetToken[props.userChainId];
                 oftAddress = config.contracts.assetOFT[props.userChainId];
                 if (!tokenAddress || !oftAddress) {
@@ -213,11 +253,9 @@ async function buildCrossChainVaultTx(props) {
             }
             case 'REDEEM': {
                 srcEid = config.layerZeroEids.hub;
-                dstEid = props.destinationChainId
-                    ? config.layerZeroEids.spokes[props.destinationChainId] ||
-                        config.layerZeroEids.hub
-                    : config.layerZeroEids.spokes[props.userChainId] ||
-                        config.layerZeroEids.hub;
+                const resolved = resolveDstEid(props.destinationChainId) ??
+                    resolveDstEid(props.userChainId);
+                dstEid = resolved !== undefined ? resolved : config.layerZeroEids.hub;
                 tokenAddress = config.vaultAddress;
                 oftAddress = config.contracts.shareOFTAdapter;
                 break;
@@ -276,6 +314,9 @@ async function buildCrossChainVaultTx(props) {
             const sendFee = inputs.txArgs[1];
             sendFee.nativeFee = inputs.messageFee.nativeFee;
         }
+        else {
+            core_1.Logger.log.warn('crossChainVault:fee-patch', `Unexpected contractFunctionName "${inputs.contractFunctionName}" from LayerZero SDK — fee buffer not applied to txArgs in-place`, { contractFunctionName: inputs.contractFunctionName });
+        }
         return {
             success: true,
             data: {
@@ -324,10 +365,13 @@ async function quoteCrossChainDeposit(props) {
     });
     if (!result.success || !result.data)
         return null;
+    const quotedAt = Date.now();
     return {
         nativeFee: result.data.messageFee.nativeFee,
         dstAmount: result.data.dstAmount,
         minDstAmount: result.data.minDstAmount,
+        quotedAt,
+        expiresAt: quotedAt + crossChain_1.CROSS_CHAIN_QUOTE_TTL_MS,
     };
 }
 async function quoteCrossChainRedeem(props) {
@@ -347,10 +391,13 @@ async function quoteCrossChainRedeem(props) {
     });
     if (!result.success || !result.data)
         return null;
+    const quotedAt = Date.now();
     return {
         nativeFee: result.data.messageFee.nativeFee,
         dstAmount: result.data.dstAmount,
         minDstAmount: result.data.minDstAmount,
+        quotedAt,
+        expiresAt: quotedAt + crossChain_1.CROSS_CHAIN_QUOTE_TTL_MS,
     };
 }
 async function needsCrossChainApproval(tokenAddress, spenderAddress, walletAddress, amount, publicClient) {
@@ -378,10 +425,19 @@ async function approveCrossChain(tokenAddress, spenderAddress, amount, walletCli
         functionName: 'approve',
         args: [spenderAddress, amount],
     });
-    await publicClient.waitForTransactionReceipt({ hash: hash });
+    const receipt = await publicClient.waitForTransactionReceipt({
+        hash: hash,
+    });
+    if (receipt.status === 'reverted') {
+        throw new Error(`Approval transaction reverted on-chain (tx ${hash}). Check token allowance limits or that the token contract supports approve().`);
+    }
     return hash;
 }
 async function crossChainVaultDeposit(props) {
+    if (props.userChainId !== props.config.hubChainId &&
+        !props.config.spokeChainIds.includes(props.userChainId)) {
+        throw new Error(`Chain ${props.userChainId} is not supported for deposits to this vault — switch to the hub (${props.config.hubChainId}) or a configured spoke (${props.config.spokeChainIds.join(', ')}).`);
+    }
     const walletClient = props.walletClient;
     const publicClient = props.publicClient;
     const result = await buildCrossChainVaultTx({

package/lib/evm/types/crossChain.d.ts

@@ -141,7 +141,11 @@ export interface IQuoteCrossChainResult {
     nativeFee: bigint;
     dstAmount: bigint;
     minDstAmount: bigint;
+    quotedAt: number;
+    expiresAt: number;
 }
+export declare const CROSS_CHAIN_QUOTE_TTL_MS = 30000;
+export declare function isQuoteStale(quote: Pick<IQuoteCrossChainResult, 'expiresAt'>, now?: number): boolean;
 export interface ICrossChainOperationStatus {
     srcTxHash: string;
     status: 'PENDING' | 'INFLIGHT' | 'DELIVERED' | 'FAILED';

package/lib/evm/types/crossChain.js

@@ -1,3 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CROSS_CHAIN_QUOTE_TTL_MS = void 0;
+exports.isQuoteStale = isQuoteStale;
+exports.CROSS_CHAIN_QUOTE_TTL_MS = 30000;
+function isQuoteStale(quote, now = Date.now()) {
+    return now >= quote.expiresAt;
+}
 //# sourceMappingURL=crossChain.js.map

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

@@ -1,4 +1,3 @@
-import { IVaultMetadata } from '../../types';
 export declare function fetchVaultWithFallback<T>(vaultAddress: string, fetchFn: () => Promise<T>, options?: {
     maxRetries?: number;
     baseDelay?: number;
@@ -100,8 +99,4 @@ export declare function filterVaultsIntelligently<T extends {
         successRate: number;
     };
 };
-export declare function fetchVaultMetadata(opts?: {
-    options?: {
-        headers?: Record<string, string>;
-    };
-}): Promise<IVaultMetadata>;
+export { fetchVaultMetadata } from '../../core/vault-metadata';

package/lib/modules/vaults/fetcher.js

@@ -1,11 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchVaultMetadata = void 0;
 exports.fetchVaultWithFallback = fetchVaultWithFallback;
 exports.fetchVaultsBatch = fetchVaultsBatch;
 exports.fetchVaultsComprehensive = fetchVaultsComprehensive;
 exports.filterVaultsIntelligently = filterVaultsIntelligently;
-exports.fetchVaultMetadata = fetchVaultMetadata;
 const core_1 = require("../../core");
+async function runWithConcurrency(tasks, limit) {
+    if (!Number.isFinite(limit) || limit <= 0) {
+        throw new Error(`runWithConcurrency: limit must be a positive finite number, got ${limit}`);
+    }
+    const results = new Array(tasks.length);
+    let nextIndex = 0;
+    const workerCount = Math.min(Math.floor(limit), tasks.length);
+    const workers = Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const i = nextIndex++;
+            if (i >= tasks.length)
+                return;
+            results[i] = await tasks[i]();
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
 async function fetchVaultWithFallback(vaultAddress, fetchFn, options = {}) {
     const { maxRetries = 3, baseDelay = 1000 } = options;
     try {
@@ -22,13 +40,13 @@ async function fetchVaultWithFallback(vaultAddress, fetchFn, options = {}) {
     };
 }
 async function fetchVaultsBatch(vaults, options = {}) {
-    const { maxRetries = 3, baseDelay = 1000, batchSize = 10, parallelLimit: _parallelLimit = 5, } = options;
+    const { maxRetries = 3, baseDelay = 1000, batchSize = 10, parallelLimit = batchSize, } = options;
     const successful = [];
     const failed = [];
     let totalAttempted = 0;
     for (let i = 0; i < vaults.length; i += batchSize) {
         const batch = vaults.slice(i, i + batchSize);
-        const batchPromises = batch.map(async (vault, batchIndex) => {
+        const batchTasks = batch.map((vault, batchIndex) => async () => {
             const globalIndex = i + batchIndex;
             totalAttempted++;
             try {
@@ -59,7 +77,7 @@ async function fetchVaultsBatch(vaults, options = {}) {
                 });
             }
         });
-        await Promise.all(batchPromises);
+        await runWithConcurrency(batchTasks, parallelLimit);
         if (i + batchSize < vaults.length) {
             await new Promise((resolve) => setTimeout(resolve, 100));
         }
@@ -73,14 +91,14 @@ async function fetchVaultsBatch(vaults, options = {}) {
     };
 }
 async function fetchVaultsComprehensive(vaults, fetchFn, options = {}) {
-    const { maxRetries = 5, baseDelay = 2000, batchSize = 10, parallelLimit: _parallelLimit = 5, includeClosed: _includeClosed = false, includeInvisible: _includeInvisible = false, fallbackRpcUrls = {}, timeout = 60000, } = options;
+    const { maxRetries = 5, baseDelay = 2000, batchSize = 10, parallelLimit = batchSize, includeClosed: _includeClosed = false, includeInvisible: _includeInvisible = false, fallbackRpcUrls = {}, timeout = 60000, } = options;
     const successful = [];
     const failed = [];
     const rpcFailures = {};
     let totalAttempted = 0;
     for (let i = 0; i < vaults.length; i += batchSize) {
         const batch = vaults.slice(i, i + batchSize);
-        const batchPromises = batch.map(async (vault, batchIndex) => {
+        const batchTasks = batch.map((vault, batchIndex) => async () => {
             const globalIndex = i + batchIndex;
             totalAttempted++;
             let attempts = 0;
@@ -182,7 +200,7 @@ async function fetchVaultsComprehensive(vaults, fetchFn, options = {}) {
             });
             rpcFailures[vault.chain] = (rpcFailures[vault.chain] || 0) + 1;
         });
-        await Promise.all(batchPromises);
+        await runWithConcurrency(batchTasks, parallelLimit);
         if (i + batchSize < vaults.length) {
             await new Promise((resolve) => setTimeout(resolve, 200));
         }
@@ -255,33 +273,6 @@ function filterVaultsIntelligently(vaults, options = {}) {
         },
     };
 }
-async function fetchVaultMetadata(opts) {
-    const { options } = opts || {};
-    try {
-        const cacheKey = 'vaults_metadata';
-        if (core_1.CACHE.has(cacheKey)) {
-            return core_1.CACHE.get(cacheKey);
-        }
-        const response = await fetch(`${core_1.WEBSERVER_URL['upshift']}${core_1.WEBSERVER_ENDPOINTS.upshift.vaults.metadata}`, {
-            method: 'GET',
-            headers: {
-                'content-type': 'application/json',
-                accept: 'application/json',
-                'x-request-client': 'august-sdk',
-                ...options?.headers,
-            },
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to fetch vault metadata: ${response.statusText}`);
-        }
-        const metadata = await response.json();
-        core_1.CACHE.set(cacheKey, metadata, { ttl: 10 * 60 * 1000 });
-        return metadata;
-    }
-    catch (e) {
-        core_1.Logger.log.error('getVaultMetadata', e);
-        const errorMessage = e instanceof Error ? e.message : String(e);
-        throw new Error(`#getVaultMetadata::${errorMessage}`);
-    }
-}
+var vault_metadata_1 = require("../../core/vault-metadata");
+Object.defineProperty(exports, "fetchVaultMetadata", { enumerable: true, get: function () { return vault_metadata_1.fetchVaultMetadata; } });
 //# sourceMappingURL=fetcher.js.map

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

@@ -1,5 +1,5 @@
 import { IAddress, IHistoricalTimeseriesResponse, INormalizedNumber, ISubgraphWithdrawProccessed, IVault, IVaultAllocations, IVaultAnnualizedApy, IVaultAvailableRedemption, IVaultLoan, IVaultPosition, IVaultRedemptionHistoryItem, IVaultSummary, IVaultWithdrawals, IVaultPendingRedemptions, IActiveStakingPosition, IVaultHistoricalParams, IVaultUserLifetimePnl, IVaultPnl, VaultAddress } from '../../types';
-import { IVaultBaseOptions } from '.';
+import { IVaultBaseOptions } from './types';
 export declare function getVault({ vault, loans, allocations, options, loadSubaccounts, loadSnapshots, }: {
     vault: IAddress;
     loans?: boolean;

package/lib/modules/vaults/getters.js

@@ -938,12 +938,13 @@ async function getVaultPositions({ vault, wallet, solanaWallet, stellarWallet, o
                 });
                 let bal = BigInt(0);
                 if (version === 'evm-2') {
-                    decimals = await (0, core_1.getDecimals)(provider, await (0, core_1.getReceiptTokenAddress)(provider, vault), false);
+                    const receiptAddress = await (0, core_1.getReceiptTokenAddress)(provider, vault);
+                    decimals = await (0, core_1.getDecimals)(provider, receiptAddress, false);
                     if (wallet && (0, ethers_1.isAddress)(wallet)) {
                         const receiptContract = (0, core_1.createContract)({
                             provider,
                             abi: TokenizedVaultV2Receipt_1.ABI_TOKENIZED_VAULT_V2_RECEIPT,
-                            address: await (0, core_1.getReceiptTokenAddress)(provider, vault),
+                            address: receiptAddress,
                         });
                         bal = await receiptContract.balanceOf(wallet);
                     }

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

@@ -28,3 +28,30 @@ export type IPreviewRwaRedemptionOptions = {
     outputDecimals: number;
 };
 export declare function previewRwaRedemption(signer: IContractRunner, options: IPreviewRwaRedemptionOptions): Promise<INormalizedNumber | undefined>;
+export type IPreviewDepositOptions = {
+    vault: IAddress;
+    amount: string | bigint | number;
+    asset?: IAddress;
+};
+export type IPreviewRedeemOptions = {
+    vault: IAddress;
+    shares: string | bigint | number;
+};
+export type IAllowanceOptions = {
+    vault: IAddress;
+    owner: IAddress;
+    asset?: IAddress;
+};
+export type IBalanceOfOptions = {
+    asset: IAddress;
+    owner: IAddress;
+};
+export type IMaxDepositOptions = {
+    vault: IAddress;
+    receiver?: IAddress;
+};
+export declare function previewDeposit(signer: IContractRunner, options: IPreviewDepositOptions): Promise<bigint>;
+export declare function previewRedeem(signer: IContractRunner, options: IPreviewRedeemOptions): Promise<bigint>;
+export declare function allowance(signer: IContractRunner, options: IAllowanceOptions): Promise<bigint>;
+export declare function balanceOf(signer: IContractRunner, options: IBalanceOfOptions): Promise<bigint>;
+export declare function maxDeposit(signer: IContractRunner, options: IMaxDepositOptions): Promise<bigint>;

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

@@ -7,6 +7,11 @@ exports.isWhitelisted = isWhitelisted;
 exports.getDeposited = getDeposited;
 exports.getRemainingAllocations = getRemainingAllocations;
 exports.previewRwaRedemption = previewRwaRedemption;
+exports.previewDeposit = previewDeposit;
+exports.previewRedeem = previewRedeem;
+exports.allowance = allowance;
+exports.balanceOf = balanceOf;
+exports.maxDeposit = maxDeposit;
 const abis_1 = require("../../abis");
 const core_1 = require("../../core");
 async function fetchInstantRedemptionFee(signer, options) {
@@ -216,4 +221,219 @@ async function previewRwaRedemption(signer, options) {
         throw new Error(`Preview RWA redemption failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
+function toRawBigInt(value, label) {
+    if (typeof value === 'bigint')
+        return value;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount must be finite, got ${value}`);
+        }
+        if (value < 0) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount must be non-negative, got ${value}`);
+        }
+        if (!Number.isSafeInteger(value)) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount ${value} exceeds Number.MAX_SAFE_INTEGER; pass a string or bigint to preserve precision`);
+        }
+        return BigInt(value);
+    }
+    if (typeof value === 'string') {
+        if (value.trim() === '') {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount string must not be empty`);
+        }
+        try {
+            const parsed = BigInt(value);
+            if (parsed < 0n) {
+                throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount must be non-negative, got ${value}`);
+            }
+            return parsed;
+        }
+        catch (e) {
+            if (e instanceof core_1.AugustValidationError)
+                throw e;
+            throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount "${value}" is not a valid integer`);
+        }
+    }
+    throw new core_1.AugustValidationError('INVALID_INPUT', `${label}: amount must be a string, bigint, or number`);
+}
+async function previewDeposit(signer, options) {
+    const { vault, amount, asset } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `previewDeposit: invalid vault address ${vault}`);
+    }
+    const amountRaw = toRawBigInt(amount, 'previewDeposit');
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        const isMultiAsset = vaultVersion === 'evm-2';
+        if (isMultiAsset) {
+            if (!asset || !(0, core_1.checkAddress)(asset, console, 'contract')) {
+                throw new core_1.AugustValidationError('INVALID_INPUT', 'previewDeposit: multi-asset vaults require an explicit `asset` parameter');
+            }
+            const contract = (0, core_1.createContract)({
+                address: vault,
+                provider: signer,
+                abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+            });
+            const result = await contract.previewDeposit(asset, amountRaw);
+            const shares = Array.isArray(result) ? result[0] : result;
+            return BigInt(shares);
+        }
+        const contract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_LENDING_POOLS,
+        });
+        const result = await contract.previewDeposit(amountRaw);
+        return BigInt(result);
+    }
+    catch (e) {
+        if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
+            throw e;
+        }
+        core_1.Logger.log.error('previewDeposit', e, { vault, amount: amount.toString() });
+        throw new core_1.AugustSDKError('UNKNOWN', `previewDeposit failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, amount: amount.toString() } });
+    }
+}
+async function previewRedeem(signer, options) {
+    const { vault, shares } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `previewRedeem: invalid vault address ${vault}`);
+    }
+    const sharesRaw = toRawBigInt(shares, 'previewRedeem');
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        const isMultiAsset = vaultVersion === 'evm-2';
+        if (isMultiAsset) {
+            const contract = (0, core_1.createContract)({
+                address: vault,
+                provider: signer,
+                abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+            });
+            const result = await contract.previewRedemption(sharesRaw, false);
+            const assets = Array.isArray(result) ? result[0] : result;
+            return BigInt(assets);
+        }
+        const contract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_LENDING_POOLS,
+        });
+        const result = await contract.previewRedeem(sharesRaw);
+        return BigInt(result);
+    }
+    catch (e) {
+        if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
+            throw e;
+        }
+        core_1.Logger.log.error('previewRedeem', e, {
+            vault,
+            shares: shares.toString(),
+        });
+        throw new core_1.AugustSDKError('UNKNOWN', `previewRedeem failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, shares: shares.toString() } });
+    }
+}
+async function allowance(signer, options) {
+    const { vault, owner, asset } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `allowance: invalid vault address ${vault}`);
+    }
+    if (!(0, core_1.checkAddress)(owner, console, 'wallet')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `allowance: invalid owner address ${owner}`);
+    }
+    if (asset && !(0, core_1.checkAddress)(asset, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `allowance: invalid asset address ${asset}`);
+    }
+    try {
+        let tokenAddress;
+        if (asset) {
+            tokenAddress = asset;
+        }
+        else {
+            const vaultContract = (0, core_1.createContract)({
+                address: vault,
+                provider: signer,
+                abi: abis_1.ABI_LENDING_POOLS,
+            });
+            tokenAddress = (await vaultContract.asset());
+        }
+        const tokenContract = (0, core_1.createContract)({
+            address: tokenAddress,
+            provider: signer,
+            abi: abis_1.ABI_ERC20,
+        });
+        const raw = (await tokenContract.allowance(owner, vault));
+        return BigInt(raw);
+    }
+    catch (e) {
+        if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
+            throw e;
+        }
+        core_1.Logger.log.error('allowance', e, { vault, owner, asset });
+        throw new core_1.AugustSDKError('UNKNOWN', `allowance failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, owner, asset } });
+    }
+}
+async function balanceOf(signer, options) {
+    const { asset, owner } = options;
+    if (!(0, core_1.checkAddress)(asset, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `balanceOf: invalid asset address ${asset}`);
+    }
+    if (!(0, core_1.checkAddress)(owner, console, 'wallet')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `balanceOf: invalid owner address ${owner}`);
+    }
+    try {
+        const tokenContract = (0, core_1.createContract)({
+            address: asset,
+            provider: signer,
+            abi: abis_1.ABI_ERC20,
+        });
+        const raw = (await tokenContract.balanceOf(owner));
+        return BigInt(raw);
+    }
+    catch (e) {
+        if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
+            throw e;
+        }
+        core_1.Logger.log.error('balanceOf', e, { asset, owner });
+        throw new core_1.AugustSDKError('UNKNOWN', `balanceOf failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { asset, owner } });
+    }
+}
+async function maxDeposit(signer, options) {
+    const { vault, receiver } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `maxDeposit: invalid vault address ${vault}`);
+    }
+    if (receiver && !(0, core_1.checkAddress)(receiver, console, 'wallet')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `maxDeposit: invalid receiver address ${receiver}`);
+    }
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault))?.[0];
+        const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
+        const isMultiAsset = vaultVersion === 'evm-2';
+        if (isMultiAsset) {
+            const contract = (0, core_1.createContract)({
+                address: vault,
+                provider: signer,
+                abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+            });
+            const raw = (await contract.maxDepositAmount());
+            return BigInt(raw);
+        }
+        const contract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_LENDING_POOLS,
+        });
+        const target = receiver ?? '0x0000000000000000000000000000000000000000';
+        const raw = (await contract.maxDeposit(target));
+        return BigInt(raw);
+    }
+    catch (e) {
+        if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
+            throw e;
+        }
+        core_1.Logger.log.error('maxDeposit', e, { vault, receiver });
+        throw new core_1.AugustSDKError('UNKNOWN', `maxDeposit failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, receiver } });
+    }
+}
 //# sourceMappingURL=read.actions.js.map

package/lib/modules/vaults/utils/date-utils.js

@@ -5,8 +5,8 @@ exports.isClaimableNow = isClaimableNow;
 exports.formatDateKey = formatDateKey;
 exports.isValidClaimableDate = isValidClaimableDate;
 exports.getDaysInMonth = getDaysInMonth;
+const TIMESTAMP_MANIPULATION_WINDOW = 300;
 function computeClaimableDate(requestTimestamp, lagDuration) {
-    const TIMESTAMP_MANIPULATION_WINDOW = 300;
     const claimableEpoch = requestTimestamp + TIMESTAMP_MANIPULATION_WINDOW + lagDuration;
     const date = new Date(claimableEpoch * 1000);
     const year = date.getUTCFullYear();
@@ -15,7 +15,6 @@ function computeClaimableDate(requestTimestamp, lagDuration) {
     return { year, month, day, epoch: claimableEpoch };
 }
 function isClaimableNow(claimableEpoch, currentEpoch) {
-    const TIMESTAMP_MANIPULATION_WINDOW = 300;
     return currentEpoch >= claimableEpoch - TIMESTAMP_MANIPULATION_WINDOW;
 }
 function formatDateKey(year, month, day) {