@mento-protocol/mento-sdk 3.2.3 → 3.2.4

package/dist/cjs/routeUtils.d.ts

@@ -1,304 +0,0 @@
-import { TradablePairWithSpread } from './constants';
-import { Address } from './interfaces';
-import { TradablePair, TradablePairID } from './mento';
-type TokenSymbol = string;
-interface ExchangeDetails {
-    providerAddr: Address;
-    id: string;
-    assets: [Address, Address];
-}
-/**
- * =============================================================================
- * ROUTE GENERATION UTILITIES
- * =============================================================================
- *
- * Utilities for generating optimal trading routes in the Mento protocol.
- *
- * The main workflow is:
- *
- * 1. Build connectivity structures from direct trading pairs
- * 2. Generate all possible routes (direct + two-hop)
- * 3. Select optimal routes using spread data or heuristics
- *
- * ALGORITHM OVERVIEW:
- * - Creates a graph where tokens are nodes and direct exchanges are edges
- * - Uses graph traversal to find two-hop routes through intermediate tokens
- * - Optimizes route selection based on spread costs when available
- * - Falls back to heuristics (prefer direct routes, major stablecoins)
- * =============================================================================
- */
-/**
- * Connectivity data structure that represents the token graph connecting all tokens.
- * Helps to efficiently answer: "How can I trade from token A to token B?"
- *
- * CONCRETE EXAMPLE:
- * Given these direct trading pairs:
- * - cUSD ↔ CELO (direct exchange exists)
- * - CELO ↔ cEUR (direct exchange exists)
- * - cUSD ↔ cREAL (direct exchange exists)
- *
- * How route finding works:
- * - Direct route: cUSD → cEUR? Check token graph: cUSD connects to [CELO, cREAL], none is cEUR → No direct route
- * - Two-hop route: cUSD → ? → cEUR?
- *   - cUSD connects to CELO, CELO connects to cEUR → Found route: cUSD → CELO → cEUR
- *   - cUSD connects to cREAL, cREAL connects to [cUSD] → No route via cREAL
- *
- * The "connectivity" part means we can quickly traverse the network of
- * token connections to find all possible trading paths.
- */
-export interface ConnectivityData {
-    /** Maps token address to symbol for efficient lookups
-     *
-     *    ```
-     *    '0x765D...' → 'cUSD'
-     *    '0x471E...' → 'CELO'
-     *    '0xD876...' → 'cEUR'
-     *    ```
-     */
-    addrToSymbol: Map<Address, TokenSymbol>;
-    /** Adjacency list mapping which tokens connect to which
-     * Used for finding two-hop routes by traversing token → neighbor → neighbor.
-     *
-     * Example for a cUSD => cEUR swap: First we find cUSD → [CELO, cKES, ...]
-     * Then we find CELO → [cUSD, cEUR, ...] = found route via cUSD → CELO → cEUR
-     *
-     *    ```
-     *    'cUSD_addr' → Set(['CELO_addr', 'cKES_addr'])  // cUSD connects to CELO and cKES
-     *    'CELO_addr' → Set(['cUSD_addr', 'cEUR_addr'])  // CELO connects to cUSD and cEUR
-     *    'cEUR_addr' → Set(['CELO_addr'])               // cEUR connects to CELO
-     *    'cKES_addr' → Set(['cUSD_addr'])               // cKES connects to cUSD
-     *    ```
-     */
-    tokenGraph: Map<Address, Set<Address>>;
-    /** Maps sorted token address pairs to their direct exchange hop details
-     *    ```
-     *    'CELO_addr-cEUR_addr' → { exchange details for CELO ↔ cEUR }
-     *    'CELO_addr-cUSD_addr' → { exchange details for CELO ↔ cUSD }
-     *    'cUSD_addr-cKES_addr' → { exchange details for cUSD ↔ cKES }
-     *    ```
-     */
-    directPathMap: Map<TradablePairID, ExchangeDetails>;
-    /** Original direct trading pairs from mento.getDirectPairs() for reference */
-    directPairs: TradablePair[];
-}
-/**
- * Builds the connectivity data structures needed for route generation.
- *
- * Transforms a list of direct trading pairs into our ConnectivityData
- * that allow us to quickly find trading routes.
- *
- * **Construction Process:**
- *
- * ```
- * Input: TradablePairs = [
- *   { id: 'cUSD-CELO', assets: [cUSD, CELO], path: [exchange1_CELO_cUSD] },
- *   { id: 'CELO-cEUR', assets: [CELO, cEUR], path: [exchange2_CELO_cEUR] }
- * ]
- *
- * Step 1 - Build addrToSymbol map:
- *   cUSD.address → 'cUSD'
- *   CELO.address → 'CELO'
- *   cEUR.address → 'cEUR'
- *
- * Step 2 - Build directPathMap (sorted alphabetically for consistency):
- *   'CELO_addr-cEUR_addr' → exchange2_CELO_cEUR
- *   'CELO_addr-cUSD_addr' → exchange1_CELO_cUSD
- *
- * Step 3 - Build bidirectional tokenGraph:
- *   cUSD.address → Set([CELO.address])
- *   CELO.address → Set([cUSD.address, cEUR.address])
- *   cEUR.address → Set([CELO.address])
- * ```
- *
- * **Result**: We can now efficiently answer:
- * - "What's the symbol for address X?" → addrToSymbol.get(addr)
- * - "What exchange connects tokens X and Y?" → directPathMap.get(sortedAddressPairKey)
- * - "What tokens can I reach from token X?" → tokenGraph.get(X)
- *
- * @param directPairs - Array of direct trading pairs
- * @returns Connectivity data structure for efficient route generation
- *
- * @example
- * ```typescript
- * const directPairs = [
- *   { id: 'cUSD-CELO', assets: [cUSD, CELO], path: [exchange1] },
- *   { id: 'CELO-cEUR', assets: [CELO, cEUR], path: [exchange2] }
- * ]
- *
- * const connectivityData = buildConnectivityStructures(directPairs)
- *
- * // Now we can efficiently find routes:
- * // 1. Check if cUSD connects to anything: connectivityData.tokenGraph.get(cUSD.address) → [CELO.address]
- * // 2. Check if CELO connects to cEUR: connectivityData.tokenGraph.get(CELO.address) → [cUSD.address, cEUR.address] ✓
- * // 3. Get exchange details: connectivityData.directPathMap.get('CELO_addr-cEUR_addr') → exchange2_CELO_cEUR
- * // Result: Found route cUSD → CELO → cEUR with exchange details
- * ```
- */
-export declare function buildConnectivityStructures(directPairs: TradablePair[]): ConnectivityData;
-/**
- * Generates all possible routes (direct + two-hop) using connectivity data.
- *
- * This function implements a route discovery algorithm that:
- *
- * 1. **Adds all direct pairs** (single-hop routes)
- * 2. **Discovers two-hop routes** using graph traversal:
- *    - For each token A, find its neighbors (tokens directly connected)
- *    - For each neighbor B, find B's neighbors
- *    - If B connects to token C (C ≠ A), then A->B->C is a valid route
- *
- * **Route Deduplication**: Multiple routes between the same token pair
- * are collected in arrays, allowing the selection algorithm to choose
- * the best one based on spread data or heuristics.
- *
- * **Canonical Pair IDs**: All pairs use alphabetically sorted symbols
- * (e.g., 'cEUR-cUSD' not 'cUSD-cEUR') for consistent identification.
- *
- * @param connectivityData - The connectivity data from buildConnectivityStructures()
- * @returns Map of pair ID -> array of possible routes for that pair
- *
- * @example
- * ```typescript
- * // Given direct pairs: cUSD-CELO, CELO-cEUR, cUSD-USDC
- * const allRoutes = generateAllRoutes(connectivityData)
- *
- * // Results might include:
- * // 'cUSD-CELO' -> [{ path: [cUSD->CELO] }] // direct route
- * // 'cEUR-cUSD' -> [
- * //   { path: [cUSD->USDC, USDC->cEUR] } // two-hop via USDC
- * //   { path: [cUSD->CELO, CELO->cEUR] } // two-hop via CELO
- * // ]
- * ```
- */
-export declare function generateAllRoutes(connectivityData: ConnectivityData): Map<TradablePairID, TradablePair[]>;
-/**
- * Creates a two-hop tradable pair if valid exchange hops exist.
- *
- * 1. **Validates tokens exist** in the asset map
- * 2. **Finds exchange hops** for both segments of the route
- * 3. **Creates canonical pair structure** with sorted symbols
- *
- * **Route Structure**: The resulting pair represents trading from start->end
- * via intermediate token, but the assets are ordered alphabetically by symbol
- * for consistency (canonical form).
- *
- * **Path Representation**: The path array contains the actual exchange hops
- * needed to execute the trade, preserving the routing information.
- *
- * @param startToken - Starting token address
- * @param intermediate - Intermediate token address for routing
- * @param end - Destination token address
- * @param assetMap - Map of token address -> Asset details
- * @param directPathMap - Map of token pairs -> exchange hop details
- * @returns Route if valid route exists, null otherwise
- *
- * @example
- * ```typescript
- * // Create route: cUSD -> CELO -> cEUR
- * const pair = createTwoHopPair(
- *   '0x765D...', // cUSD address
- *   '0x471E...', // CELO address
- *   '0xD876...', // cEUR address
- *   addrToSymbol,
- *   directPathMap
- * )
- *
- * // Result:
- * // {
- * //   id: 'cEUR-cUSD',           // alphabetical order
- * //   assets: [cEUR, cUSD],     // alphabetical order
- * //   path: [                   // actual routing path
- * //     { cUSD->CELO exchange },
- * //     { CELO->cEUR exchange }
- * //   ]
- * // }
- * ```
- */
-export declare function createTwoHopPair(startToken: Address, intermediateToken: Address, endToken: Address, addrToSymbol: Map<Address, TokenSymbol>, directPathMap: Map<string, {
-    providerAddr: Address;
-    id: string;
-    assets: [Address, Address];
-}>): TradablePair | null;
-/**
- * Selects optimal routes from all candidates based on spread data or heuristics.
- *
- * This is the route optimization engine that implements the following logic:
- *
- * **For Single Route**: Use it directly (no optimization needed)
- *
- * **For Multiple Routes**:
- * - If `returnAllRoutes=true`: Return all routes (used for cache generation)
- * - If `returnAllRoutes=false`: Apply optimization to select the best route
- *
- * **Route Selection Strategy**: Delegates to `selectBestRoute()` which uses
- * a multi-tier approach prioritizing cost efficiency and reliability.
- *
- * @param allRoutes - Map of pair ID -> array of possible routes
- * @param returnAllRoutes - Whether to return all routes or optimize selection
- * @param assetMap - Asset map for token symbol lookups during optimization
- * @returns Array of selected optimal routes
- *
- * @example
- * ```typescript
- * // Multiple routes for cUSD-cEUR pair
- * const candidates = new Map([
- *   ['cEUR-cUSD', [
- *     { path: [cUSD->CELO->cEUR], spreadData: { totalSpreadPercent: 0.5 } },
- *     { path: [cUSD->cREAL->cEUR], spreadData: { totalSpreadPercent: 0.3 } },
- *     { path: [cUSD->cEUR] } // direct route, no spread data
- *   ]]
- * ])
- *
- * const optimal = selectOptimalRoutes(candidates, false, assetMap)
- * // Returns the cUSD->cREAL->cEUR route (lowest spread: 0.3%)
- * ```
- */
-export declare function selectOptimalRoutes(allRoutes: Map<TradablePairID, TradablePair[]>, returnAllRoutes: boolean, addrToSymbol: Map<Address, TokenSymbol>): (TradablePair | TradablePairWithSpread)[];
-/**
- * Selects the best route from candidates using spread data or fallback heuristics.
- *
- * This function implements a sophisticated route selection algorithm with
- * multiple optimization tiers:
- *
- * **Tier 1 - Spread-Based Optimization** (Preferred):
- * - Use routes with spread data (actual cost information)
- * - Select route with lowest `totalSpreadPercent`
- * - This provides the most cost-efficient trading
- *
- * **Tier 2 - Direct Route Preference** (Fallback):
- * - If no spread data available, prefer direct (single-hop) routes
- * - Direct routes have lower execution risk and gas costs
- *
- * **Tier 3 - Major Stablecoin Preference** (Final Fallback):
- * - For two-hop routes, prefer those going through major stablecoins
- * - Major FX currencies like cUSD and cEUR typically have better liquidity
- *
- * **Tier 4 - First Available** (Last Resort):
- * - If no other heuristics apply, use the first route found
- *
- * @param candidates - Array of possible routes for the same token pair
- * @param assetMap - Asset map for token symbol lookups
- * @returns The optimal route selected using the tier system
- *
- * @example
- * ```typescript
- * const candidates = [
- *   { path: [A->B->C], spreadData: { totalSpreadPercent: 0.8 } },
- *   { path: [A->D->C], spreadData: { totalSpreadPercent: 0.4 } }, // Winner: lowest spread
- *   { path: [A->C] }, // direct route, no spread data
- * ]
- *
- * const best = selectBestRoute(candidates, assetMap)
- * // Returns the A->D->C route (0.4% spread)
- * ```
- */
-export declare function selectBestRoute(candidates: TradablePair[], addrToSymbol: Map<Address, TokenSymbol>): TradablePair | TradablePairWithSpread;
-/**
- * Extracts the intermediate token address from a two-hop route.
- * In a two-hop route A->B->C, this function finds token B (the intermediate).
- */
-export declare function getIntermediateToken(route: TradablePair): Address | undefined;
-/**
- * Type guard to check if a Route has spread data.
- */
-export declare function hasSpreadData(pair: TradablePair | TradablePairWithSpread): pair is TradablePairWithSpread;
-export {};

