@upshiftfinance/sdk 0.0.0-stage → 0.2.0

package/lib/modules/vaults/utils.js

@@ -0,0 +1,818 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC_20_PERMIT_HASH = exports.getRewardMultiplierByTimestamp = void 0;
+exports.walletClientToSigner = walletClientToSigner;
+exports.getVaultRewards = getVaultRewards;
+exports.getIdleAssets = getIdleAssets;
+exports.getYieldLastRealizedOn = getYieldLastRealizedOn;
+exports.formatVaultApy = formatVaultApy;
+exports.mapVaultFreshness = mapVaultFreshness;
+exports.mapUnderlyingVault = mapUnderlyingVault;
+exports.mapStrategists = mapStrategists;
+exports.mapComposabilityIntegrations = mapComposabilityIntegrations;
+exports.backendTvlToNormalizedBn = backendTvlToNormalizedBn;
+exports.buildBackendVault = buildBackendVault;
+exports.buildFormattedVault = buildFormattedVault;
+exports.generatePermitSignature = generatePermitSignature;
+exports.createDeadline = createDeadline;
+const abis_1 = require("../../abis");
+const core_1 = require("../../core");
+const vaults_1 = require("../../core/helpers/vaults");
+const ethers_1 = require("ethers");
+/**
+ * @param walletClient a wagmi-derived client (from useWalletClient)
+ * @returns An ethers JsonRpcSigner object used in sdk.evm.setSigner
+ */
+async function walletClientToSigner(walletClient) {
+    const { account, chain, transport } = walletClient;
+    const network = {
+        chainId: chain.id,
+        name: chain.name,
+        ensAddress: chain.contracts?.ensRegistry?.address,
+    };
+    //@ts-expect-error
+    const provider = new ethers_1.BrowserProvider(transport, network);
+    const signer = await provider.getSigner(account.address);
+    return signer;
+}
+/**
+ * Calculates the reward multiplier based on the vault and optional timestamp.
+ * Returns the applicable multiplier for a given vault at a specific timestamp,
+ * or the latest multiplier if no timestamp is provided.
+ * @param foundPool The vault to get the multiplier for
+ * @param timestamp Optional timestamp to get historical multiplier
+ * @returns The reward multiplier value
+ */
+const getRewardMultiplierByTimestamp = (foundPool, timestamp) => {
+    const multipliers = foundPool.rewards?.multipliers;
+    if (!multipliers?.length) {
+        return 1; // default multiplier if multipliers are not found
+    }
+    const multipliersByTimestamp = multipliers.reduce((acc, curr) => {
+        return {
+            ...acc,
+            [curr.timestamp]: curr.value,
+        };
+    }, {});
+    if (!multipliersByTimestamp) {
+        return 1; // default multiplier if pool is not found
+    }
+    // return the latest if timestamp not provided
+    if (!timestamp) {
+        const latest = Object.keys(multipliersByTimestamp)
+            .map(Number)
+            .sort((a, b) => b - a)[0];
+        return latest !== undefined ? (multipliersByTimestamp[latest] ?? 1) : 1;
+    }
+    const applicableTimestamp = Object.keys(multipliersByTimestamp)
+        .map(Number)
+        .filter((ts) => ts <= timestamp) // filter only timestamps before or equal to the given timestamp
+        .sort((a, b) => b - a)[0]; // get the latest applicable timestamp
+    return applicableTimestamp !== undefined
+        ? (multipliersByTimestamp[applicableTimestamp] ?? 1)
+        : 1;
+};
+exports.getRewardMultiplierByTimestamp = getRewardMultiplierByTimestamp;
+/**
+ * Build the human-readable display label for a single reward.
+ *
+ * The format is `"{multiplier}x {text}"`, with the multiplier prefix omitted
+ * when it equals 1 (e.g. `"2x Cores"`, `" Cores"` when multiplier is 1 — the
+ * leading space is preserved to keep `additionalPoints` and the
+ * `additionalPointsDetailed` label in lockstep). This is a display string only;
+ * consumers that need a stable key should join on the reward's `id`
+ * (see {@link IVaultRewardDetail}), not on this label.
+ *
+ * @param reward - The raw tokenized-vault reward.
+ * @returns The display label string.
+ */
+function getRewardLabel(reward) {
+    return `${reward.multiplier !== 1 ? `${reward.multiplier}x` : ''} ${reward.text}`;
+}
+/**
+ * Get the rewards for the vault.
+ *
+ * Builds the display-facing rewards summary from the raw tokenized-vault
+ * rewards array. In addition to the legacy `additionalPoints` string list, it
+ * emits `additionalPointsDetailed`, which pairs each label with its
+ * backend-provided `img_url`. Consumers (e.g. the Upshift app) resolve a
+ * reward's logo from this `imgUrl` first, falling back to a bundled asset only
+ * when it is absent — so a newly-added reward with a backend logo (e.g.
+ * "Cores") renders its icon without any client-side keyword mapping.
+ *
+ * @param tokenizedVault - The tokenized vault.
+ * @returns The rewards summary, including `additionalPointsDetailed`.
+ */
+function getVaultRewards(tokenizedVault) {
+    const upshiftPointRewards = tokenizedVault.rewards?.filter((r) => r.text === 'Upshift Points');
+    const sortedPointsMultipliers = upshiftPointRewards?.sort((a, b) => new Date(b.start_datetime).getTime() -
+        new Date(a.start_datetime).getTime());
+    const upshiftPointsMultipliers = sortedPointsMultipliers?.map((r) => ({
+        timestamp: new Date(r.start_datetime).getTime() / 1000,
+        value: r.multiplier,
+    }));
+    const latestUpshiftPointMultiplier = upshiftPointsMultipliers?.[0]?.value;
+    const rewards = {
+        points: upshiftPointRewards.length
+            ? `${latestUpshiftPointMultiplier}x Upshift Points`
+            : '',
+        multiplier: latestUpshiftPointMultiplier,
+        multipliers: upshiftPointsMultipliers,
+        additionalPoints: tokenizedVault.rewards.map(getRewardLabel),
+        additionalPointsDetailed: tokenizedVault.rewards.map((r) => ({
+            id: r.id,
+            label: getRewardLabel(r),
+            text: r.text,
+            imgUrl: r.img_url || null,
+            multiplier: r.multiplier,
+        })),
+    };
+    return rewards;
+}
+/**
+ * Get the idle assets for the vault
+ * @param provider - The provider
+ * @param vaultAddress - The vault address
+ * @param totalAssets - The total assets of the vault
+ * @param knownVersion - Optional pre-resolved vault version. Callers that
+ *   already hold the backend row (e.g. `buildFormattedVault`) pass it so this
+ *   function doesn't re-fetch `GET /tokenized_vault/{address}` — and with the
+ *   API's default load flags at that, a heavier payload on a different cache
+ *   key than the caller's own fetch — just to dispatch on the version.
+ * @returns The idle assets
+ */
+async function getIdleAssets(provider, vaultAddress, underlying, totalAssets, knownVersion) {
+    const version = knownVersion ??
+        (0, vaults_1.getVaultVersionV2)((await (0, core_1.fetchTokenizedVault)(vaultAddress, undefined, false, false))?.[0]);
+    let idleAssets;
+    switch (version) {
+        case 'evm-0': {
+            // old lending pool
+            const globalLoansAmount = await (0, core_1.createContract)({
+                provider,
+                address: vaultAddress,
+                abi: abis_1.ABI_LENDING_POOLS,
+            }).globalLoansAmount();
+            idleAssets = BigInt(totalAssets.raw) - BigInt(globalLoansAmount);
+            break;
+        }
+        case 'evm-2': {
+            const vaultContract = (0, core_1.createContract)({
+                provider,
+                address: vaultAddress,
+                abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+            });
+            const primaryAsset = await vaultContract.asset();
+            idleAssets = await (0, core_1.createContract)({
+                provider,
+                address: primaryAsset,
+                abi: abis_1.ABI_ERC20,
+            }).balanceOf(vaultAddress);
+            break;
+        }
+        default: {
+            // tokenized vault
+            idleAssets = await (0, core_1.createContract)({
+                provider,
+                address: underlying,
+                abi: abis_1.ABI_ERC20,
+            }).balanceOf(vaultAddress);
+            break;
+        }
+    }
+    return idleAssets;
+}
+async function getYieldLastRealizedOn(provider, vaultAddress) {
+    const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vaultAddress))?.[0];
+    if (!tokenizedVault) {
+        throw new Error(`Vault ${vaultAddress} not found`);
+    }
+    const version = (0, vaults_1.getVaultVersionV2)(tokenizedVault);
+    let assetsUpdatedOn;
+    switch (version) {
+        case 'evm-2': {
+            const contract = (0, core_1.createContract)({
+                provider,
+                address: vaultAddress,
+                abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+            });
+            assetsUpdatedOn = await contract.assetsUpdatedOn();
+            break;
+        }
+        case 'evm-0': {
+            const contract = (0, core_1.createContract)({
+                provider,
+                address: vaultAddress,
+                abi: abis_1.ABI_LENDING_POOL_V3,
+            });
+            assetsUpdatedOn = await contract.assetsUpdatedOn();
+            break;
+        }
+        case 'sol-0':
+        case 'stellar-0': {
+            return 0;
+        }
+        default: {
+            // Default to V3 ABI which has assetsUpdatedOn
+            const contract = (0, core_1.createContract)({
+                provider,
+                address: vaultAddress,
+                abi: abis_1.ABI_LENDING_POOL_V3,
+            });
+            assetsUpdatedOn = await contract.assetsUpdatedOn();
+            break;
+        }
+    }
+    return Number(assetsUpdatedOn);
+}
+/**
+ * Format APY data from backend tokenized vault into the unified IVaultApy shape.
+ * Shared across all chain adapters (EVM, Solana, Stellar).
+ */
+function formatVaultApy(tokenizedVault) {
+    const { reported_apy, campaign_apy } = tokenizedVault;
+    return {
+        apy: (reported_apy?.apy ?? 0) * 100,
+        explainer: reported_apy?.explainer ?? null,
+        pointsApy: reported_apy?.points_apy != null ? reported_apy.points_apy * 100 : null,
+        campaignApy: campaign_apy != null ? campaign_apy * 100 : null,
+        liquidApy: (reported_apy?.liquid_apy ?? 0) * 100,
+        rewardsClaimable: reported_apy?.rewards_claimable ?? null,
+        rewardsCompounded: reported_apy?.rewards_compounded ?? null,
+        underlyingApy: (reported_apy?.underlying_apy ?? 0) * 100,
+    };
+}
+/**
+ * Map the backend `freshness` object onto the camelCased {@link IVaultFreshness}
+ * shape carried on `IVault`. Shared across all chain adapters (EVM, Solana,
+ * Stellar) so every surface reports provenance identically.
+ *
+ * Each of the three stamps is passed through independently: a missing member
+ * becomes `null` and is never defaulted from one of the others. That is the point
+ * of the object — `apy_computed_at` and `share_ratio_snapshot_at` describe two
+ * different pipelines, and collapsing them would erase the very staleness signal
+ * (snapshot newer than APY) the field exists to expose.
+ *
+ * @param tokenizedVault - Backend tokenized-vault payload. `freshness` is absent on
+ *   responses predating the backend change, and may be explicitly null.
+ * @returns The mapped freshness object, or `null` when the backend reported none.
+ *   Values are the backend's RFC 3339 UTC strings verbatim — no reformatting, so
+ *   the trailing `Z` is preserved.
+ */
+function mapVaultFreshness(tokenizedVault) {
+    const freshness = tokenizedVault?.freshness;
+    if (!freshness)
+        return null;
+    return {
+        apyComputedAt: freshness.apy_computed_at ?? null,
+        shareRatioSnapshotAt: freshness.share_ratio_snapshot_at ?? null,
+        cachedAt: freshness.cached_at ?? null,
+    };
+}
+/**
+ * Map a wrapper vault's link to the vault it wraps.
+ *
+ * @param tokenizedVault - Backend tokenized-vault payload.
+ * @returns The underlying vault address (casing preserved) and chain id, both
+ *   null for a non-wrapper vault. A chain id without an address is dropped.
+ */
+function mapUnderlyingVault(tokenizedVault) {
+    const address = tokenizedVault?.underlying_vault_address;
+    if (!address)
+        return { underlyingVaultAddress: null, underlyingChainId: null };
+    return {
+        underlyingVaultAddress: address,
+        underlyingChainId: tokenizedVault?.underlying_chain ?? null,
+    };
+}
+/**
+ * Map strategists from backend subaccounts or hardcoded list.
+ * Shared across all chain adapters.
+ */
+function mapStrategists(tokenizedVault) {
+    const hasValidStrategists = tokenizedVault.subaccounts?.length > 0 &&
+        tokenizedVault.subaccounts.some((s) => s.strategist !== null);
+    return hasValidStrategists
+        ? tokenizedVault.subaccounts
+            .filter((s) => s.strategist !== null)
+            .map((s) => ({
+            address: s.address,
+            logo: s.strategist?.strategist_logo,
+            name: s.strategist?.strategist_name,
+            type: 'subaccount',
+            website_url: s.strategist?.website_url ?? null,
+        }))
+        : (tokenizedVault.hardcoded_strategists || []).map((s) => ({
+            address: '0x',
+            logo: s.strategist_logo,
+            name: s.strategist_name,
+            type: 'subaccount',
+            website_url: s.website_url ?? null,
+        }));
+}
+/**
+ * Map composability integrations from backend format to vault format.
+ * Shared across all chain adapters.
+ */
+function mapComposabilityIntegrations(tokenizedVault) {
+    return (tokenizedVault.composability_integrations?.map((integration) => ({
+        name: integration.name,
+        description: integration.description,
+        earningMultiplier: integration.earning_multiplier,
+        protocolUrl: integration.protocol_url,
+        logoUrl: integration.logo_url,
+        tokenizedVaultId: integration.tokenized_vault_id,
+        id: integration.id,
+    })) || []);
+}
+/**
+ * Convert a backend-reported TVL (whole token units) to a NormalizedBn.
+ * Handles null, undefined, and non-finite values (NaN, Infinity) safely, defaulting to 0.
+ * Shared between non-EVM adapters (Solana, Stellar) and the module-level getVaultTvl handler.
+ */
+function backendTvlToNormalizedBn(tvl, decimals) {
+    if (tvl == null) {
+        core_1.Logger.log.warn('backendTvlToNormalizedBn', 'TVL is null/undefined, defaulting to 0 — check backend data pipeline', { decimals });
+        return (0, core_1.toNormalizedBn)(BigInt(0), decimals);
+    }
+    if (!Number.isFinite(tvl) || tvl < 0) {
+        core_1.Logger.log.warn('backendTvlToNormalizedBn', tvl < 0
+            ? 'Negative TVL value, defaulting to 0'
+            : 'Non-finite TVL value, defaulting to 0', { tvl, decimals });
+        return (0, core_1.toNormalizedBn)(BigInt(0), decimals);
+    }
+    const scaleFactor = BigInt(10) ** BigInt(decimals);
+    const tvlWhole = BigInt(Math.round(tvl));
+    return (0, core_1.toNormalizedBn)(tvlWhole * scaleFactor, decimals);
+}
+/**
+ * Map daily PnL per share from backend Record format to array format.
+ * Shared across non-EVM adapters.
+ */
+function mapDailyPnlPerShare(dailyPnl) {
+    if (!dailyPnl)
+        return [];
+    return Object.entries(dailyPnl).map(([timestamp, value]) => ({
+        timestamp,
+        value,
+    }));
+}
+/**
+ * Build a base IVault from backend data, shared across non-EVM adapters (Solana, Stellar).
+ * Chain-specific fields (chainId, version, name, totalAssets, totalSupply, depositAssets, receipt)
+ * must be provided via the overrides parameter.
+ */
+function buildBackendVault(tokenizedVault, overrides) {
+    const apy = formatVaultApy(tokenizedVault);
+    const rewards = tokenizedVault.rewards?.length
+        ? getVaultRewards(tokenizedVault)
+        : {
+            points: '0',
+            multiplier: 0,
+            multipliers: [],
+            additionalPoints: [],
+            additionalPointsDetailed: [],
+        };
+    return {
+        operator: '0x',
+        eoa_operators: [],
+        operators: [],
+        historical_snapshots: tokenizedVault.historical_snapshots || [],
+        address: tokenizedVault.address,
+        historical_apy: tokenizedVault.historical_apy,
+        historical_compound_apy: tokenizedVault.historical_compound_apy,
+        max_drawdown: tokenizedVault.max_drawdown,
+        logoUrl: tokenizedVault.vault_logo_url || '/img/strategist/august.svg',
+        description: tokenizedVault.description || '',
+        startDatetime: tokenizedVault.start_datetime
+            ? new Date(tokenizedVault.start_datetime).toISOString()
+            : new Date(0).toISOString(),
+        status: tokenizedVault.status,
+        tags: [tokenizedVault.public_type || 'Defi Yield'],
+        isFeatured: tokenizedVault.is_featured || false,
+        isSpotlighted: tokenizedVault.is_spotlighted ?? false,
+        withdrawalOnly: tokenizedVault.withdrawal_only ?? false,
+        isVisible: tokenizedVault.is_visible || false,
+        reserveTarget: tokenizedVault.reserve_target || 0,
+        reserveTolerance: tokenizedVault.reserve_tolerance || 0,
+        // Vault decimals are derived from the receipt token decimals for non-EVM vaults
+        decimals: overrides.receipt.decimals,
+        maxSupply: (0, core_1.toNormalizedBn)(1_000_000_000),
+        depositCap: null,
+        apy,
+        rewards,
+        fees: {
+            performance: tokenizedVault.weekly_performance_fee_bps || 0,
+            management: tokenizedVault.platform_fee_override?.management_fee || 0,
+            isManagementWaived: (0, vaults_1.resolveFeeWaived)(tokenizedVault.platform_fee_override?.is_fee_waived ?? false, tokenizedVault.management_fee_waived_until_date ?? null, tokenizedVault.management_fee_waived_until_tvl ?? null),
+            managementFeeWaivedUntilDate: tokenizedVault.management_fee_waived_until_date ?? null,
+            managementFeeWaivedUntilTvl: tokenizedVault.management_fee_waived_until_tvl ?? null,
+            isPerformanceWaived: (0, vaults_1.resolveFeeWaived)(tokenizedVault.platform_fee_override?.is_fee_waived ?? false, tokenizedVault.performance_fee_waived_until_date ?? null, tokenizedVault.performance_fee_waived_until_tvl ?? null),
+            performanceFeeWaivedUntilDate: tokenizedVault.performance_fee_waived_until_date ?? null,
+            performanceFeeWaivedUntilTvl: tokenizedVault.performance_fee_waived_until_tvl ?? null,
+        },
+        lagDuration: 0,
+        withdrawalMarginSeconds: tokenizedVault.withdrawal_margin_seconds ?? null,
+        iatTraders: tokenizedVault.iat_traders ?? null,
+        maxDailyDrawdown: tokenizedVault.max_daily_drawdown || 0,
+        risk: tokenizedVault.risk || 'low',
+        isWithdrawalPaused: false,
+        isDepositPaused: false,
+        idleAssets: (0, core_1.toNormalizedBn)(0),
+        loans: [],
+        allocations: {
+            unfilteredTokens: [],
+            defi: [],
+            tokens: [],
+            cefi: [],
+            otc: {},
+            exposurePerCategory: {
+                borrowing: [],
+                supplying: [],
+                lending: [],
+                wallet: [],
+                cefiBalance: 0,
+                defiBalance: 0,
+                walletBalance: 0,
+                loanBalance: 0,
+            },
+            netValue: 0,
+            defiPerBorrower: {},
+        },
+        position: {
+            vault: tokenizedVault.address,
+            status: 'active',
+            availableRedemptions: [],
+            pendingRedemptions: [],
+            redeemable: (0, core_1.toNormalizedBn)(0),
+            walletBalance: (0, core_1.toNormalizedBn)(0),
+        },
+        composabilityIntegrations: mapComposabilityIntegrations(tokenizedVault),
+        strategists: mapStrategists(tokenizedVault),
+        cachedAt: tokenizedVault.cached_at ?? null,
+        freshness: mapVaultFreshness(tokenizedVault),
+        dailyPnlPerShare: mapDailyPnlPerShare(tokenizedVault.daily_pnl_per_share),
+        enabled_historical_price_horizons: tokenizedVault.enabled_historical_price_horizons || [],
+        latest_reported_tvl: tokenizedVault.latest_reported_tvl,
+        ...mapUnderlyingVault(tokenizedVault),
+        defaultApyHorizon: tokenizedVault.default_apy_horizon,
+        ...(tokenizedVault.instant_redeem_config
+            ? {
+                instant_redeem_config: {
+                    subaccountAddress: tokenizedVault.instant_redeem_config
+                        .subaccount_address,
+                    outputAssetSymbol: tokenizedVault.instant_redeem_config.output_asset_symbol,
+                    redeemableAssets: tokenizedVault.instant_redeem_config.redeemable_assets.map((a) => ({
+                        address: a.address,
+                        symbol: a.symbol,
+                        decimals: a.decimals,
+                        spreadBps: a.spread_bps,
+                    })),
+                    isPaused: tokenizedVault.instant_redeem_config.is_paused,
+                    availableLiquidity: tokenizedVault.instant_redeem_config.available_liquidity,
+                },
+            }
+            : {}),
+        showCapFilled: tokenizedVault?.show_cap_filled ?? null,
+        apyOverride: tokenizedVault.apy_override ?? null,
+        // Spread chain-specific overrides last so they take precedence
+        ...overrides,
+    };
+}
+/**
+ * Build the formatted vault
+ * @param provider - The provider
+ * @param tokenizedVault - The tokenized vault
+ * @param contractCalls - The contract calls
+ * @returns The formatted vault
+ */
+async function buildFormattedVault(provider, tokenizedVault, contractCalls) {
+    const strategists = mapStrategists(tokenizedVault);
+    const operators = tokenizedVault?.operators || [];
+    const eoa_operators = tokenizedVault?.eoa_operators || [];
+    // Load offchain props
+    const baseProps = {
+        chainId: tokenizedVault.chain,
+        maxDailyDrawdown: tokenizedVault.max_daily_drawdown || 0,
+        risk: tokenizedVault.risk,
+        lagDuration: Number(contractCalls.lagDuration),
+        withdrawalMarginSeconds: tokenizedVault.withdrawal_margin_seconds ?? null,
+        iatTraders: tokenizedVault.iat_traders ?? null,
+        address: tokenizedVault.address,
+        name: tokenizedVault.vault_name,
+        logoUrl: tokenizedVault.vault_logo_url,
+        // Single source of truth shared with the Solana/Stellar adapters. The
+        // inline version this replaced produced `NaN` for liquid/underlying APY
+        // when `reported_apy` was absent and `null` for a genuine 0% `apy`.
+        apy: formatVaultApy(tokenizedVault),
+        strategists: strategists,
+        eoa_operators,
+        operators,
+        fees: {
+            performance: tokenizedVault.weekly_performance_fee_bps,
+            management: tokenizedVault.platform_fee_override.management_fee,
+            isManagementWaived: (0, vaults_1.resolveFeeWaived)(tokenizedVault.platform_fee_override.is_fee_waived, tokenizedVault.management_fee_waived_until_date, tokenizedVault.management_fee_waived_until_tvl),
+            managementFeeWaivedUntilDate: tokenizedVault.management_fee_waived_until_date,
+            managementFeeWaivedUntilTvl: tokenizedVault.management_fee_waived_until_tvl,
+            isPerformanceWaived: (0, vaults_1.resolveFeeWaived)(tokenizedVault.platform_fee_override.is_fee_waived, tokenizedVault.performance_fee_waived_until_date, tokenizedVault.performance_fee_waived_until_tvl),
+            performanceFeeWaivedUntilDate: tokenizedVault.performance_fee_waived_until_date,
+            performanceFeeWaivedUntilTvl: tokenizedVault.performance_fee_waived_until_tvl,
+        },
+        rewards: getVaultRewards(tokenizedVault),
+        version: (0, vaults_1.getVaultVersionV2)(tokenizedVault),
+        description: tokenizedVault.description,
+        startDatetime: String(tokenizedVault.start_datetime),
+        status: tokenizedVault.status,
+        tags: [tokenizedVault.public_type],
+        isFeatured: tokenizedVault.is_featured,
+        withdrawalOnly: tokenizedVault.withdrawal_only ?? false,
+        isSpotlighted: tokenizedVault.is_spotlighted ?? false,
+        isVisible: tokenizedVault.is_visible,
+        reserveTarget: tokenizedVault.reserve_target,
+        reserveTolerance: tokenizedVault.reserve_tolerance,
+        // On-chain pause first, then the hardcoded deny list — a vault can be
+        // withheld from deposits for either reason and the list is not a substitute
+        // for reading the contract.
+        isDepositPaused: contractCalls.depositsPaused === true ||
+            (0, vaults_1.isBadVault)(tokenizedVault.address),
+        decimals: contractCalls.decimals,
+        isWithdrawalPaused: contractCalls.withdrawalsPaused,
+        idleAssets: (0, core_1.toNormalizedBn)(await getIdleAssets(provider, tokenizedVault.address, contractCalls.asset, contractCalls.totalAssets, 
+        // The row is already in hand — don't let getIdleAssets re-fetch it
+        // just to resolve the version.
+        (0, vaults_1.getVaultVersionV2)(tokenizedVault)), Number(contractCalls.decimals)),
+    };
+    // Version specific logic
+    const version = (0, vaults_1.getVaultVersionV2)(tokenizedVault);
+    let operator = '0x';
+    let depositAssets = [];
+    let totalAssets = (0, core_1.toNormalizedBn)(0);
+    let totalSupply = (0, core_1.toNormalizedBn)(0);
+    let maxSupply = (0, core_1.toNormalizedBn)(0);
+    let depositCap = null;
+    let maxDepositAmount = null;
+    let receipt = {
+        symbol: '',
+        address: '0x',
+        decimals: 0,
+    };
+    switch (version) {
+        case 'sol-0': {
+            // @todo
+            break;
+        }
+        case 'evm-2': {
+            totalAssets = contractCalls.getTotalAssets;
+            depositAssets.push({
+                address: contractCalls.asset,
+                symbol: await (0, core_1.getSymbol)(provider, contractCalls.asset, false),
+                decimals: contractCalls.decimals,
+            });
+            const extraAssets = await Promise.all(contractCalls.getWhitelistedAssets.map(async (a) => {
+                const decimals = await (0, core_1.getDecimals)(provider, a, false);
+                const symbol = await (0, core_1.getSymbol)(provider, a, false);
+                return {
+                    address: a,
+                    symbol,
+                    decimals,
+                };
+            }));
+            if (contractCalls.depositCap) {
+                depositCap = contractCalls.depositCap;
+            }
+            depositAssets = [...depositAssets, ...extraAssets];
+            totalSupply = contractCalls.totalSupply;
+            (maxSupply =
+                (0, core_1.toNormalizedBn)(1_000_000_000_000)), // @hardcoded: no maxSupply on here
+                (receipt = {
+                    symbol: tokenizedVault.receipt_token_symbol,
+                    address: contractCalls.lpTokenAddress,
+                    decimals: contractCalls.decimals,
+                });
+            // @todo: get operator
+            // operator = contractCalls.loansOperator as IAddress;
+            break;
+        }
+        default: {
+            // get idle assets
+            depositAssets = [
+                {
+                    address: contractCalls.asset,
+                    symbol: await (0, core_1.getSymbol)(provider, contractCalls.asset, false),
+                    decimals: contractCalls.decimals,
+                },
+            ];
+            totalAssets = contractCalls.totalAssets;
+            totalSupply = contractCalls.totalSupply;
+            maxSupply = contractCalls.maxSupply;
+            if (contractCalls.maxDepositAmount) {
+                maxDepositAmount = contractCalls.maxDepositAmount;
+            }
+            operator = contractCalls.loansOperator;
+            receipt = {
+                symbol: tokenizedVault.receipt_token_symbol,
+                address: tokenizedVault.address,
+                decimals: contractCalls.decimals,
+            };
+            break;
+        }
+    }
+    // Check for adapter configuration and add adapter deposit tokens
+    const adapterConfig = (0, core_1.getVaultAdapterConfig)(tokenizedVault.address);
+    if (adapterConfig) {
+        const allDepositTokens = (0, core_1.getVaultDepositTokens)(tokenizedVault.address, contractCalls.asset);
+        // Build deposit assets array including adapter tokens
+        const depositAssetsWithAdapters = await Promise.all(allDepositTokens.map(async (tokenAddress) => {
+            // Skip if already in depositAssets
+            if (depositAssets.find((a) => a.address.toLowerCase() === tokenAddress.toLowerCase())) {
+                return null;
+            }
+            const decimals = await (0, core_1.getDecimals)(provider, tokenAddress, false);
+            const symbol = await (0, core_1.getSymbol)(provider, tokenAddress, false);
+            return {
+                address: tokenAddress,
+                symbol,
+                decimals,
+            };
+        }));
+        // Add adapter tokens to depositAssets
+        depositAssets = [
+            ...depositAssets,
+            ...depositAssetsWithAdapters.filter((a) => a !== null),
+        ];
+    }
+    const result = {
+        ...baseProps,
+        operator: operator,
+        depositAssets: depositAssets,
+        totalAssets: totalAssets,
+        totalSupply: totalSupply,
+        maxSupply: maxSupply,
+        depositCap: depositCap,
+        maxDepositAmount: maxDepositAmount,
+        receipt: receipt,
+        historical_apy: tokenizedVault?.historical_apy,
+        historical_compound_apy: tokenizedVault?.historical_compound_apy,
+        historical_snapshots: tokenizedVault?.historical_snapshots || [],
+        max_drawdown: tokenizedVault?.max_drawdown,
+        composabilityIntegrations: mapComposabilityIntegrations(tokenizedVault),
+        dailyPnlPerShare: tokenizedVault?.daily_pnl_per_share
+            ? Object.entries(tokenizedVault.daily_pnl_per_share).map(([timestamp, value]) => ({
+                timestamp,
+                value,
+            }))
+            : [],
+        enabled_historical_price_horizons: tokenizedVault?.enabled_historical_price_horizons,
+        defaultApyHorizon: tokenizedVault?.default_apy_horizon ?? null,
+        latest_reported_tvl: tokenizedVault?.latest_reported_tvl,
+        ...mapUnderlyingVault(tokenizedVault),
+        cachedAt: tokenizedVault?.cached_at ?? null,
+        freshness: mapVaultFreshness(tokenizedVault),
+        showCapFilled: tokenizedVault?.show_cap_filled ?? null,
+        apyOverride: tokenizedVault?.apy_override ?? null,
+    };
+    if (tokenizedVault.instant_redeem_config) {
+        const config = tokenizedVault.instant_redeem_config;
+        result.instant_redeem_config = {
+            subaccountAddress: config.subaccount_address,
+            outputAssetSymbol: config.output_asset_symbol,
+            redeemableAssets: config.redeemable_assets.map((a) => ({
+                address: a.address,
+                symbol: a.symbol,
+                decimals: a.decimals,
+                spreadBps: a.spread_bps,
+            })),
+            isPaused: config.is_paused,
+            availableLiquidity: config.available_liquidity,
+        };
+    }
+    return result;
+}
+exports.ERC_20_PERMIT_HASH = '0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9';
+/**
+ * Generate an ERC2612 permit signature
+ * @param token - The ERC20 token contract address
+ * @param owner - The token owner's address (signer)
+ * @param spender - The address that will be approved to spend (your pool contract)
+ * @param value - The amount to approve
+ * @param deadline - Unix timestamp for when the permit expires
+ * @param signer - The ethers.js Signer (wallet)
+ * @param provider - The ethers.js Provider
+ * @returns The signature components (v, r, s) and deadline
+ */
+async function generatePermitSignature(token, owner, spender, value, deadline, signer, chainId) {
+    const tokenContract = (0, core_1.createContract)({
+        address: token,
+        provider: signer,
+        abi: abis_1.ABI_TOKENIZED_VAULT_V2_RECEIPT,
+    });
+    const noncePromise = tokenContract.nonces(owner);
+    const domainSeparatorPromise = (async () => {
+        try {
+            return await tokenContract.DOMAIN_SEPARATOR();
+        }
+        catch (error) {
+            core_1.Logger.log.error('generatePermitSignature', error, {
+                message: 'Could not fetch DOMAIN_SEPARATOR from contract',
+            });
+            throw error;
+        }
+    })();
+    const [nonce, contractDomainSeparator] = await Promise.all([
+        noncePromise,
+        domainSeparatorPromise,
+    ]);
+    const valueBigInt = typeof value === 'string' ? BigInt(value) : value;
+    const permitDomainCacheKey = `permit-domain-${chainId}-${token.toLowerCase()}`;
+    const cachedDomain = core_1.CACHE.get(permitDomainCacheKey);
+    let matchingDomain = null;
+    if (cachedDomain) {
+        const cachedHash = ethers_1.ethers.TypedDataEncoder.hashDomain(cachedDomain);
+        if (cachedHash.toLowerCase() === contractDomainSeparator.toLowerCase()) {
+            matchingDomain = cachedDomain;
+        }
+        else {
+            core_1.CACHE.delete(permitDomainCacheKey);
+        }
+    }
+    if (!matchingDomain) {
+        const name = (await tokenContract.name());
+        // Try different domain configurations to find which matches
+        const domainConfigs = [
+            // Standard EIP-2612
+            { name, version: '1', chainId, verifyingContract: token },
+            { name, version: '2', chainId, verifyingContract: token },
+            // Without version
+            { name, chainId, verifyingContract: token },
+            // With different salt values (some contracts use this)
+            {
+                name,
+                version: '1',
+                chainId,
+                verifyingContract: token,
+                salt: ethers_1.ethers.zeroPadValue('0x', 32),
+            },
+        ];
+        for (const domain of domainConfigs) {
+            const computed = ethers_1.ethers.TypedDataEncoder.hashDomain(domain);
+            if (computed.toLowerCase() === contractDomainSeparator.toLowerCase()) {
+                matchingDomain = domain;
+                break;
+            }
+        }
+        if (!matchingDomain) {
+            // If no match, try to get the version from the contract
+            // Some token contracts have a version() method for EIP-2612 domain
+            try {
+                const version = await tokenContract.version();
+                matchingDomain = { name, version, chainId, verifyingContract: token };
+                const computed = ethers_1.ethers.TypedDataEncoder.hashDomain(matchingDomain);
+                if (computed.toLowerCase() !== contractDomainSeparator.toLowerCase()) {
+                    throw new Error('Could not match DOMAIN_SEPARATOR even with contract version');
+                }
+            }
+            catch {
+                throw new Error(`Could not determine correct domain configuration. Contract DOMAIN_SEPARATOR: ${contractDomainSeparator}`);
+            }
+        }
+        core_1.CACHE.set(permitDomainCacheKey, matchingDomain, {
+            ttl: 60 * 60 * 1000,
+        });
+    }
+    // EIP-2612 Permit type
+    const types = {
+        Permit: [
+            { name: 'owner', type: 'address' },
+            { name: 'spender', type: 'address' },
+            { name: 'value', type: 'uint256' },
+            { name: 'nonce', type: 'uint256' },
+            { name: 'deadline', type: 'uint256' },
+        ],
+    };
+    const message = {
+        owner: owner,
+        spender: spender,
+        value: valueBigInt,
+        nonce: Number(nonce),
+        deadline: deadline,
+    };
+    // Sign the typed data
+    const signature = await signer.signTypedData(matchingDomain, types, message);
+    // Split signature into r, s, v
+    const sig = ethers_1.ethers.Signature.from(signature);
+    return {
+        r: sig.r,
+        s: sig.s,
+        v: sig.v,
+        deadline: deadline,
+    };
+}
+/**
+ * Helper to create a deadline (current time + offset in seconds)
+ * @param offsetSeconds - Number of seconds from now (default: 20 minutes)
+ * @returns Unix timestamp
+ */
+function createDeadline(offsetSeconds = 1200) {
+    return Math.floor(Date.now() / 1000) + offsetSeconds;
+}
+//# sourceMappingURL=utils.js.map