upshift-config 0.5.14

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

@@ -0,0 +1,596 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchInstantRedemptionFee = fetchInstantRedemptionFee;
+exports.vaultAllowance = vaultAllowance;
+exports.sendersWhitelistAddress = sendersWhitelistAddress;
+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");
+/**
+ * Function to fetch instant redemption fee
+ * @param signer - signer / provider object
+ * @param options - object including pool contract address, user wallet address
+ * @returns normalized number object of the instant redemption fee
+ */
+async function fetchInstantRedemptionFee(signer, options) {
+    const { wallet, target } = options;
+    const [goodWallet, goodPool] = [
+        (0, core_1.checkAddress)(wallet, console, 'wallet'),
+        (0, core_1.checkAddress)(target, console),
+    ];
+    if (!goodWallet || !goodPool)
+        return;
+    try {
+        if (signer && target) {
+            const poolContract = (0, core_1.createContract)({
+                address: target,
+                abi: abis_1.ABI_LENDING_POOL_V3,
+                provider: signer,
+            });
+            const instantRedemptionResult = await poolContract.instantRedemptionFee();
+            return (0, core_1.toNormalizedBn)(instantRedemptionResult);
+        }
+    }
+    catch (e) {
+        (0, core_1.logChainError)('failed to fetch instant redeem fee', e, (0, core_1.isExpectedRevertError)(e));
+        throw new Error(`Failed to fetch instant redeem fee for ${target}: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+/**
+ * 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
+ */
+async function vaultAllowance(signer, options) {
+    const { wallet, target } = options;
+    const [goodWallet, goodPool] = [
+        (0, core_1.checkAddress)(wallet, console, 'wallet'),
+        (0, core_1.checkAddress)(target, console),
+    ];
+    if (!goodWallet || !goodPool)
+        return;
+    try {
+        // ERC4626 vault
+        const poolContract = (0, core_1.createContract)({
+            address: target,
+            abi: abis_1.ABI_LENDING_POOLS,
+            provider: signer,
+        });
+        // get vault asset address and decimals
+        const [asset, rawDecimals] = await Promise.all([
+            poolContract.asset(),
+            poolContract.decimals(),
+        ]);
+        const decimals = Number(rawDecimals);
+        // check amount vault approves user for
+        const depositTokenContract = (0, core_1.createContract)({
+            address: asset,
+            abi: abis_1.ABI_ERC20,
+            provider: signer,
+        });
+        const _allowance = (await depositTokenContract.allowance(wallet, target));
+        const normalized = (0, core_1.toNormalizedBn)(_allowance, decimals);
+        core_1.Logger.log.info('allowance', normalized);
+        return normalized;
+    }
+    catch (e) {
+        (0, core_1.logChainError)('allowance', e, (0, core_1.isExpectedRevertError)(e));
+        throw new Error(`Failed to fetch allowance: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Fetches the senders whitelist contract address from a whitelisted allocation vault
+ * @param signer - signer / provider object
+ * @param options - object including vault contract address
+ * @returns the senders whitelist contract address
+ */
+async function sendersWhitelistAddress(signer, options) {
+    const { vault } = options;
+    const goodTarget = (0, core_1.checkAddress)(vault, console);
+    if (!goodTarget)
+        return;
+    try {
+        const vaultContract = (0, core_1.createContract)({
+            address: vault,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2_WHITELISTED_ALLOCATION,
+            provider: signer,
+        });
+        const whitelistAddress = await vaultContract.sendersWhitelistAddress();
+        core_1.Logger.log.info('sendersWhitelistAddress', whitelistAddress);
+        return whitelistAddress;
+    }
+    catch (e) {
+        (0, core_1.logChainError)('sendersWhitelistAddress', e, (0, core_1.isExpectedRevertError)(e));
+        throw new Error(`Failed to fetch senders whitelist address: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Checks if an address is whitelisted on a whitelist contract
+ * @param signer - signer / provider object
+ * @param options - object including whitelist contract address and wallet address to check
+ * @returns boolean indicating if the address is whitelisted
+ */
+async function isWhitelisted(signer, options) {
+    const { whitelist, wallet } = options;
+    const [goodWhitelist, goodWallet] = [
+        (0, core_1.checkAddress)(whitelist, console, 'contract'),
+        (0, core_1.checkAddress)(wallet, console, 'wallet'),
+    ];
+    if (!goodWhitelist || !goodWallet)
+        return;
+    try {
+        const whitelistContract = (0, core_1.createContract)({
+            address: whitelist,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2_SENDER_ALLOCATION_WHITELIST,
+            provider: signer,
+        });
+        const result = await whitelistContract.isWhitelisted(wallet);
+        core_1.Logger.log.info('isWhitelisted', result);
+        return result;
+    }
+    catch (e) {
+        (0, core_1.logChainError)('isWhitelisted', e, (0, core_1.isExpectedRevertError)(e));
+        throw new Error(`Failed to check whitelist status: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Fetches the total amount deposited by an address on a whitelist contract
+ * @param signer - signer / provider object
+ * @param options - object including whitelist contract address, wallet address, and vault address
+ * @returns normalized number of the deposited amount
+ */
+async function getDeposited(signer, options) {
+    const { whitelist, wallet, vault } = options;
+    const [goodWhitelist, goodWallet, goodVault] = [
+        (0, core_1.checkAddress)(whitelist, console, 'contract'),
+        (0, core_1.checkAddress)(wallet, console, 'wallet'),
+        (0, core_1.checkAddress)(vault, console, 'contract'),
+    ];
+    if (!goodWhitelist || !goodWallet || !goodVault)
+        return;
+    try {
+        const vaultContract = (0, core_1.createContract)({
+            address: vault,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2_WHITELISTED_ALLOCATION,
+            provider: signer,
+        });
+        const whitelistContract = (0, core_1.createContract)({
+            address: whitelist,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2_SENDER_ALLOCATION_WHITELIST,
+            provider: signer,
+        });
+        const [deposited, asset] = await Promise.all([
+            whitelistContract.getDeposited(wallet),
+            vaultContract.asset(),
+        ]);
+        const assetContract = (0, core_1.createContract)({
+            address: asset,
+            abi: abis_1.ABI_ERC20,
+            provider: signer,
+        });
+        const decimals = Number(await assetContract.decimals());
+        const normalized = (0, core_1.toNormalizedBn)(deposited, decimals);
+        core_1.Logger.log.info('getDeposited', normalized);
+        return normalized;
+    }
+    catch (e) {
+        (0, core_1.logChainError)('getDeposited', e, (0, core_1.isExpectedRevertError)(e));
+        throw new Error(`Failed to fetch deposited amount: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Fetches the remaining allocation for an address on a whitelist contract
+ * @param signer - signer / provider object
+ * @param options - object including whitelist contract address, wallet address, vault address, and optional deposit cap amount
+ * @returns the remaining allocation as normalized number
+ */
+async function getRemainingAllocations(signer, options) {
+    const { whitelist, wallet, vault, depositCapAmount } = options;
+    const [goodWhitelist, goodWallet, goodVault] = [
+        (0, core_1.checkAddress)(whitelist, console, 'contract'),
+        (0, core_1.checkAddress)(wallet, console, 'wallet'),
+        (0, core_1.checkAddress)(vault, console, 'contract'),
+    ];
+    if (!goodWhitelist || !goodWallet || !goodVault)
+        return;
+    try {
+        const vaultContract = (0, core_1.createContract)({
+            address: vault,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2_WHITELISTED_ALLOCATION,
+            provider: signer,
+        });
+        const whitelistContract = (0, core_1.createContract)({
+            address: whitelist,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2_SENDER_ALLOCATION_WHITELIST,
+            provider: signer,
+        });
+        // Fetch depositCap if not provided, along with asset address
+        const [capAmount, asset] = await Promise.all([
+            depositCapAmount !== undefined
+                ? Promise.resolve(depositCapAmount)
+                : vaultContract.depositCap(),
+            vaultContract.asset(),
+        ]);
+        const assetContract = (0, core_1.createContract)({
+            address: asset,
+            abi: abis_1.ABI_ERC20,
+            provider: signer,
+        });
+        const decimals = Number(await assetContract.decimals());
+        const remaining = await whitelistContract.getRemainingAllocation(wallet, capAmount);
+        const normalized = (0, core_1.toNormalizedBn)(remaining, decimals);
+        core_1.Logger.log.info('getRemainingAllocations', normalized);
+        return normalized;
+    }
+    catch (e) {
+        (0, core_1.logChainError)('getRemainingAllocations', e, (0, core_1.isExpectedRevertError)(e));
+        throw new Error(`Failed to fetch remaining allocations: ${e instanceof Error ? e.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Preview the output amount for an RWA instant redemption via the RwaRedeemSubaccount contract.
+ * @param signer - signer / provider object
+ * @param options - object including subaccount address, asset, amount, decimals, and outputDecimals
+ * @returns normalized number of the expected output amount (in output asset decimals)
+ */
+async function previewRwaRedemption(signer, options) {
+    const { target, asset, amount, decimals, outputDecimals } = options;
+    const goodTarget = (0, core_1.checkAddress)(target, console, 'contract');
+    const goodAsset = (0, core_1.checkAddress)(asset, console, 'contract');
+    if (!goodTarget || !goodAsset)
+        return;
+    try {
+        const subaccountContract = (0, core_1.createContract)({
+            address: target,
+            provider: signer,
+            abi: abis_1.RWA_REDEEM_SUBACCOUNT,
+        });
+        if (!subaccountContract)
+            return;
+        const normalizedAmt = (0, core_1.toNormalizedBn)(amount, decimals);
+        const result = await subaccountContract.previewRedemption(asset, BigInt(normalizedAmt.raw));
+        const normalized = (0, core_1.toNormalizedBn)(result, outputDecimals);
+        core_1.Logger.log.info('previewRwaRedemption', normalized);
+        return normalized;
+    }
+    catch (e) {
+        (0, core_1.logChainError)('previewRwaRedemption', e, (0, core_1.isExpectedRevertError)(e), {
+            target,
+            asset,
+            amount,
+        });
+        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`);
+}
+/**
+ * Preview the number of shares that would be minted for a deposit, without
+ * touching on-chain state. Routes between single-asset ERC-4626 and EVM-2
+ * multi-asset vaults using the vault version detected from backend metadata.
+ *
+ * @returns The number of shares (raw on-chain units, share-token decimals).
+ * @throws AugustValidationError on invalid vault address or amount.
+ * @throws AugustSDKError when the underlying contract call fails.
+ *
+ * @example
+ * ```ts
+ * const shares = await augustSdk.evm.previewDeposit({
+ *   vault: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32',
+ *   amount: 1_000_000n,           // 1 USDC (6 decimals)
+ * });
+ * ```
+ */
+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);
+            // TokenizedVaultV2 previewDeposit returns (shares, _); take shares.
+            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;
+        }
+        (0, core_1.logChainError)('previewDeposit', e, (0, core_1.isExpectedRevertError)(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() } });
+    }
+}
+/**
+ * Preview the number of underlying assets returned by redeeming a given
+ * number of shares, without touching on-chain state. Routes between single-
+ * asset ERC-4626 (`previewRedeem`) and EVM-2 multi-asset
+ * (`previewRedemption(shares, isInstant=false)`) using the vault version.
+ *
+ * @returns The assets that would be redeemed (raw on-chain units, asset
+ *   decimals).
+ * @throws AugustValidationError on invalid vault or share input.
+ * @throws AugustSDKError when the underlying contract call fails.
+ *
+ * @example
+ * ```ts
+ * const assets = await augustSdk.evm.previewRedeem({
+ *   vault: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32',
+ *   shares: 1_000_000_000_000_000_000n, // 1 share (18 decimals)
+ * });
+ * ```
+ */
+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);
+            // EVM-2 previewRedemption returns (assetsAmount, assetsAfterFee); take gross.
+            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;
+        }
+        (0, core_1.logChainError)('previewRedeem', e, (0, core_1.isExpectedRevertError)(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() } });
+    }
+}
+/**
+ * Read the ERC-20 allowance an `owner` has granted to a vault (the spender).
+ * If `asset` is omitted, the vault's underlying asset is resolved via
+ * `IERC4626.asset()` and used as the token.
+ *
+ * Returns a raw `bigint` to keep BigInt math precise — call
+ * {@link toNormalizedBn} if you need a UI-shaped {@link INormalizedNumber}.
+ *
+ * @returns Allowance in raw on-chain units of `asset`.
+ * @throws AugustValidationError on invalid addresses.
+ * @throws AugustSDKError when the underlying contract call fails.
+ *
+ * @example
+ * ```ts
+ * const raw = await augustSdk.evm.allowance({
+ *   vault: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32',
+ *   owner: walletAddress,
+ * });
+ * if (raw < requiredAmount) {
+ *   await augustSdk.evm.vaultApprove({
+ *     target: vault,
+ *     wallet: walletAddress,
+ *     amount: requiredAmount.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;
+        }
+        (0, core_1.logChainError)('allowance', e, (0, core_1.isExpectedRevertError)(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 } });
+    }
+}
+/**
+ * Read an ERC-20 balance directly. Returns the raw on-chain value as
+ * `bigint`; call {@link toNormalizedBn} if you need a {@link INormalizedNumber}.
+ *
+ * @returns Balance in raw on-chain units of `asset`.
+ * @throws AugustValidationError on invalid asset / owner addresses.
+ * @throws AugustSDKError when the underlying contract call fails.
+ *
+ * @example
+ * ```ts
+ * const raw = await augustSdk.evm.balanceOf({
+ *   asset: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+ *   owner: walletAddress,
+ * });
+ * ```
+ */
+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;
+        }
+        (0, core_1.logChainError)('balanceOf', e, (0, core_1.isExpectedRevertError)(e), { asset, owner });
+        throw new core_1.AugustSDKError('UNKNOWN', `balanceOf failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { asset, owner } });
+    }
+}
+/**
+ * Read the maximum deposit currently accepted by a vault. Routes between
+ * single-asset ERC-4626 (`maxDeposit(receiver)`) and EVM-2 multi-asset
+ * (`maxDepositAmount()`, vault-level cap, no receiver dependence).
+ *
+ * @returns Max deposit in raw on-chain units of the deposit asset.
+ * @throws AugustValidationError on invalid vault address.
+ * @throws AugustSDKError when the underlying contract call fails.
+ *
+ * @example
+ * ```ts
+ * const cap = await augustSdk.evm.maxDeposit({ vault });
+ * if (cap === 0n) showVaultIsFullToast();
+ * ```
+ */
+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,
+        });
+        // Zero-address default: vaults that require a receiver arg won't revert.
+        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;
+        }
+        (0, core_1.logChainError)('maxDeposit', e, (0, core_1.isExpectedRevertError)(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/types.d.ts

@@ -0,0 +1,71 @@
+import type { Connection } from '@solana/web3.js';
+import type { IAddress, IEnv, IStellarNetwork, IWSMonitorHeaders } from '../../types';
+/**
+ * Structural interface for the Solana adapter surface used by vault operations.
+ * Avoids importing the concrete SolanaAdapter class to prevent circular dependencies.
+ */
+export interface ISolanaService {
+    connection: Connection;
+    getVaultState: (vaultProgramId: any, idl: any, vaultAddress?: any) => Promise<any>;
+    fetchUserShareBalance: (publicKey: any, shareMint: any) => Promise<any>;
+    /**
+     * Raw (BigInt-safe) variant. Required — `fetchUserShareBalance` alone
+     * returns a JS-number `uiAmount` which is lossy and silently encodes
+     * against 18 decimals when fed back through `toNormalizedBn` without an
+     * explicit decimals argument. Every consumer that needs a correct
+     * `walletBalance.raw` (positions, redemptions, max actions) MUST use this
+     * entry point.
+     *
+     * Returns `{ amount, decimals }`:
+     *   - `amount` is the on-chain u64 as a base-units string (always set;
+     *     `'0'` when no balance / no account / no args / RPC failure).
+     *   - `decimals` matches the mint when a parsed `tokenAmount` is
+     *     available; otherwise **`null`**. `decimals === null` is the
+     *     "scale unknown" signal — callers must substitute a known decimals
+     *     value (typically the deposit mint's decimals from backend metadata)
+     *     before constructing an `INormalizedNumber`. Never throws.
+     */
+    fetchUserShareBalanceRaw: (publicKey: any, shareMint: any) => Promise<{
+        amount: string;
+        decimals: number | null;
+    }>;
+}
+/**
+ * Base configuration for vault operations.
+ */
+export interface IVaultBaseOptions {
+    rpcUrl: string;
+    env?: IEnv;
+    augustKey?: string;
+    subgraphKey?: string;
+    chainId?: number;
+    solanaService?: ISolanaService;
+    /**
+     * Optional Soroban RPC override (e.g. a keyed Alchemy URL) for Stellar vault
+     * reads, threaded from the SDK's `stellar` config. Carries the network it was
+     * configured for so it is only applied to matching-network vaults — a testnet
+     * override must not be used for a mainnet read. Unset → built-in endpoints.
+     */
+    stellarRpc?: {
+        rpcUrl: string;
+        network: IStellarNetwork;
+    };
+    headers?: IWSMonitorHeaders;
+    /**
+     * Portfolio mode: when true, the per-vault EVM getter does NOT null out a
+     * closed + invisible vault. Needed so a user's position in a closed,
+     * invisible vault can still resolve its metadata. Defaults to undefined
+     * (false) so marketplace/discovery reads keep hiding closed staging vaults.
+     */
+    includeClosed?: boolean;
+}
+/**
+ * Optional enrichment options for vault queries.
+ */
+export interface IVaultCustomOptions {
+    loans?: boolean;
+    allocations?: boolean;
+    wallet?: IAddress;
+    solanaWallet?: string;
+    stellarWallet?: string;
+}

package/lib/modules/vaults/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map