package/dist/cjs/types/contractAddressMap.d.ts

@@ -1,4 +0,0 @@
-import { ContractAddresses } from '.';
-export type ContractAddressMap = {
-    [chainId: number]: Partial<ContractAddresses>;
-};

package/dist/cjs/types/contractAddressMap.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/contractAddresses.d.ts

@@ -1,23 +0,0 @@
-export type ContractAddresses = {
-    GovernanceFactory: string;
-    Airgrab: string;
-    Emission: string;
-    MentoGovernor: string;
-    MentoToken: string;
-    TimelockController: string;
-    Locking: string;
-    MentoRouter: string;
-    Broker: string;
-    BiPoolManager: string;
-    BreakerBox: string;
-    Reserve: string;
-    ConstantSumPricingModule: string;
-    ConstantProductPricingModule: string;
-    MedianDeltaBreaker: string;
-    ValueDeltaBreaker: string;
-    StableToken: string;
-    StableTokenEUR: string;
-    StableTokenBRL: string;
-    StableTokenXOF: string;
-    SortedOracles: string;
-};

package/dist/cjs/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from './contractAddresses';
-export * from './contractAddressMap';

package/dist/cjs/utils.d.ts

@@ -1,80 +0,0 @@
-import { BigNumberish, providers, Signer } from 'ethers';
-import { TokenSymbol } from './constants';
-import { Address } from './interfaces';
-import { Token, TradablePair } from './mento';
-/**
- * Gets the chain ID from a signer or provider
- * @param signerOrProvider an ethers provider or signer
- * @returns the chain ID
- */
-export declare function getChainId(signerOrProvider: Signer | providers.Provider): Promise<number>;
-/**
- * Ensures that given signer is truly a a connected signer
- * @param signer an ethers signer
- * @throws if signer is invalid or not connected
- */
-export declare function validateSigner(signer: Signer): void;
-/**
- * Ensures that given signerOrProvider is truly a provider or a connected signer
- * @param signerOrProvider an ethers provider or signer
- * @throws if signerOrProvider is invalid or not connected
- */
-export declare function validateSignerOrProvider(signerOrProvider: Signer | providers.Provider): void;
-/**
- * Returns the symbol of an erc20 token
- * @param tokenAddr the address of the erc20 token
- * @param signerOrProvider an ethers provider or signer
- * @returns the symbol of the erc20 token
- */
-export declare function getSymbolFromTokenAddress(tokenAddr: Address, signerOrProvider: Signer | providers.Provider): Promise<TokenSymbol>;
-/**
- * Returns the name of an erc20 token
- * @param tokenAddr the address of the erc20 token
- * @param signerOrProvider an ethers provider or signer
- * @returns the name of the erc20 token
- */
-export declare function getNameFromTokenAddress(tokenAddr: Address, signerOrProvider: Signer | providers.Provider): Promise<string>;
-/**
- * Returns the decimals of an erc20 token
- * @param tokenAddr the address of the erc20 token
- * @param signerOrProvider an ethers provider or signer
- * @returns the decimals of the erc20 token
- */
-export declare function getDecimalsFromTokenAddress(tokenAddr: Address, signerOrProvider: Signer | providers.Provider): Promise<number>;
-/**
- * Returns a populated tx obj for increasing the allowance of a spender for a given erc20 token by a given amount
- * @param tokenAddr the address of the erc20 token
- * @param spender the address of the spender
- * @param amount the amount to increase the allowance by
- * @param signerOrProvider an ethers signer or provider
- * @returns the populated TransactionRequest object
- */
-export declare function increaseAllowance(tokenAddr: string, spender: string, amount: BigNumberish, signerOrProvider: Signer | providers.Provider): Promise<providers.TransactionRequest>;
-/**
- * Find a token address by its symbol from tradable pairs
- * @param pairs array of tradable pairs to search through
- * @param symbol the token symbol to find (case-insensitive)
- * @returns the token address if found, null otherwise
- */
-export declare function findTokenAddressBySymbolInTradablePairs(symbol: TokenSymbol, pairs: readonly TradablePair[]): Address | null;
-export declare function capitalize(str: string): string; /**
- * Helper function to get token address by symbol for a specific chain
- * @param symbol - The token symbol
- * @param chainId - The chain ID
- * @returns The token address or undefined if not found
- */
-export declare function getTokenAddress(symbol: TokenSymbol, chainId: number): string | undefined;
-/**
- * Helper function to find a token by symbol in the cached tokens
- * @param symbol - The token symbol to search for
- * @param chainId - The chain ID
- * @returns The token object or undefined if not found
- */
-export declare function findTokenBySymbol(symbol: string, chainId: number): Token | undefined;
-/**
- * Computes the rate feed ID from a rate feed identifier string.
- * This follows the Solidity formula: address(uint160(uint256(keccak256(abi.encodePacked(rateFeed)))))
- * @param rateFeed the rate feed identifier string (e.g., "EURUSD", "relayed:COPUSD")
- * @returns the computed rate feed address
- */
-export declare function toRateFeedId(rateFeed: string): Address;

