@lit-protocol/vincent-ability-morpho 0.1.17-mma → 0.1.19-mma

package/dist/src/lib/helpers/index.js

@@ -1,30 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.morphoVaultClient = exports.MorphoVaultClient = exports.VAULT_FILTER_PRESETS = exports.BUNDLER_ADDRESSES = exports.BUNDLER_ABI = exports.ERC20_ABI = exports.ERC4626_VAULT_ABI = exports.WELL_KNOWN_TOKENS = exports.SUPPORTED_CHAINS = exports.CHAIN_IDS = void 0;
-exports.getTokenAddresses = getTokenAddresses;
-exports.getTokenAddress = getTokenAddress;
-exports.isSupportedChain = isSupportedChain;
-exports.getSupportedChainIds = getSupportedChainIds;
-exports.getChainName = getChainName;
-exports.isValidAddress = isValidAddress;
-exports.parseAmount = parseAmount;
-exports.formatAmount = formatAmount;
+exports.ERC4626_VAULT_ABI = exports.ERC20_ABI = exports.CHAIN_IDS = exports.SUPPORTED_CHAINS = void 0;
 exports.validateOperationRequirements = validateOperationRequirements;
-exports.getBestVaultsForAsset = getBestVaultsForAsset;
-exports.getTopVaultsByNetApy = getTopVaultsByNetApy;
-exports.getTopVaultsByTvl = getTopVaultsByTvl;
-exports.searchVaults = searchVaults;
-exports.getVaultsByPreset = getVaultsByPreset;
-exports.getVaults = getVaults;
-exports.getSupportedChainsWithVaults = getSupportedChainsWithVaults;
-exports.getVaultDiscoverySummary = getVaultDiscoverySummary;
-exports.normalizeLitSig = normalizeLitSig;
-exports.buildDepositTxData = buildDepositTxData;
-exports.buildRedeemTxData = buildRedeemTxData;
-exports.executeChainOperation = executeChainOperation;
+exports.getMorphoVaultByAddress = getMorphoVaultByAddress;
+exports.executeMorphoOperation = executeMorphoOperation;
 const vincent_scaffold_sdk_1 = require("@lit-protocol/vincent-scaffold-sdk");
-const bundler_sdk_ethers_1 = require("@morpho-org/bundler-sdk-ethers");
-const ethers_1 = require("ethers");
+const schemas_1 = require("../schemas");
+/**
+ * Supported chain IDs and their names
+ */
+exports.SUPPORTED_CHAINS = {
+    1: 'ethereum',
+    8453: 'base',
+    42161: 'arbitrum',
+    10: 'optimism',
+    137: 'polygon',
+};
 /**
  * Chain names to IDs mapping for backwards compatibility
  */
@@ -36,51 +27,50 @@ exports.CHAIN_IDS = {
     polygon: 137,
 };
 /**
- * Supported chain IDs and their names
- */
-exports.SUPPORTED_CHAINS = {
-    [exports.CHAIN_IDS.ethereum]: 'ethereum',
-    [exports.CHAIN_IDS.base]: 'base',
-    [exports.CHAIN_IDS.arbitrum]: 'arbitrum',
-    [exports.CHAIN_IDS.optimism]: 'optimism',
-    [exports.CHAIN_IDS.polygon]: 'polygon',
-};
-/**
- * Well-known token addresses across different chains
- * Using official Circle USDC and canonical WETH addresses
+ * ERC20 Token ABI - Essential methods only
  */
