@mento-protocol/mento-sdk 3.1.0-beta.4 → 3.1.0-beta.5

package/dist/core/types/liquidity.d.ts

@@ -114,6 +114,20 @@ export interface ZapOutTransaction {
     approval: TokenApproval | null;
     zapOut: ZapOutDetails;
 }
+export interface PreparedZapIn {
+    routesA: RouterRoute[];
+    routesB: RouterRoute[];
+    quote: ZapInQuote;
+    approval?: TokenApproval | null;
+    details: ZapInDetails;
+}
+export interface PreparedZapOut {
+    routesA: RouterRoute[];
+    routesB: RouterRoute[];
+    quote: ZapOutQuote;
+    approval?: TokenApproval | null;
+    details: ZapOutDetails;
+}
 /** Input for adding liquidity (without approval handling) */
 export interface AddLiquidityInput {
     poolAddress: string;
@@ -140,6 +154,9 @@ export interface ZapInInput {
     recipient: string;
     options: LiquidityOptions;
 }
+export interface PrepareZapInInput extends ZapInInput {
+    owner?: string;
+}
 /** Input for zap out (without approval handling) */
 export interface ZapOutInput {
     poolAddress: string;
@@ -148,4 +165,7 @@ export interface ZapOutInput {
     recipient: string;
     options: LiquidityOptions;
 }
+export interface PrepareZapOutInput extends ZapOutInput {
+    owner?: string;
+}
 //# sourceMappingURL=liquidity.d.ts.map

package/dist/esm/index.js

@@ -10,6 +10,14 @@ import { SwapService } from './services/swap';
 import { TradingService } from './services/trading';
 import { LiquidityService } from './services/liquidity';
 import { BorrowService } from './services/borrow';
+const DEFAULT_HTTP_BATCH_OPTIONS = {
+    batchSize: 1000,
+    wait: 8,
+};
+const DEFAULT_MULTICALL_BATCH_OPTIONS = {
+    batchSize: 1024,
+    wait: 8,
+};
 /**
  * @class Mento
  * @description The main class for the Mento SDK. Initializes a viem PublicClient internally
@@ -70,14 +78,7 @@ export class Mento {
         this.liquidity = liquidity;
         this.borrow = borrow;
     }
-    /**
-     * Create a new Mento SDK instance
-     * @param chainId - The chain ID (e.g., ChainId.CELO, ChainId.CELO_SEPOLIA)
-     * @param rpcUrlOrClient - Optional RPC URL string or an existing viem PublicClient.
-     *                         If not provided, uses the default RPC URL for the chain.
-     * @returns A new Mento instance
-     */
-    static async create(chainId, rpcUrlOrClient) {
+    static async create(chainId, rpcUrlOrClient, options) {
         // Validate chainId is supported
         const supportedChainIds = Object.values(ChainId).filter((v) => typeof v === 'number');
         if (!supportedChainIds.includes(chainId)) {
@@ -89,8 +90,23 @@ export class Mento {
             publicClient = rpcUrlOrClient;
         }
         else {
-            const transport = http(rpcUrlOrClient || getDefaultRpcUrl(chainId));
+            const transport = http(rpcUrlOrClient || getDefaultRpcUrl(chainId), {
+                batch: options?.httpBatch === false
+                    ? false
+                    : {
+                        ...DEFAULT_HTTP_BATCH_OPTIONS,
+                        ...(options?.httpBatch ?? {}),
+                    },
+            });
             publicClient = createPublicClient({
+                batch: {
+                    multicall: options?.multicallBatch === false
+                        ? false
+                        : {
+                            ...DEFAULT_MULTICALL_BATCH_OPTIONS,
+                            ...(options?.multicallBatch ?? {}),
+                        },
+                },
                 chain: getChainConfig(chainId),
                 transport,
             });

package/dist/esm/services/borrow/internal/borrowReadService.js

@@ -1,27 +1,31 @@
 import { BORROWER_OPERATIONS_ABI, HINT_HELPERS_ABI, MULTI_TROVE_GETTER_ABI, PRICE_FEED_ABI, TROVE_MANAGER_ABI, TROVE_NFT_ABI, } from '../../../core/abis';
 import { COLL_INDEX } from '../../../core/constants';
+import { multicall } from '../../../utils/multicall';
 import { parseBorrowPosition } from './borrowPositionParser';
 import { formatTroveId, MAX_SAFE_INTEGER_BIGINT, parseTroveId, requireAddress, requireNonNegativeBigInt, } from './borrowValidation';
+const TROVE_ID_BATCH_SIZE = 64;
+const TROVE_OWNER_BATCH_SIZE = 64;
+const TROVE_DETAIL_BATCH_SIZE = 64;
 export class BorrowReadService {
     constructor(publicClient) {
         this.publicClient = publicClient;
     }
     async getTroveData(ctx, troveId) {
         const parsedTroveId = parseTroveId(troveId);
-        const [latestData, trovesData] = await Promise.all([
-            this.publicClient.readContract({
+        const [latestData, trovesData] = await this.readContractsInChunks([
+            {
                 address: ctx.addresses.troveManager,
                 abi: TROVE_MANAGER_ABI,
                 functionName: 'getLatestTroveData',
                 args: [parsedTroveId],
-            }),
-            this.publicClient.readContract({
+            },
+            {
                 address: ctx.addresses.troveManager,
                 abi: TROVE_MANAGER_ABI,
                 functionName: 'Troves',
                 args: [parsedTroveId],
-            }),
-        ]);
+            },
+        ], 2);
         return parseBorrowPosition(formatTroveId(parsedTroveId), latestData, trovesData);
     }
     async getUserTroves(ctx, owner) {
@@ -32,41 +36,49 @@ export class BorrowReadService {
             functionName: 'getTroveIdsCount',
             args: [],
         }));
-        const matchedTroveIds = [];
+        if (troveCount === 0n) {
+            return [];
+        }
+        const troveIdContracts = [];
         for (let i = 0n; i < troveCount; i++) {
-            const troveId = (await this.publicClient.readContract({
+            troveIdContracts.push({
                 address: ctx.addresses.troveManager,
                 abi: TROVE_MANAGER_ABI,
                 functionName: 'getTroveFromTroveIdsArray',
                 args: [i],
-            }));
-            const troveOwner = (await this.publicClient.readContract({
-                address: ctx.addresses.troveNFT,
-                abi: TROVE_NFT_ABI,
-                functionName: 'ownerOf',
-                args: [troveId],
-            }));
-            if (troveOwner.toLowerCase() === ownerAddress.toLowerCase()) {
-                matchedTroveIds.push(troveId);
-            }
+            });
         }
-        return Promise.all(matchedTroveIds.map(async (troveId) => {
-            const [latestData, trovesData] = await Promise.all([
-                this.publicClient.readContract({
-                    address: ctx.addresses.troveManager,
-                    abi: TROVE_MANAGER_ABI,
-                    functionName: 'getLatestTroveData',
-                    args: [troveId],
-                }),
-                this.publicClient.readContract({
-                    address: ctx.addresses.troveManager,
-                    abi: TROVE_MANAGER_ABI,
-                    functionName: 'Troves',
-                    args: [troveId],
-                }),
-            ]);
-            return parseBorrowPosition(formatTroveId(troveId), latestData, trovesData);
+        const troveIds = (await this.readContractsInChunks(troveIdContracts, TROVE_ID_BATCH_SIZE)).map((troveId) => troveId);
+        const ownerContracts = troveIds.map((troveId) => ({
+            address: ctx.addresses.troveNFT,
+            abi: TROVE_NFT_ABI,
+            functionName: 'ownerOf',
+            args: [troveId],
         }));
+        const troveOwners = await this.readContractsInChunks(ownerContracts, TROVE_OWNER_BATCH_SIZE);
+        const matchedTroveIds = troveIds.filter((troveId, index) => troveOwners[index].toLowerCase() === ownerAddress.toLowerCase());
+        if (matchedTroveIds.length === 0) {
+            return [];
+        }
+        const troveDetailContracts = matchedTroveIds.flatMap((troveId) => ([
+            {
+                address: ctx.addresses.troveManager,
+                abi: TROVE_MANAGER_ABI,
+                functionName: 'getLatestTroveData',
+                args: [troveId],
+            },
+            {
+                address: ctx.addresses.troveManager,
+                abi: TROVE_MANAGER_ABI,
+                functionName: 'Troves',
+                args: [troveId],
+            },
+        ]));
+        const detailResults = await this.readContractsInChunks(troveDetailContracts, TROVE_DETAIL_BATCH_SIZE * 2);
+        return matchedTroveIds.map((troveId, index) => {
+            const offset = index * 2;
+            return parseBorrowPosition(formatTroveId(troveId), detailResults[offset], detailResults[offset + 1]);
+        });
     }
     async getCollateralPrice(ctx) {
         return (await this.publicClient.readContract({
@@ -210,4 +222,21 @@ export class BorrowReadService {
         }
         return Number(ownerTroveCount);
     }
+    async readContractsInChunks(contracts, chunkSize) {
+        if (contracts.length === 0) {
+            return [];
+        }
+        const results = [];
+        for (let index = 0; index < contracts.length; index += chunkSize) {
+            const chunk = contracts.slice(index, index + chunkSize);
+            const chunkResults = await multicall(this.publicClient, chunk, { allowFailure: false });
+            for (const result of chunkResults) {
+                if (result.status === 'failure') {
+                    throw result.error;
+                }
+                results.push(result.result);
+            }
+        }
+        return results;
+    }
 }

package/dist/esm/services/borrow/internal/borrowRegistryReader.js

@@ -1,9 +1,26 @@
 import { ADDRESSES_REGISTRY_ABI, BORROWER_OPERATIONS_ABI, SYSTEM_PARAMS_ABI, } from '../../../core/abis';
+import { multicall } from '../../../utils/multicall';
 import { validateAddress } from '../../../utils/validation';
 function readNoArgsContract(publicClient, address, abi, functionName) {
     const readContract = publicClient.readContract;
     return readContract({ address, abi, functionName, args: [] });
 }
+async function readNoArgsContracts(publicClient, contracts) {
+    if (contracts.length === 0) {
+        return [];
+    }
+    const results = await multicall(publicClient, contracts.map((contract) => ({
+        ...contract,
+        abi: contract.abi,
+        args: [],
+    })), { allowFailure: false });
+    return results.map((result) => {
+        if (result.status === 'failure') {
+            throw result.error;
+        }
+        return result.result;
+    });
+}
 function requireAddress(value, fieldName) {
     if (typeof value !== 'string') {
         throw new Error(`${fieldName} must be a string address`);
@@ -23,26 +40,26 @@ function requireBigInt(value, fieldName) {
 export async function resolveAddressesFromRegistry(publicClient, registryAddress) {
     validateAddress(registryAddress, 'registryAddress');
     const registry = registryAddress;
-    const [borrowerOperationsRaw, troveManagerRaw, sortedTrovesRaw, activePoolRaw, defaultPoolRaw, hintHelpersRaw, multiTroveGetterRaw, collTokenRaw, debtTokenRaw, troveNFTRaw, metadataNFTRaw, stabilityPoolRaw, priceFeedRaw, collSurplusPoolRaw, interestRouterRaw, collateralRegistryRaw, gasTokenRaw, gasPoolAddressRaw, liquidityStrategyRaw,] = await Promise.all([
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'borrowerOperations'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'troveManager'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'sortedTroves'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'activePool'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'defaultPool'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'hintHelpers'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'multiTroveGetter'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'collToken'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'boldToken'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'troveNFT'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'metadataNFT'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'stabilityPool'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'priceFeed'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'collSurplusPool'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'interestRouter'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'collateralRegistry'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'gasToken'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'gasPoolAddress'),
-        readNoArgsContract(publicClient, registry, ADDRESSES_REGISTRY_ABI, 'liquidityStrategy'),
+    const [borrowerOperationsRaw, troveManagerRaw, sortedTrovesRaw, activePoolRaw, defaultPoolRaw, hintHelpersRaw, multiTroveGetterRaw, collTokenRaw, debtTokenRaw, troveNFTRaw, metadataNFTRaw, stabilityPoolRaw, priceFeedRaw, collSurplusPoolRaw, interestRouterRaw, collateralRegistryRaw, gasTokenRaw, gasPoolAddressRaw, liquidityStrategyRaw,] = await readNoArgsContracts(publicClient, [
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'borrowerOperations' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'troveManager' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'sortedTroves' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'activePool' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'defaultPool' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'hintHelpers' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'multiTroveGetter' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'collToken' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'boldToken' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'troveNFT' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'metadataNFT' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'stabilityPool' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'priceFeed' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'collSurplusPool' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'interestRouter' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'collateralRegistry' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'gasToken' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'gasPoolAddress' },
+        { address: registry, abi: ADDRESSES_REGISTRY_ABI, functionName: 'liquidityStrategy' },
     ]);
     return {
         borrowerOperations: requireAddress(borrowerOperationsRaw, 'borrowerOperations'),
@@ -70,14 +87,14 @@ export async function readSystemParams(publicClient, borrowerOperations) {
     validateAddress(borrowerOperations, 'borrowerOperations');
     const systemParamsAddressRaw = await readNoArgsContract(publicClient, borrowerOperations, BORROWER_OPERATIONS_ABI, 'systemParams');
     const systemParamsAddress = requireAddress(systemParamsAddressRaw, 'systemParamsAddress');
-    const [ccrRaw, mcrRaw, scrRaw, bcrRaw, minDebtRaw, ethGasCompensationRaw, minAnnualInterestRateRaw,] = await Promise.all([
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'CCR'),
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'MCR'),
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'SCR'),
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'BCR'),
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'MIN_DEBT'),
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'ETH_GAS_COMPENSATION'),
-        readNoArgsContract(publicClient, systemParamsAddress, SYSTEM_PARAMS_ABI, 'MIN_ANNUAL_INTEREST_RATE'),
+    const [ccrRaw, mcrRaw, scrRaw, bcrRaw, minDebtRaw, ethGasCompensationRaw, minAnnualInterestRateRaw,] = await readNoArgsContracts(publicClient, [
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'CCR' },
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'MCR' },
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'SCR' },
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'BCR' },
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'MIN_DEBT' },
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'ETH_GAS_COMPENSATION' },
+        { address: systemParamsAddress, abi: SYSTEM_PARAMS_ABI, functionName: 'MIN_ANNUAL_INTEREST_RATE' },
     ]);
     return {
         mcr: requireBigInt(mcrRaw, 'MCR'),

package/dist/esm/services/index.js

@@ -5,3 +5,4 @@ export * from './swap';
 export * from './trading';
 export * from './borrow';
 export * from './tokens';
+export * from './liquidity';

package/dist/esm/services/liquidity/LiquidityService.js

@@ -1,6 +1,6 @@
 import { buildAddLiquidityTransactionInternal, buildAddLiquidityParamsInternal, buildRemoveLiquidityTransactionInternal, buildRemoveLiquidityParamsInternal, quoteAddLiquidityInternal, quoteRemoveLiquidityInternal, getLPTokenBalanceInternal, } from './basicLiquidity';
-import { buildZapInTransactionInternal, buildZapInParamsInternal, quoteZapInInternal, } from './zapIn';
-import { buildZapOutTransactionInternal, buildZapOutParamsInternal, quoteZapOutInternal, } from './zapOut';
+import { buildZapInTransactionInternal, buildZapInParamsInternal, prepareZapInInternal, quoteZapInInternal, } from './zapIn';
+import { buildZapOutTransactionInternal, buildZapOutParamsInternal, prepareZapOutInternal, quoteZapOutInternal, } from './zapOut';
 export class LiquidityService {
     constructor(publicClient, chainId, poolService, routeService) {
         this.publicClient = publicClient;
@@ -93,6 +93,9 @@ export class LiquidityService {
     async buildZapInParams(input) {
         return buildZapInParamsInternal(this.publicClient, this.chainId, this.poolService, this.routeService, input.poolAddress, input.tokenIn, input.amountIn, input.amountInSplit, input.recipient, input.options);
     }
+    async prepareZapIn(input) {
+        return prepareZapInInternal(this.publicClient, this.chainId, this.poolService, this.routeService, input.poolAddress, input.tokenIn, input.amountIn, input.amountInSplit, input.recipient, input.owner, input.options);
+    }
     /**
      * Builds zap out transaction with approval if needed.
      * Removes liquidity and swaps both tokens to a single output token.
@@ -111,6 +114,9 @@ export class LiquidityService {
     async buildZapOutParams(input) {
         return buildZapOutParamsInternal(this.publicClient, this.chainId, this.poolService, this.routeService, input.poolAddress, input.tokenOut, input.liquidity, input.recipient, input.options);
     }
+    async prepareZapOut(input) {
+        return prepareZapOutInternal(this.publicClient, this.chainId, this.poolService, this.routeService, input.poolAddress, input.tokenOut, input.liquidity, input.recipient, input.owner, input.options);
+    }
     /**
      * Quotes a zap in operation (read-only call).
      * Estimates expected LP tokens and minimum amounts after swaps and slippage.

package/dist/esm/services/liquidity/liquidityHelpers.js

@@ -1,8 +1,9 @@
 import { encodeFunctionData } from 'viem';
 import { PoolType } from '../../core/types';
-import { ERC20_ABI } from '../../core/abis';
+import { ERC20_ABI, FPMM_ABI } from '../../core/abis';
 import { getContractAddress } from '../../core/constants';
 import { validateAddress } from '../../utils/validation';
+import { multicall } from '../../utils/multicall';
 export function buildApprovalParams(chainId, token, amount) {
     const routerAddress = getContractAddress(chainId, 'Router');
     const data = encodeFunctionData({
@@ -64,3 +65,28 @@ export function validatePoolTokens(poolToken0, poolToken1, tokenA, tokenB) {
         throw new Error('tokenA and tokenB must be different');
     }
 }
+export async function getPoolSnapshot(publicClient, poolAddress) {
+    const results = await multicall(publicClient, [
+        {
+            address: poolAddress,
+            abi: FPMM_ABI,
+            functionName: 'getReserves',
+        },
+        {
+            address: poolAddress,
+            abi: ERC20_ABI,
+            functionName: 'totalSupply',
+            args: [],
+        },
+    ]);
+    if (results[0].status === 'failure' || results[1].status === 'failure') {
+        throw new Error(`Failed to fetch pool snapshot for ${poolAddress}`);
+    }
+    const [reserve0, reserve1, blockTimestampLast] = results[0].result;
+    return {
+        reserve0,
+        reserve1,
+        blockTimestampLast,
+        totalSupply: results[1].result,
+    };
+}

package/dist/esm/services/liquidity/zapHelpers.js

@@ -33,18 +33,16 @@ export function encodeZapOutCall(tokenOut, liquidity, zapParams, routesA, routes
  * @returns Routes from tokenIn to token0 and token1
  */
 export async function findZapInRoutes(routeService, tokenIn, token0, token1) {
-    let routesA = [];
-    let routesB = [];
-    // Find route from tokenIn to token0 (if different)
-    if (tokenIn.toLowerCase() !== token0.toLowerCase()) {
-        const routeA = await routeService.findRoute(tokenIn, token0);
-        routesA = encodeRoutePath(routeA.path, tokenIn, token0);
-    }
-    // Find route from tokenIn to token1 (if different)
-    if (tokenIn.toLowerCase() !== token1.toLowerCase()) {
-        const routeB = await routeService.findRoute(tokenIn, token1);
-        routesB = encodeRoutePath(routeB.path, tokenIn, token1);
-    }
+    const [routeA, routeB] = await Promise.all([
+        tokenIn.toLowerCase() !== token0.toLowerCase()
+            ? routeService.findRoute(tokenIn, token0)
+            : Promise.resolve(null),
+        tokenIn.toLowerCase() !== token1.toLowerCase()
+            ? routeService.findRoute(tokenIn, token1)
+            : Promise.resolve(null),
+    ]);
+    const routesA = routeA ? encodeRoutePath(routeA.path, tokenIn, token0) : [];
+    const routesB = routeB ? encodeRoutePath(routeB.path, tokenIn, token1) : [];
     return { routesA, routesB };
 }
 /**
@@ -57,18 +55,16 @@ export async function findZapInRoutes(routeService, tokenIn, token0, token1) {
  * @returns Routes from token0 and token1 to tokenOut
  */
 export async function findZapOutRoutes(routeService, token0, token1, tokenOut) {
-    let routesA = [];
-    let routesB = [];
-    // Find route from token0 to tokenOut (if different)
-    if (token0.toLowerCase() !== tokenOut.toLowerCase()) {
-        const routeA = await routeService.findRoute(token0, tokenOut);
-        routesA = encodeRoutePath(routeA.path, token0, tokenOut);
-    }
-    // Find route from token1 to tokenOut (if different)
-    if (token1.toLowerCase() !== tokenOut.toLowerCase()) {
-        const routeB = await routeService.findRoute(token1, tokenOut);
-        routesB = encodeRoutePath(routeB.path, token1, tokenOut);
-    }
+    const [routeA, routeB] = await Promise.all([
+        token0.toLowerCase() !== tokenOut.toLowerCase()
+            ? routeService.findRoute(token0, tokenOut)
+            : Promise.resolve(null),
+        token1.toLowerCase() !== tokenOut.toLowerCase()
+            ? routeService.findRoute(token1, tokenOut)
+            : Promise.resolve(null),
+    ]);
+    const routesA = routeA ? encodeRoutePath(routeA.path, token0, tokenOut) : [];
+    const routesB = routeB ? encodeRoutePath(routeB.path, token1, tokenOut) : [];
     return { routesA, routesB };
 }
 // ========== CALCULATION FUNCTIONS ==========

package/dist/esm/services/liquidity/zapIn.js

@@ -1,40 +1,64 @@
-import { ROUTER_ABI, ERC20_ABI } from '../../core/abis';
+import { ROUTER_ABI } from '../../core/abis';
 import { getContractAddress } from '../../core/constants';
 import { validateAddress } from '../../utils/validation';
-import { buildApprovalParams, getAllowance, calculateMinAmount, getPoolInfo } from './liquidityHelpers';
+import { buildApprovalParams, getAllowance, calculateMinAmount, getPoolInfo, getPoolSnapshot } from './liquidityHelpers';
 import { encodeZapInCall, findZapInRoutes, splitAmount, estimateLiquidityFromZapIn, } from './zapHelpers';
 // ========== ZAP IN OPERATIONS ==========
 /**
  * Builds a complete zap in transaction including approval if needed
  */
 export async function buildZapInTransactionInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, owner, options) {
-    validateAddress(owner, 'owner');
-    // Build zap in params
-    const zapIn = await buildZapInParamsInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, options);
-    // Check allowance for input token
-    const tokenInAddr = tokenIn;
-    const ownerAddr = owner;
-    const currentAllowance = await getAllowance(publicClient, tokenInAddr, ownerAddr, chainId);
-    // Build approval if needed
-    const approval = currentAllowance < amountIn
-        ? { token: tokenIn, amount: amountIn, params: buildApprovalParams(chainId, tokenInAddr, amountIn) }
-        : null;
-    return { approval, zapIn };
+    const prepared = await prepareZapInInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, owner, options);
+    return {
+        approval: prepared.approval ?? null,
+        zapIn: prepared.details,
+    };
 }
 /**
  * Builds zap in transaction parameters without checking approval
  */
 export async function buildZapInParamsInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, options) {
+    const prepared = await prepareZapInInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, undefined, options);
+    return prepared.details;
+}
+/**
+ * Quotes a zap in operation (read-only)
+ */
+export async function quoteZapInInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, options) {
+    const prepared = await prepareZapInInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, tokenIn, undefined, options);
+    return prepared.quote;
+}
+export async function prepareZapInInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, owner, options) {
+    if (owner) {
+        validateAddress(owner, 'owner');
+    }
+    const [context, currentAllowance] = await Promise.all([
+        prepareZapInContextInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, options),
+        owner ? getAllowance(publicClient, tokenIn, owner, chainId) : Promise.resolve(null),
+    ]);
+    const approval = owner && currentAllowance !== null && currentAllowance < amountIn
+        ? { token: tokenIn, amount: amountIn, params: buildApprovalParams(chainId, tokenIn, amountIn) }
+        : owner
+            ? null
+            : undefined;
+    return {
+        routesA: context.routesA,
+        routesB: context.routesB,
+        quote: context.quote,
+        approval,
+        details: context.details,
+    };
+}
+async function prepareZapInContextInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, options) {
     validateAddress(poolAddress, 'poolAddress');
     validateAddress(tokenIn, 'tokenIn');
     validateAddress(recipient, 'recipient');
-    // Get pool info
     const { token0, token1, factoryAddr } = await getPoolInfo(poolService, poolAddress);
-    // Split input amount
     const { amountA: amountInA, amountB: amountInB } = splitAmount(amountIn, amountInSplit);
-    // Find routes for swapping
-    const { routesA, routesB } = await findZapInRoutes(routeService, tokenIn, token0, token1);
-    // Generate zap parameters using Router helper
+    const [{ routesA, routesB }, poolSnapshot] = await Promise.all([
+        findZapInRoutes(routeService, tokenIn, token0, token1),
+        getPoolSnapshot(publicClient, poolAddress),
+    ]);
     const routerAddress = getContractAddress(chainId, 'Router');
     const [amountOutMinA, amountOutMinB, amountAMin, amountBMin] = (await publicClient.readContract({
         address: routerAddress,
@@ -42,20 +66,18 @@ export async function buildZapInParamsInternal(publicClient, chainId, poolServic
         functionName: 'generateZapInParams',
         args: [token0, token1, factoryAddr, amountInA, amountInB, routesA, routesB],
     }));
-    // Apply slippage to all minimum amounts
     const finalAmountAMin = calculateMinAmount(amountAMin, options.slippageTolerance);
     const finalAmountBMin = calculateMinAmount(amountBMin, options.slippageTolerance);
     const finalAmountOutMinA = calculateMinAmount(amountOutMinA, options.slippageTolerance);
     const finalAmountOutMinB = calculateMinAmount(amountOutMinB, options.slippageTolerance);
-    // Estimate expected liquidity
-    const poolDetails = await poolService.getPoolDetails(poolAddress);
-    const totalSupply = (await publicClient.readContract({
-        address: poolAddress,
-        abi: ERC20_ABI,
-        functionName: 'totalSupply',
-        args: [],
-    }));
-    const expectedLiquidity = estimateLiquidityFromZapIn(finalAmountOutMinA, finalAmountOutMinB, poolDetails.reserve0, poolDetails.reserve1, totalSupply);
+    const expectedLiquidity = estimateLiquidityFromZapIn(finalAmountOutMinA, finalAmountOutMinB, poolSnapshot.reserve0, poolSnapshot.reserve1, poolSnapshot.totalSupply);
+    const quote = {
+        amountOutFromA: finalAmountOutMinA,
+        amountOutFromB: finalAmountOutMinB,
+        amountAMin: finalAmountAMin,
+        amountBMin: finalAmountBMin,
+        estimatedMinLiquidity: expectedLiquidity,
+    };
     const zapParams = {
         tokenA: token0,
         tokenB: token1,
@@ -67,53 +89,24 @@ export async function buildZapInParamsInternal(publicClient, chainId, poolServic
     };
     const data = encodeZapInCall(tokenIn, amountInA, amountInB, zapParams, routesA, routesB, recipient);
     return {
-        params: {
-            to: routerAddress,
-            data,
-            value: '0',
-        },
-        poolAddress,
-        tokenIn,
-        amountIn,
-        amountInA,
-        amountInB,
         routesA,
         routesB,
-        zapParams,
-        estimatedMinLiquidity: expectedLiquidity,
-    };
-}
-/**
- * Quotes a zap in operation (read-only)
- */
-export async function quoteZapInInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, options) {
-    validateAddress(poolAddress, 'poolAddress');
-    validateAddress(tokenIn, 'tokenIn');
-    const { token0, token1, factoryAddr } = await getPoolInfo(poolService, poolAddress);
-    const { amountA: amountInA, amountB: amountInB } = splitAmount(amountIn, amountInSplit);
-    const { routesA, routesB } = await findZapInRoutes(routeService, tokenIn, token0, token1);
-    const routerAddress = getContractAddress(chainId, 'Router');
-    const [amountOutMinA, amountOutMinB, amountAMin, amountBMin] = (await publicClient.readContract({
-        address: routerAddress,
-        abi: ROUTER_ABI,
-        functionName: 'generateZapInParams',
-        args: [token0, token1, factoryAddr, amountInA, amountInB, routesA, routesB],
-    }));
-    const poolDetails = await poolService.getPoolDetails(poolAddress);
-    const totalSupply = (await publicClient.readContract({
-        address: poolAddress,
-        abi: ERC20_ABI,
-        functionName: 'totalSupply',
-        args: [],
-    }));
-    const finalAmountOutMinA = calculateMinAmount(amountOutMinA, options.slippageTolerance);
-    const finalAmountOutMinB = calculateMinAmount(amountOutMinB, options.slippageTolerance);
-    const expectedLiquidity = estimateLiquidityFromZapIn(finalAmountOutMinA, finalAmountOutMinB, poolDetails.reserve0, poolDetails.reserve1, totalSupply);
-    return {
-        amountOutFromA: finalAmountOutMinA,
-        amountOutFromB: finalAmountOutMinB,
-        amountAMin: calculateMinAmount(amountAMin, options.slippageTolerance),
-        amountBMin: calculateMinAmount(amountBMin, options.slippageTolerance),
-        estimatedMinLiquidity: expectedLiquidity,
+        quote,
+        details: {
+            params: {
+                to: routerAddress,
+                data,
+                value: '0',
+            },
+            poolAddress,
+            tokenIn,
+            amountIn,
+            amountInA,
+            amountInB,
+            routesA,
+            routesB,
+            zapParams,
+            estimatedMinLiquidity: expectedLiquidity,
+        },
     };
 }