package/dist/cjs/utils.js

@@ -1,177 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toRateFeedId = exports.findTokenBySymbol = exports.getTokenAddress = exports.capitalize = exports.findTokenAddressBySymbolInTradablePairs = exports.increaseAllowance = exports.getDecimalsFromTokenAddress = exports.getNameFromTokenAddress = exports.getSymbolFromTokenAddress = exports.validateSignerOrProvider = exports.validateSigner = exports.getChainId = void 0;
-const ethers_1 = require("ethers");
-const tokens_1 = require("./constants/tokens");
-/**
- * Gets the chain ID from a signer or provider
- * @param signerOrProvider an ethers provider or signer
- * @returns the chain ID
- */
-function getChainId(signerOrProvider) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const provider = ethers_1.Signer.isSigner(signerOrProvider)
-            ? signerOrProvider.provider
-            : signerOrProvider;
-        return (yield provider.getNetwork()).chainId;
-    });
-}
-exports.getChainId = getChainId;
-/**
- * Ensures that given signer is truly a a connected signer
- * @param signer an ethers signer
- * @throws if signer is invalid or not connected
- */
-function validateSigner(signer) {
-    if (!ethers_1.Signer.isSigner(signer)) {
-        throw new Error('A valid signer must be provided');
-    }
-    if (!ethers_1.providers.Provider.isProvider(signer.provider)) {
-        throw new Error('Signer must be connected to a provider');
-    }
-}
-exports.validateSigner = validateSigner;
-/**
- * Ensures that given signerOrProvider is truly a provider or a connected signer
- * @param signerOrProvider an ethers provider or signer
- * @throws if signerOrProvider is invalid or not connected
- */
-function validateSignerOrProvider(signerOrProvider) {
-    const isSigner = ethers_1.Signer.isSigner(signerOrProvider);
-    const isProvider = ethers_1.providers.Provider.isProvider(signerOrProvider);
-    if (!isSigner && !isProvider) {
-        throw new Error('A valid signer or provider must be provided');
-    }
-    if (isSigner && !ethers_1.providers.Provider.isProvider(signerOrProvider.provider)) {
-        throw new Error('Signer must be connected to a provider');
-    }
-}
-exports.validateSignerOrProvider = validateSignerOrProvider;
-/**
- * Returns the symbol of an erc20 token
- * @param tokenAddr the address of the erc20 token
- * @param signerOrProvider an ethers provider or signer
- * @returns the symbol of the erc20 token
- */
-function getSymbolFromTokenAddress(tokenAddr, signerOrProvider) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const erc20Abi = ['function symbol() external view returns (string memory)'];
-        const contract = new ethers_1.Contract(tokenAddr, erc20Abi, signerOrProvider);
-        return contract.symbol();
-    });
-}
-exports.getSymbolFromTokenAddress = getSymbolFromTokenAddress;
-/**
- * Returns the name of an erc20 token
- * @param tokenAddr the address of the erc20 token
- * @param signerOrProvider an ethers provider or signer
- * @returns the name of the erc20 token
- */
-function getNameFromTokenAddress(tokenAddr, signerOrProvider) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const erc20Abi = ['function name() external view returns (string memory)'];
-        const contract = new ethers_1.Contract(tokenAddr, erc20Abi, signerOrProvider);
-        return contract.name();
-    });
-}
-exports.getNameFromTokenAddress = getNameFromTokenAddress;
-/**
- * Returns the decimals of an erc20 token
- * @param tokenAddr the address of the erc20 token
- * @param signerOrProvider an ethers provider or signer
- * @returns the decimals of the erc20 token
- */
-function getDecimalsFromTokenAddress(tokenAddr, signerOrProvider) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const erc20Abi = ['function decimals() external view returns (uint8)'];
-        const contract = new ethers_1.Contract(tokenAddr, erc20Abi, signerOrProvider);
-        return contract.decimals();
-    });
-}
-exports.getDecimalsFromTokenAddress = getDecimalsFromTokenAddress;
-/**
- * Returns a populated tx obj for increasing the allowance of a spender for a given erc20 token by a given amount
- * @param tokenAddr the address of the erc20 token
- * @param spender the address of the spender
- * @param amount the amount to increase the allowance by
- * @param signerOrProvider an ethers signer or provider
- * @returns the populated TransactionRequest object
- */
-function increaseAllowance(tokenAddr, spender, amount, signerOrProvider) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const abi = [
-            'function increaseAllowance(address spender, uint256 value) external returns (bool)',
-        ];
-        // TODO, not all ERC-20 contracts support increaseAllowance
-        // Add a check for that here
-        const contract = new ethers_1.Contract(tokenAddr, abi, signerOrProvider);
-        return yield contract.populateTransaction.increaseAllowance(spender, amount);
-    });
-}
-exports.increaseAllowance = increaseAllowance;
-/**
- * Find a token address by its symbol from tradable pairs
- * @param pairs array of tradable pairs to search through
- * @param symbol the token symbol to find (case-insensitive)
- * @returns the token address if found, null otherwise
- */
-function findTokenAddressBySymbolInTradablePairs(symbol, pairs) {
-    var _a, _b;
-    return ((_b = (_a = pairs
-        .flatMap((pair) => pair.assets)
-        .find((asset) => asset.symbol.toLowerCase() === symbol.toLowerCase())) === null || _a === void 0 ? void 0 : _a.address) !== null && _b !== void 0 ? _b : null);
-}
-exports.findTokenAddressBySymbolInTradablePairs = findTokenAddressBySymbolInTradablePairs;
-function capitalize(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-} /**
- * Helper function to get token address by symbol for a specific chain
- * @param symbol - The token symbol
- * @param chainId - The chain ID
- * @returns The token address or undefined if not found
- */
-exports.capitalize = capitalize;
-function getTokenAddress(symbol, chainId) {
-    var _a;
-    return (_a = tokens_1.TOKEN_ADDRESSES_BY_CHAIN[chainId]) === null || _a === void 0 ? void 0 : _a[symbol];
-}
-exports.getTokenAddress = getTokenAddress;
-/**
- * Helper function to find a token by symbol in the cached tokens
- * @param symbol - The token symbol to search for
- * @param chainId - The chain ID
- * @returns The token object or undefined if not found
- */
-function findTokenBySymbol(symbol, chainId) {
-    const tokens = (0, tokens_1.getCachedTokensSync)(chainId);
-    return tokens.find((token) => token.symbol === symbol);
-}
-exports.findTokenBySymbol = findTokenBySymbol;
-/**
- * Computes the rate feed ID from a rate feed identifier string.
- * This follows the Solidity formula: address(uint160(uint256(keccak256(abi.encodePacked(rateFeed)))))
- * @param rateFeed the rate feed identifier string (e.g., "EURUSD", "relayed:COPUSD")
- * @returns the computed rate feed address
- */
-function toRateFeedId(rateFeed) {
-    // 1. Calculate keccak256 hash
-    const hashedBytes = ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.toUtf8Bytes(rateFeed));
-    // 2. Convert to BigInt (equivalent to uint256)
-    const hashAsBigInt = BigInt(hashedBytes);
-    // 3. Mask to 160 bits (equivalent to uint160)
-    const maskedToUint160 = hashAsBigInt & ((BigInt(1) << BigInt(160)) - BigInt(1));
-    // 4. Convert to address (hex string)
-    const addressHex = '0x' + maskedToUint160.toString(16).padStart(40, '0');
-    // 5. Return calculated rate feed ID
-    return addressHex;
-}
-exports.toRateFeedId = toRateFeedId;