-exports.WELL_KNOWN_TOKENS = {
-    [exports.CHAIN_IDS.ethereum]: {
-        USDC: '0xA0b86991c6218A36c1D19D4a2e9Eb0cE3606eB48', // Circle USDC
-        WETH: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // Canonical WETH
-        USDT: '0xdAC17F958D2ee523a2206206994597C13D831ec7', // Tether USDT
-    },
-    [exports.CHAIN_IDS.base]: {
-        USDC: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // Native USDC on Base
-        WETH: '0x4200000000000000000000000000000000000006', // WETH on Base
-        USDT: '0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2', // USDT on Base
+exports.ERC20_ABI = [
+    {
+        inputs: [{ internalType: 'address', name: 'account', type: 'address' }],
+        name: 'balanceOf',
+        outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
     },
-    [exports.CHAIN_IDS.arbitrum]: {
-        USDC: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', // Native USDC on Arbitrum
-        WETH: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', // WETH on Arbitrum
-        USDT: '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9', // USDT on Arbitrum
+    {
+        inputs: [
+            { internalType: 'address', name: 'owner', type: 'address' },
+            { internalType: 'address', name: 'spender', type: 'address' },
+        ],
+        name: 'allowance',
+        outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
     },
-    [exports.CHAIN_IDS.optimism]: {
-        USDC: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85', // Native USDC on Optimism
-        WETH: '0x4200000000000000000000000000000000000006', // WETH on Optimism
-        USDT: '0x94b008aA00579c1307B0EF2c499aD98a8ce58e58', // USDT on Optimism
+    {
+        inputs: [
+            { internalType: 'address', name: 'spender', type: 'address' },
+            { internalType: 'uint256', name: 'amount', type: 'uint256' },
+        ],
+        name: 'approve',
+        outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+        stateMutability: 'nonpayable',
+        type: 'function',
     },
-    [exports.CHAIN_IDS.polygon]: {
-        USDC: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359', // Native USDC on Polygon
-        WETH: '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619', // WETH on Polygon
-        USDT: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F', // USDT on Polygon
+    {
+        inputs: [],
+        name: 'decimals',
+        outputs: [{ internalType: 'uint8', name: '', type: 'uint8' }],
+        stateMutability: 'view',
+        type: 'function',
     },
-};
+];
 /**
  * ERC4626 Vault ABI - Essential methods for Morpho vaults
  */
 exports.ERC4626_VAULT_ABI = [
-    // Deposit
+    // ERC4626 is an extension of ERC20, the token represents vault shares
+    ...exports.ERC20_ABI,
     {
         inputs: [
             { internalType: 'uint256', name: 'assets', type: 'uint256' },
@@ -91,7 +81,6 @@ exports.ERC4626_VAULT_ABI = [
         stateMutability: 'nonpayable',
         type: 'function',
     },
-    // Redeem
     {
         inputs: [
             { internalType: 'uint256', name: 'shares', type: 'uint256' },
@@ -103,7 +92,6 @@ exports.ERC4626_VAULT_ABI = [
         stateMutability: 'nonpayable',
         type: 'function',
     },
-    // Asset (underlying token address)
     {
         inputs: [],
         name: 'asset',
@@ -111,15 +99,6 @@ exports.ERC4626_VAULT_ABI = [
         stateMutability: 'view',
         type: 'function',
     },
-    // Balance of shares
-    {
-        inputs: [{ internalType: 'address', name: 'account', type: 'address' }],
-        name: 'balanceOf',
-        outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
-        stateMutability: 'view',
-        type: 'function',
-    },
-    // Convert assets to shares
     {
         inputs: [{ internalType: 'uint256', name: 'assets', type: 'uint256' }],
         name: 'convertToShares',
@@ -127,7 +106,6 @@ exports.ERC4626_VAULT_ABI = [
         stateMutability: 'view',
         type: 'function',
     },
-    // Convert shares to assets
     {
         inputs: [{ internalType: 'uint256', name: 'shares', type: 'uint256' }],
         name: 'convertToAssets',
@@ -135,7 +113,6 @@ exports.ERC4626_VAULT_ABI = [
         stateMutability: 'view',
         type: 'function',
     },
-    // Total assets managed by the vault
     {
         inputs: [],
         name: 'totalAssets',
@@ -143,218 +120,44 @@ exports.ERC4626_VAULT_ABI = [
         stateMutability: 'view',
         type: 'function',
     },
-    {
-        inputs: [],
-        name: 'decimals',
-        outputs: [{ internalType: 'uint8', name: '', type: 'uint8' }],
-        stateMutability: 'view',
-        type: 'function',
-    },
 ];
-/**
- * ERC20 Token ABI - Essential methods only
- */
-exports.ERC20_ABI = [
-    {
-        inputs: [{ internalType: 'address', name: 'account', type: 'address' }],
-        name: 'balanceOf',
-        outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
-        stateMutability: 'view',
-        type: 'function',
-    },
-    {
-        inputs: [
-            { internalType: 'address', name: 'owner', type: 'address' },
-            { internalType: 'address', name: 'spender', type: 'address' },
-        ],
-        name: 'allowance',
-        outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
-        stateMutability: 'view',
-        type: 'function',
-    },
-    {
-        inputs: [
-            { internalType: 'address', name: 'spender', type: 'address' },
-            { internalType: 'uint256', name: 'amount', type: 'uint256' },
-        ],
-        name: 'approve',
-        outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
-        stateMutability: 'nonpayable',
-        type: 'function',
-    },
-    {
-        inputs: [],
-        name: 'decimals',
-        outputs: [{ internalType: 'uint8', name: '', type: 'uint8' }],
-        stateMutability: 'view',
-        type: 'function',
-    },
-    // EIP-2612 ERC20Permit extension
-    {
-        inputs: [],
-        name: 'name',
-        outputs: [{ internalType: 'string', name: '', type: 'string' }],
-        stateMutability: 'view',
-        type: 'function',
-    },
-    {
-        inputs: [],
-        name: 'version',
-        outputs: [{ internalType: 'string', name: '', type: 'string' }],
-        stateMutability: 'view',
-        type: 'function',
-    },
-    {
-        inputs: [{ internalType: 'address', name: 'owner', type: 'address' }],
-        name: 'nonces',
-        outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
-        stateMutability: 'view',
-        type: 'function',
-    },
-];
-exports.BUNDLER_ABI = [
-    {
-        inputs: [
-            {
-                internalType: 'bytes[]',
-                name: 'data',
-                type: 'bytes[]',
-            },
-        ],
-        name: 'multicall',
-        outputs: [
-            {
-                internalType: 'bytes[]',
-                name: 'results',
-                type: 'bytes[]',
-            },
-        ],
-        stateMutability: 'payable',
-        type: 'function',
-    },
-];
-exports.BUNDLER_ADDRESSES = {
-    [exports.CHAIN_IDS.ethereum]: '0x6566194141eefa99Af43Bb5Aa71460Ca2Dc90245',
-    [exports.CHAIN_IDS.base]: '0x6BFd8137e702540E7A42B74178A4a49Ba43920C4',
-    [exports.CHAIN_IDS.arbitrum]: '0x1FA4431bC113D308beE1d46B0e98Cb805FB48C13',
-    [exports.CHAIN_IDS.optimism]: '0xFBCd3C258feB131D8E038F2A3a670A7bE0507C05',
-    [exports.CHAIN_IDS.polygon]: '0x2d9C3A9E67c966C711208cc78b34fB9E9f8db589',
-};
-/**
- * Pre-configured filter presets for common use cases
- */
-exports.VAULT_FILTER_PRESETS = {
-    highYield: {
-        minNetApy: 0.08,
-        minTvl: 1000000,
-        sortBy: 'netApy',
-        sortOrder: 'desc',
-        excludeIdle: true,
-        limit: 10,
-    },
-    stable: {
-        minTvl: 5000000,
-        maxNetApy: 0.15,
-        whitelistedOnly: true,
-        sortBy: 'totalAssetsUsd',
-        sortOrder: 'desc',
-        excludeIdle: true,
-        limit: 10,
-    },
-    highTvl: {
-        minTvl: 10000000,
-        sortBy: 'totalAssetsUsd',
-        sortOrder: 'desc',
-        excludeIdle: true,
-        limit: 20,
-    },
-};
-/**
- * Get well-known token addresses for a specific chain
- */
-function getTokenAddresses(chainId) {
-    if (!(chainId in exports.WELL_KNOWN_TOKENS)) {
-        throw new Error(`Unsupported chain ID: ${chainId}. Supported chains: ${Object.keys(exports.WELL_KNOWN_TOKENS).join(', ')}`);
-    }
-    return exports.WELL_KNOWN_TOKENS[chainId];
-}
-/**
- * Get token address for a specific token symbol and chain
- */
-function getTokenAddress(symbol, chainId) {
-    const tokens = getTokenAddresses(chainId);
-    const upperSymbol = symbol.toUpperCase();
-    if (!(upperSymbol in tokens)) {
-        throw new Error(`Token ${symbol} not found on chain ${chainId}. Available tokens: ${Object.keys(tokens).join(', ')}`);
-    }
-    return tokens[upperSymbol];
-}
-/**
- * Check if a chain is supported by Morpho
- */
-function isSupportedChain(chainId) {
-    return chainId in exports.WELL_KNOWN_TOKENS;
-}
-/**
- * Get all supported chain IDs
- */
-function getSupportedChainIds() {
-    return Object.keys(exports.WELL_KNOWN_TOKENS).map(Number);
-}
-/**
- * Get chain name from chain ID
- */
-function getChainName(chainId) {
-    return exports.SUPPORTED_CHAINS[chainId] || `chain-${chainId}`;
-}
-/**
- * Utility function to validate Ethereum address
- */
-function isValidAddress(address) {
-    return /^0x[a-fA-F0-9]{40}$/.test(address);
-}
-/**
- * Utility function to parse amount with decimals
- */
-function parseAmount(amount, decimals = 18) {
-    return ethers_1.ethers.utils.parseUnits(amount, decimals).toString();
-}
-/**
- * Utility function to format amount from wei
- */
-function formatAmount(amount, decimals = 18) {
-    return ethers_1.ethers.utils.formatUnits(amount, decimals);
-}
 /**
  * Validate operation-specific requirements for Morpho vaults
  */
-async function validateOperationRequirements(operation, userBalance, vaultShares, convertedAmount) {
-    const userBalanceBN = BigInt(userBalance);
-    const vaultSharesBN = BigInt(vaultShares);
-    const convertedAmountBN = BigInt(convertedAmount);
+async function validateOperationRequirements(operation, userBalance, allowance, vaultShares, amount) {
+    const debugParams = {
+        operation,
+        userBalance: userBalance.toString(),
+        allowance: allowance.toString(),
+        vaultShares: vaultShares.toString(),
+        amount: amount.toString(),
+    };
     switch (operation) {
-        case 'deposit':
-            // Check if user has enough balance
-            if (userBalanceBN < convertedAmountBN) {
+        case schemas_1.MorphoOperation.APPROVE:
+            // No need to check anything, the user can always approve token spending even when not having enough of them
+            break;
+        case schemas_1.MorphoOperation.DEPOSIT:
+            // Check if the user has enough tokens to deposit
+            if (userBalance.lt(amount)) {
                 return {
                     valid: false,
-                    error: `Insufficient balance for deposit operation. You have ${userBalance} and need ${convertedAmount}`,
+                    error: `Insufficient balance for deposit operation. ${debugParams}`,
                 };
             }
-            break;
-        case 'redeem':
-            // For redeem, we need to check if user has enough vault shares
-            if (vaultSharesBN === 0n) {
+            // Check if the user has approved vault to take his tokens
+            if (allowance.lt(amount)) {
                 return {
                     valid: false,
-                    error: 'No vault shares available for redeem',
+                    error: `Insufficient allowance for deposit operation. Please approve vault to take your tokens first. ${debugParams}`,
                 };
             }
-            // For redeem, the amount is in shares, so check directly
-            if (vaultSharesBN < convertedAmountBN) {
+            break;
+        case schemas_1.MorphoOperation.REDEEM:
+            // Check if the user can take enough vault shares
+            if (vaultShares.lt(amount)) {
                 return {
                     valid: false,
-                    error: `Insufficient vault shares for redeem operation. You have ${vaultShares} shares and need ${convertedAmount} shares`,
+                    error: `Insufficient vault shares for redeem operation. ${debugParams}`,
                 };
             }
             break;
@@ -363,179 +166,69 @@ async function validateOperationRequirements(operation, userBalance, vaultShares
     }
     return { valid: true };
 }
-/**
- * Morpho GraphQL API Client
- */
-class MorphoVaultClient {
-    apiUrl = 'https://blue-api.morpho.org/graphql';
-    /**
-     * Fetch vault data from Morpho GraphQL API
-     */
-    async fetchVaultData(query, variables) {
-        try {
-            // console.log("fetchVaultData", query, variables);
-            const response = await fetch(this.apiUrl, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    query,
-                    variables,
-                }),
-            });
-            if (!response.ok) {
-                const body = await response.text();
-                throw new Error(`HTTP error! status: ${response.status} and body: ${body}`);
-            }
-            const data = await response.json();
-            if (data.errors) {
-                throw new Error(`GraphQL error: ${data.errors.map((e) => e.message).join(', ')}`);
-            }
-            return data.data;
-        }
-        catch (error) {
-            console.error('Failed to fetch vault data:', error);
-            throw error;
-        }
-    }
-    /**
-     * Get all vaults with comprehensive information
-     * Now uses proper server-side filtering via GraphQL VaultFilters
-     */
-    async getAllVaults(options = {}) {
-        // Build GraphQL where clause from options
-        const whereClause = this.buildVaultFilters(options);
-        const query = `
-      query GetAllVaults($first: Int, $orderBy: VaultOrderBy, $orderDirection: OrderDirection, $where: VaultFilters) {
-        vaults(first: $first, orderBy: $orderBy, orderDirection: $orderDirection, where: $where) {
-          items {
-            address
-            name
-            symbol
-            whitelisted
-            creationTimestamp
-            asset {
-              address
-              symbol
-              name
-              decimals
-            }
-            chain {
-              id
-              network
-            }
-            state {
-              apy
-              netApy
-              totalAssets
-              totalAssetsUsd
-              fee
-              rewards {
-                asset {
-                  address
-                  symbol
-                }
-                supplyApr
-                yearlySupplyTokens
-              }
-            }
-          }
-        }
-      }
-    `;
-        // Fetch more results than requested to account for client-side filtering
-        // If excludeIdle is true, we might need to filter some out, so fetch extra
-        // But never exceed 1000 (GraphQL API limit)
-        const calculateFetchLimit = (requestedLimit) => {
-            if (!requestedLimit)
-                return 100; // Default limit
-            // Always cap at 1000 to respect GraphQL API limits
-            const cappedLimit = Math.min(requestedLimit, 1000);
-            if (options.excludeIdle) {
-                // For excludeIdle filtering, fetch extra but never exceed 1000
-                return Math.max(cappedLimit, 1000);
-            }
-            // No client-side filtering, use requested limit (capped at 1000)
-            return cappedLimit;
-        };
-        const fetchLimit = calculateFetchLimit(options.limit);
-        const variables = {
-            first: fetchLimit,
-            orderBy: this.mapSortBy(options.sortBy || 'totalAssetsUsd'),
-            orderDirection: options.sortOrder === 'asc' ? 'Asc' : 'Desc',
-            where: whereClause,
-        };
-        const data = await this.fetchVaultData(query, variables);
-        const vaults = data.vaults.items.map((vault) => this.mapVaultData(vault));
-        // console.log("vaults after server-side filtering", vaults.length);
-        // Apply only remaining client-side filters not supported by GraphQL
-        const filtered = this.applyRemainingClientFilters(vaults, options);
-        // console.log("vaults after additional client filtering", filtered.length);
-        // Apply the limit AFTER client-side filtering to ensure we get the expected number of results
-        const finalResults = options.limit ? filtered.slice(0, options.limit) : filtered;
-        // Log a warning if we couldn't fetch enough results due to API limits
-        if (options.limit && options.limit > 1000 && finalResults.length < options.limit) {
-            console.warn(`Warning: Requested ${options.limit} vaults but GraphQL API limit is 1000. Got ${finalResults.length} results.`);
+async function fetchVaultData(query, variables) {
+    try {
+        const response = await fetch('https://blue-api.morpho.org/graphql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                query,
+                variables,
+            }),
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`HTTP error! status: ${response.status} and body: ${body}`);
         }
-        return finalResults;
-    }
-    /**
-     * Unified function to get vaults with flexible filtering
-     * Supports filtering by asset, chain, and all other options
-     */
-    async getVaults(options = {}) {
-        // If specific asset or chain filters are provided, enhance the options
-        const enhancedOptions = { ...options };
-        // Handle chain filtering - support both chainId and chain name/ID
-        if (options.chainId) {
-            enhancedOptions.chain = options.chainId;
+        const data = await response.json();
+        if (data.errors) {
+            throw new Error(`GraphQL error: ${data.errors.map((e) => e.message).join(', ')}`);
         }
-        return this.getAllVaults(enhancedOptions);
-    }
-    /**
-     * Get top vaults by APY
-     */
-    async getTopVaultsByNetApy(limit = 10, minTvl = 0) {
-        return this.getAllVaults({
-            sortBy: 'netApy',
-            sortOrder: 'desc',
-            limit,
-            minTvl,
-            excludeIdle: true,
-        });
-    }
-    /**
-     * Get top vaults by TVL
-     */
-    async getTopVaultsByTvl(limit = 10) {
-        return this.getAllVaults({
-            sortBy: 'totalAssetsUsd',
-            sortOrder: 'desc',
-            limit,
-            excludeIdle: true,
-        });
+        return data.data;
     }
-    /**
-     * Search vaults by name, symbol, or asset
-     */
-    async searchVaults(searchOptions) {
-        const allVaults = await this.getAllVaults({ limit: 500 }); // Reduced to avoid GraphQL limit issues
-        if (!searchOptions.query) {
-            return allVaults.slice(0, searchOptions.limit || 50);
-        }
-        const query = searchOptions.query.toLowerCase();
-        const filtered = allVaults.filter((vault) => vault.name.toLowerCase().includes(query) ||
-            vault.symbol.toLowerCase().includes(query) ||
-            vault.asset.symbol.toLowerCase().includes(query) ||
-            vault.asset.name.toLowerCase().includes(query));
-        return filtered.slice(0, searchOptions.limit || 50);
+    catch (error) {
+        console.error('Failed to fetch vault data:', error);
+        throw error;
     }
-    /**
-     * Get vault details by address
-     */
-    async getVaultByAddress(address, chainId) {
-        const query = `
+}
+function mapVaultData(vault) {
+    return {
+        address: vault.address,
+        name: vault.name,
+        symbol: vault.symbol,
+        asset: {
+            address: vault.asset.address,
+            symbol: vault.asset.symbol,
+            name: vault.asset.name,
+            decimals: vault.asset.decimals,
+        },
+        chain: {
+            id: vault.chain.id,
+            network: vault.chain.network,
+        },
+        metrics: {
+            apy: vault.state.apy || 0,
+            netApy: vault.state.netApy || 0,
+            totalAssets: vault.state.totalAssets || '0',
+            totalAssetsUsd: vault.state.totalAssetsUsd || 0,
+            fee: vault.state.fee || 0,
+            rewards: vault.state.rewards?.map((reward) => ({
+                asset: reward.asset.address,
+                supplyApr: reward.supplyApr,
+                yearlySupplyTokens: reward.yearlySupplyTokens,
+            })) || [],
+        },
+        whitelisted: vault.whitelisted,
+        creationTimestamp: vault.creationTimestamp,
+    };
+}
+/**
+ * Get Morpho vault details using their graphql api
+ */
+async function getMorphoVaultByAddress(address, chainId) {
+    const query = `
       query GetVaultByAddress($address: String!, $chainId: Int!) {
         vaultByAddress(address: $address, chainId: $chainId) {
           address
@@ -571,541 +264,28 @@ class MorphoVaultClient {
         }
       }
     `;
-        const variables = { address, chainId };
-        try {
-            const data = await this.fetchVaultData(query, variables);
-            return data.vaultByAddress ? this.mapVaultData(data.vaultByAddress) : null;
-        }
-        catch (error) {
-            console.error(`Failed to fetch vault ${address}:`, error);
-            return null;
-        }
-    }
-    /**
-     * Get best vaults for a specific asset
-     */
-    async getBestVaultsForAsset(assetSymbol, limit = 5) {
-        const vaults = await this.getAllVaults({
-            sortBy: 'netApy',
-            sortOrder: 'desc',
-            limit: 100,
-            minTvl: 10000, // Minimum $10k TVL
-            excludeIdle: true,
-        });
-        return vaults
-            .filter((vault) => vault.asset.symbol.toLowerCase() === assetSymbol.toLowerCase())
-            .slice(0, limit);
-    }
-    /**
-     * Map vault data from GraphQL response
-     */
-    mapVaultData(vault) {
-        return {
-            address: vault.address,
-            name: vault.name,
-            symbol: vault.symbol,
-            asset: {
-                address: vault.asset.address,
-                symbol: vault.asset.symbol,
-                name: vault.asset.name,
-                decimals: vault.asset.decimals,
-            },
-            chain: {
-                id: vault.chain.id,
-                network: vault.chain.network,
-            },
-            metrics: {
-                apy: vault.state.apy || 0,
-                netApy: vault.state.netApy || 0,
-                totalAssets: vault.state.totalAssets || '0',
-                totalAssetsUsd: vault.state.totalAssetsUsd || 0,
-                fee: vault.state.fee || 0,
-                rewards: vault.state.rewards?.map((reward) => ({
-                    asset: reward.asset.address,
-                    supplyApr: reward.supplyApr,
-                    yearlySupplyTokens: reward.yearlySupplyTokens,
-                })) || [],
-            },
-            whitelisted: vault.whitelisted,
-            creationTimestamp: vault.creationTimestamp,
-            isIdle: vault.state.totalAssetsUsd < 100, // Consider vaults with < $100 TVL as idle
-        };
-    }
-    /**
-     * Build GraphQL VaultFilters from filter options
-     * Uses proper server-side filtering for better performance
-     */
-    buildVaultFilters(options) {
-        const filters = {};
-        // Chain filtering - server-side supported
-        if (options.chain !== undefined || options.chainId !== undefined) {
-            let targetChainId;
-            if (options.chainId !== undefined) {
-                targetChainId = options.chainId;
-            }
-            else if (options.chain !== undefined) {
-                targetChainId =
-                    typeof options.chain === 'string'
-                        ? exports.CHAIN_IDS[options.chain]
-                        : options.chain;
-            }
-            if (targetChainId !== undefined) {
-                filters.chainId_in = [targetChainId];
-            }
-        }
-        // Asset filtering - server-side supported
-        if (options.assetAddress) {
-            filters.assetAddress_in = [options.assetAddress.toLowerCase()];
-        }
-        if (options.assetSymbol) {
-            filters.assetSymbol_in = [options.assetSymbol.toUpperCase()];
-        }
-        // Whitelisted status filtering - server-side supported
-        if (options.whitelistedOnly) {
-            filters.whitelisted = true;
-        }
-        // Net APY filtering - server-side supported
-        if (options.minNetApy !== undefined) {
-            filters.netApy_gte = options.minNetApy;
-        }
-        if (options.maxNetApy !== undefined) {
-            filters.netApy_lte = options.maxNetApy;
-        }
-        // TVL filtering - server-side supported
-        if (options.minTvl !== undefined) {
-            filters.totalAssetsUsd_gte = options.minTvl;
-        }
-        if (options.maxTvl !== undefined) {
-            filters.totalAssetsUsd_lte = options.maxTvl;
-        }
-        // Total assets filtering - server-side supported
-        if (options.minTotalAssets !== undefined) {
-            filters.totalAssets_gte = options.minTotalAssets.toString();
-        }
-        if (options.maxTotalAssets !== undefined) {
-            filters.totalAssets_lte = options.maxTotalAssets.toString();
-        }
-        // Return null if no filters to avoid empty where clause
-        return Object.keys(filters).length > 0 ? filters : null;
-    }
-    /**
-     * Apply remaining client-side filters not supported by GraphQL
-     * Only handles computed properties like isIdle
-     */
-    applyRemainingClientFilters(vaults, options) {
-        let filtered = vaults;
-        // Idle vault filtering (computed client-side)
-        if (options.excludeIdle) {
-            filtered = filtered.filter((vault) => !vault.isIdle);
-        }
-        return filtered;
-    }
-    /**
-     * Map sortBy option to GraphQL enum
-     */
-    mapSortBy(sortBy) {
-        switch (sortBy) {
-            case 'netApy':
-                return 'NetApy';
-            case 'totalAssets':
-                return 'TotalAssets';
-            case 'totalAssetsUsd':
-                return 'TotalAssetsUsd';
-            case 'creationTimestamp':
-                return 'CreationTimestamp';
-            default:
-                return 'TotalAssetsUsd';
-        }
-    }
-}
-exports.MorphoVaultClient = MorphoVaultClient;
-/**
- * Create a singleton instance of MorphoVaultClient
- */
-exports.morphoVaultClient = new MorphoVaultClient();
-/**
- * Helper function to get best vaults for a specific asset
- */
-async function getBestVaultsForAsset(assetSymbol, limit = 5) {
-    return exports.morphoVaultClient.getBestVaultsForAsset(assetSymbol, limit);
-}
-/**
- * Helper function to get top vaults by APY
- */
-async function getTopVaultsByNetApy(limit = 10, minTvl = 10000) {
-    return exports.morphoVaultClient.getTopVaultsByNetApy(limit, minTvl);
-}
-/**
- * Helper function to get top vaults by TVL
- */
-async function getTopVaultsByTvl(limit = 10) {
-    return exports.morphoVaultClient.getTopVaultsByTvl(limit);
-}
-/**
- * Helper function to search vaults
- */
-async function searchVaults(query, limit = 20) {
-    return exports.morphoVaultClient.searchVaults({ query, limit });
-}
-/**
- * 🚀 **Quick Vault Search with Presets**
- *
- * Get vaults using pre-configured filter presets for common use cases.
- *
- * @param preset - Pre-configured filter preset
- * @param overrides - Additional options to override preset defaults
- * @returns Promise resolving to array of vault information
- *
- * @example
- * ```typescript
- * // Find high-yield vaults
- * const highYieldVaults = await getVaultsByPreset("highYield");
- *
- * // Find high-yield USDC vaults specifically
- * const usdcHighYield = await getVaultsByPreset("highYield", {
- *   assetSymbol: "USDC"
- * });
- *
- * // Find stable vaults on Base chain
- * const stableBaseVaults = await getVaultsByPreset("stable", {
- *   chainId: 8453
- * });
- * ```
- */
-async function getVaultsByPreset(preset, overrides = {}) {
-    const presetOptions = exports.VAULT_FILTER_PRESETS[preset];
-    const mergedOptions = { ...presetOptions, ...overrides };
-    return getVaults(mergedOptions);
-}
-/**
- * 🔍 **Primary Vault Discovery Function**
- *
- * Get Morpho vaults with comprehensive filtering and sorting options.
- * Uses server-side GraphQL queries for optimal performance.
- *
- * @param options - Vault filtering and sorting options
- * @returns Promise resolving to array of vault information
- *
- * @example
- * ```typescript
- * // Find best USDC vaults across all chains
- * const topVaults = await getVaults({
- *   assetSymbol: "USDC",
- *   minNetApy: 0.05,
- *   minTvl: 1000000,
- *   sortBy: "netApy",
- *   sortOrder: "desc",
- *   limit: 5
- * });
- *
- * // Filter by specific chain
- * const baseVaults = await getVaults({
- *   chainId: 8453, // Base
- *   excludeIdle: true,
- *   sortBy: "totalAssetsUsd"
- * });
- *
- * // Search with multiple criteria
- * const premiumVaults = await getVaults({
- *   minNetApy: 10.0,
- *   minTvl: 5000000,
- *   whitelistedOnly: true,
- *   sortBy: "netApy",
- *   limit: 3
- * });
- * ```
- */
-async function getVaults(options = {}) {
-    return exports.morphoVaultClient.getVaults(options);
-}
-/**
- * Get supported chains with active vaults
- */
-async function getSupportedChainsWithVaults() {
-    const supportedChains = getSupportedChainIds();
-    const results = [];
-    for (const chainId of supportedChains) {
-        try {
-            const vaults = await exports.morphoVaultClient.getVaults({
-                chainId,
-                limit: 1,
-                excludeIdle: true,
-            });
-            if (vaults.length > 0) {
-                // Get total count - reduced limit to avoid GraphQL errors
-                const allVaults = await exports.morphoVaultClient.getVaults({
-                    chainId,
-                    limit: 500, // Reduced to avoid GraphQL limit issues
-                    excludeIdle: true,
-                });
-                results.push({
-                    chainId,
-                    name: getChainName(chainId),
-                    vaultCount: allVaults.length,
-                });
-            }
-        }
-        catch (error) {
-            console.warn(`Could not fetch vaults for chain ${chainId}:`, error instanceof Error ? error.message : String(error));
-        }
-    }
-    return results.sort((a, b) => b.vaultCount - a.vaultCount);
-}
-/**
- * Get vault discovery summary for a chain
- */
-async function getVaultDiscoverySummary(chainId) {
-    try {
-        const [topByTvl, topByNetApy, assetBreakdown] = await Promise.all([
-            exports.morphoVaultClient.getVaults({
-                chainId,
-                sortBy: 'totalAssetsUsd',
-                sortOrder: 'desc',
-                limit: 5,
-                excludeIdle: true,
-            }),
-            exports.morphoVaultClient.getVaults({
-                chainId,
-                sortBy: 'netApy',
-                sortOrder: 'desc',
-                limit: 5,
-                excludeIdle: true,
-            }),
-            exports.morphoVaultClient.getVaults({
-                chainId,
-                limit: 500, // Reduced to avoid GraphQL limit issues
-                excludeIdle: true,
-            }),
-        ]);
-        // Group by asset
-        const assetGroups = assetBreakdown.reduce((acc, vault) => {
-            const symbol = vault.asset.symbol;
-            if (!acc[symbol]) {
-                acc[symbol] = { count: 0, totalTvl: 0, maxNetApy: 0 };
-            }
-            acc[symbol].count++;
-            acc[symbol].totalTvl += vault.metrics.totalAssetsUsd;
-            acc[symbol].maxNetApy = Math.max(acc[symbol].maxNetApy, vault.metrics.netApy);
-            return acc;
-        }, {});
-        return {
-            chainId,
-            chainName: getChainName(chainId),
-            totalVaults: assetBreakdown.length,
-            totalTvl: assetBreakdown.reduce((sum, v) => sum + v.metrics.totalAssetsUsd, 0),
-            topVaultsByTvl: topByTvl,
-            topVaultsByNetApy: topByNetApy,
-            assetBreakdown: Object.entries(assetGroups)
-                .map(([symbol, data]) => ({ symbol, ...data }))
-                .sort((a, b) => b.totalTvl - a.totalTvl),
-        };
-    }
-    catch (error) {
-        console.error(`Error getting vault summary for chain ${chainId}:`, error);
-        throw error;
-    }
-}
-const N = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
-const N2 = N >> 1n;
-function add0x(h) {
-    return h.startsWith("0x") ? h : ("0x" + h);
-}
-function to32Bytes(h) {
-    const bytes = ethers_1.ethers.utils.arrayify(add0x(h));
-    if (bytes.length === 32) {
-        return ethers_1.ethers.utils.hexlify(bytes);
-    }
-    // Lit sometimes prefixes a single "tag" byte. If so, drop it.
-    if (bytes.length === 33 &&
-        (bytes[0] === 0x00 || bytes[0] === 0x02 || bytes[0] === 0x03)) {
-        return ethers_1.ethers.utils.hexlify(bytes.slice(1));
-    }
-    // Left-pad if < 32
-    if (bytes.length < 32) {
-        const out = new Uint8Array(32);
-        out.set(bytes, 32 - bytes.length);
-        return ethers_1.ethers.utils.hexlify(out);
-    }
-    throw new Error(`Invalid 32-byte value length=${bytes.length} for ${h}`);
-}
-function normalizeLitSig(parsed) {
-    const r = to32Bytes(parsed.r);
-    let s = to32Bytes(parsed.s);
-    let v = parsed.v;
-    // map 0/1 -> 27/28 (ethers v5 wants that for many contracts)
-    if (v === 0 || v === 1)
-        v += 27;
-    // low-s normalization (OpenZeppelin ECDSA-compatible)
-    let sBN = BigInt(s);
-    if (sBN > N2) {
-        sBN = N - sBN;
-        s = "0x" + sBN.toString(16).padStart(64, "0");
-        v = v === 27 ? 28 : 27; // flip parity
-    }
-    return { r, s, v };
-}
-async function buildDepositTxData({ bundlerStepsLimit, skipRevertOnPermit, amount, pkpAddress, pkpPublicKey, provider, tokenAddress, vaultAddress, }) {
-    const { chainId } = await provider.getNetwork();
-    const bundlerAddress = exports.BUNDLER_ADDRESSES[chainId];
-    if (!bundlerAddress) {
-        throw new Error(`No bundler address found for chain ${chainId}`);
-    }
-    console.log('[@lit-protocol/vincent-ability-morpho/buildDepositTxData] Building EIP-2612 permit data in runOnce');
-    const permitDataResponse = await Lit.Actions.runOnce({ waitForResponse: true, name: 'permitData' }, async () => {
-        const tokenContract = new ethers_1.ethers.Contract(tokenAddress, exports.ERC20_ABI, provider);
-        const [name, nonce, version] = await Promise.all([
-            tokenContract.name(),
-            tokenContract.nonces(pkpAddress),
-            tokenContract.version(),
-        ]);
-        const deadline = Math.floor(Date.now() / 1000) + 60 * 30; // 30 min
-        // EIP-2612 permit signature
-        const domain = {
-            name,
-            version,
-            chainId,
-            verifyingContract: tokenAddress,
-        };
-        const message = {
-            owner: pkpAddress,
-            spender: bundlerAddress,
-            value: amount,
-            nonce: nonce.toString(),
-            deadline,
-        };
-        console.log('[@lit-protocol/vincent-ability-morpho/buildDepositTxData] Built EIP-2612 permit properties', {
-            domain,
-            message,
-        });
-        return JSON.stringify({
-            deadline,
-            domain,
-            message,
-        });
-    });
-    if (!permitDataResponse ||
-        permitDataResponse[0] !== '{' ||
-        permitDataResponse.includes('error')) {
-        throw new Error(`permitData runOnce failed: ${permitDataResponse}`);
-    }
-    const { deadline, domain, message } = JSON.parse(permitDataResponse);
-    const types = {
-        Permit: [
-            { name: 'owner', type: 'address' },
-            { name: 'spender', type: 'address' },
-            { name: 'value', type: 'uint256' },
-            { name: 'nonce', type: 'uint256' },
-            { name: 'deadline', type: 'uint256' },
-        ],
-    };
-    const digest = ethers_1.ethers.utils._TypedDataEncoder.hash(domain, types, message);
-    const toSign = ethers_1.ethers.utils.arrayify(digest);
-    console.log('[@lit-protocol/vincent-ability-morpho/buildDepositTxData] Built EIP-2612 permit msg', {
-        toSign,
-    });
-    const publicKey = pkpPublicKey.replace(/^0x/, '');
-    const permitSignatureString = await Lit.Actions.signAndCombineEcdsa({
-        publicKey,
-        toSign,
-        sigName: 'tokenPermit',
-    });
-    console.log('[@lit-protocol/vincent-ability-morpho/buildDepositTxData] Permit signature', {
-        permitSignatureString,
-    });
-    const permitSignatureParsed = JSON.parse(permitSignatureString);
-    const { r, s, v } = normalizeLitSig(permitSignatureParsed);
-    console.log('[@lit-protocol/vincent-ability-morpho/buildDepositTxData] Parsed permit signature', {
-        r,
-        s,
-        v,
-    });
-    // Signature sanity check
-    const recovered = ethers_1.ethers.utils.recoverAddress(digest, { r, s, v });
-    if (recovered.toLowerCase() !== pkpAddress.toLowerCase()) {
-        throw new Error(`Permit sig does not recover to owner: ${recovered} != ${pkpAddress}`);
-    }
-    // Permit sanity check
-    try {
-        const tokenContract = new ethers_1.ethers.Contract(tokenAddress, [
-            'function nonces(address) view returns (uint256)',
-            'function permit(address owner,address spender,uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s)',
-        ], provider);
-        await tokenContract.callStatic.permit(pkpAddress, bundlerAddress, amount, deadline, v, r, s);
-    }
-    catch (error) {
-        console.error(`[@lit-protocol/vincent-ability-morpho/buildDepositTxData] Permit sanity check failed:`, error);
-        throw new Error(`Permit sanity check failed: ${error}`);
-    }
-    console.log('[@lit-protocol/vincent-ability-morpho/buildDepositTxData] Building bundler calls');
-    const calls = [
-        // @ts-expect-error permit expects a full Signature but having v ∈ {27, 28} which is not what ethers gives us
-        bundler_sdk_ethers_1.BundlerAction.permit(tokenAddress, amount, deadline, { r, s, v }, skipRevertOnPermit),
-        bundler_sdk_ethers_1.BundlerAction.erc20TransferFrom(tokenAddress, amount),
-        // Deposit into the ERC4626 vault (minShares = 0; set if you want protection)
-        bundler_sdk_ethers_1.BundlerAction.erc4626Deposit(vaultAddress, amount, 0, pkpAddress),
-    ].slice(0, bundlerStepsLimit);
-    const iface = new ethers_1.ethers.utils.Interface(exports.BUNDLER_ABI);
-    const data = iface.encodeFunctionData('multicall', [calls]);
-    console.log('[@lit-protocol/vincent-ability-morpho/buildDepositTxData] Built bundler encoded tx data', {
-        data,
-    });
-    return {
-        data,
-        abi: exports.BUNDLER_ABI,
-        functionName: 'multicall',
-        args: [calls],
-        to: bundlerAddress,
-        value: '0x0',
-    };
-}
-async function buildRedeemTxData({ bundlerStepsLimit, amount, pkpAddress, provider, vaultAddress, }) {
-    const { chainId } = await provider.getNetwork();
-    const bundlerAddress = exports.BUNDLER_ADDRESSES[chainId];
-    if (!bundlerAddress) {
-        throw new Error(`No bundler address found for chain ${chainId}`);
-    }
-    console.log('[@lit-protocol/vincent-ability-morpho/buildDepositTxData] Building bundler calls');
-    const calls = [
-        bundler_sdk_ethers_1.BundlerAction.erc4626Redeem(vaultAddress, amount, amount, pkpAddress, pkpAddress),
-    ].slice(0, bundlerStepsLimit);
-    const iface = new ethers_1.ethers.utils.Interface(exports.BUNDLER_ABI);
-    const data = iface.encodeFunctionData('multicall', [calls]);
-    console.log('[@lit-protocol/vincent-ability-morpho/buildDepositTxData] Built bundler encoded tx data', {
-        data,
-    });
-    return {
-        data,
-        abi: exports.BUNDLER_ABI,
-        functionName: 'multicall',
-        args: [calls],
-        to: bundlerAddress,
-        value: '0x0',
-    };
+    const variables = { address, chainId };
+    const data = await fetchVaultData(query, variables);
+    return data.vaultByAddress ? mapVaultData(data.vaultByAddress) : null;
 }
 /**
  * Generic function to execute any Morpho operation, with optional gas sponsorship
  */
-async function executeChainOperation({ abi, provider, pkpEthAddress, pkpPublicKey, contractAddress, functionName, args, chainId, alchemyGasSponsor, alchemyGasSponsorApiKey, alchemyGasSponsorPolicyId, }) {
+async function executeMorphoOperation({ abi, args, alchemyGasSponsor = false, alchemyGasSponsorApiKey, alchemyGasSponsorPolicyId, contractAddress, chainId, functionName, provider, pkpInfo, }) {
     console.log(`[@lit-protocol/vincent-ability-morpho/executeMorphoOperation] Starting ${functionName} operation`, { sponsored: !!alchemyGasSponsor });
     // Use gas sponsorship if enabled and all required parameters are provided
     if (alchemyGasSponsor && alchemyGasSponsorApiKey && alchemyGasSponsorPolicyId) {
         console.log(`[@lit-protocol/vincent-ability-morpho/executeMorphoOperation] Using EIP-7702 gas sponsorship`, { contractAddress, functionName, args, policyId: alchemyGasSponsorPolicyId });
-        try {
-            return await vincent_scaffold_sdk_1.laUtils.transaction.handler.sponsoredGasContractCall({
-                abi,
-                pkpPublicKey,
-                contractAddress,
-                functionName,
-                args,
-                chainId,
-                eip7702AlchemyApiKey: alchemyGasSponsorApiKey,
-                eip7702AlchemyPolicyId: alchemyGasSponsorPolicyId,
-            });
-        }
-        catch (error) {
-            console.error(`[@lit-protocol/vincent-ability-morpho/executeMorphoOperation] EIP-7702 operation failed:`, error);
-            throw error;
-        }
+        return await vincent_scaffold_sdk_1.laUtils.transaction.handler.sponsoredGasContractCall({
+            abi,
+            args,
+            contractAddress,
+            chainId,
+            functionName,
+            eip7702AlchemyApiKey: alchemyGasSponsorApiKey,
+            eip7702AlchemyPolicyId: alchemyGasSponsorPolicyId,
+            pkpPublicKey: pkpInfo.publicKey,
+        });
     }
     else {
         // Use regular transaction without gas sponsorship
@@ -1113,22 +293,16 @@ async function executeChainOperation({ abi, provider, pkpEthAddress, pkpPublicKe
         if (!provider) {
             throw new Error('Provider is required for non-sponsored transactions');
         }
-        try {
-            return await vincent_scaffold_sdk_1.laUtils.transaction.handler.contractCall({
-                abi,
-                provider,
-                pkpPublicKey,
-                contractAddress,
-                functionName,
-                args,
-                chainId,
-                callerAddress: pkpEthAddress,
-            });
-        }
-        catch (error) {
-            console.error(`[@lit-protocol/vincent-ability-morpho/executeMorphoOperation] Regular transaction failed:`, error);
-            throw error;
-        }
+        return await vincent_scaffold_sdk_1.laUtils.transaction.handler.contractCall({
+            abi,
+            args,
+            chainId,
+            contractAddress,
+            functionName,
+            provider,
+            callerAddress: pkpInfo.ethAddress,
+            pkpPublicKey: pkpInfo.publicKey,
+        });
     }
 }
 //# sourceMappingURL=index.js.map