package/dist/esm/ChainClient.d.ts

@@ -1,9 +0,0 @@
-import { PopulatedTransaction, ethers, providers } from 'ethers';
-import { IChainClient } from './interfaces';
-export declare class ChainClient implements IChainClient {
-    private readonly signerOrProvider;
-    constructor(signerOrProvider: ethers.Signer | providers.Provider);
-    getSigner(): Promise<ethers.Signer | providers.Provider>;
-    getChainId(): Promise<number>;
-    populateTransaction(tx: PopulatedTransaction): Promise<providers.TransactionRequest>;
-}

package/dist/esm/ChainClient.js

@@ -1,54 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { Signer, providers } from 'ethers';
-import { validateSignerOrProvider } from './utils';
-export class ChainClient {
-    constructor(signerOrProvider) {
-        validateSignerOrProvider(signerOrProvider);
-        this.signerOrProvider = signerOrProvider;
-    }
-    getSigner() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.signerOrProvider;
-        });
-    }
-    getChainId() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let chainId = 0;
-            if (Signer.isSigner(this.signerOrProvider)) {
-                const network = yield ((_a = this.signerOrProvider.provider) === null || _a === void 0 ? void 0 : _a.getNetwork());
-                if (network) {
-                    chainId = network.chainId;
-                }
-            }
-            else if (providers.Provider.isProvider(this.signerOrProvider)) {
-                const network = yield this.signerOrProvider.getNetwork();
-                if (network) {
-                    chainId = network.chainId;
-                }
-            }
-            if (chainId === 0) {
-                throw new Error('Could not get chainId from signer or provider');
-            }
-            return chainId;
-        });
-    }
-    populateTransaction(tx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (Signer.isSigner(this.signerOrProvider)) {
-                return this.signerOrProvider.populateTransaction(tx);
-            }
-            else {
-                return tx;
-            }
-        });
-    }
-}

package/dist/esm/TestChainClient.d.ts

@@ -1,7 +0,0 @@
-import { PopulatedTransaction, ethers, providers } from 'ethers';
-import { IChainClient } from './interfaces';
-export declare class TestChainClient implements IChainClient {
-    getSigner(): Promise<ethers.Signer | providers.Provider>;
-    getChainId(): Promise<number>;
-    populateTransaction(tx: PopulatedTransaction): Promise<providers.TransactionRequest>;
-}