@otim/utils 0.0.11 → 0.0.12

package/dist/chains/index.js

@@ -1,6 +1,7 @@
-const require_chunk = require('../chunk-kSYXY2_d.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
 const require_api_urls = require('../api-urls-Cd20DG4i.js');
-const require_helpers = require('../helpers-DoC7Xl12.js');
+const require_zod = require('../zod-CjftwcOJ.js');
 let viem_chains = require("viem/chains");
 
 //#region src/chains/config/custom-chains.ts
@@ -46,11 +47,7 @@ const pecorinoHost = {
 const supportedChains = {
 	mainnet: {
 		mainnet: viem_chains.mainnet,
-		base: viem_chains.base,
-		arbitrum: viem_chains.arbitrum,
-		optimism: viem_chains.optimism,
-		bsc: viem_chains.bsc,
-		polygon: viem_chains.polygon
+		base: viem_chains.base
 	},
 	testnet: {
 		sepolia: viem_chains.sepolia,
@@ -132,34 +129,34 @@ function isTestnetChain(chainId) {
 */
 const testnetTokenAddresses = {
 	[viem_chains.sepolia.id]: {
-		ETH: require_helpers.DEFAULT_ADDRESS,
+		ETH: require_zod.DEFAULT_ADDRESS,
 		WETH: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
 		USDC: "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238",
 		USDT: "0xaa8e23fb1079ea71e0a56f48a2aa51851d8433d0"
 	},
 	[viem_chains.baseSepolia.id]: {
-		ETH: require_helpers.DEFAULT_ADDRESS,
+		ETH: require_zod.DEFAULT_ADDRESS,
 		WETH: "0x4200000000000000000000000000000000000006",
 		USDC: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
 		USDT: "0x323e78f944A9a1FcF3a10efcC5319DBb0bB6e673"
 	},
 	[viem_chains.bscTestnet.id]: {
-		BNB: require_helpers.DEFAULT_ADDRESS,
+		BNB: require_zod.DEFAULT_ADDRESS,
 		WBNB: "0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd",
 		USDC: "0x64544969ed7EBf5f083679233325356EbE738930"
 	},
 	[viem_chains.polygonAmoy.id]: {
-		POL: require_helpers.DEFAULT_ADDRESS,
+		POL: require_zod.DEFAULT_ADDRESS,
 		WMATIC: "0x360ad4f9a9A8EFe9A8DCB5f461c4Cc1047E1Dcf9",
 		USDC: "0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582"
 	},
 	[viem_chains.unichain.id]: {
-		ETH: require_helpers.DEFAULT_ADDRESS,
+		ETH: require_zod.DEFAULT_ADDRESS,
 		WETH: "0x4200000000000000000000000000000000000006",
 		USDC: "0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA"
 	},
-	[pecorinoSignet.id]: { USD: require_helpers.DEFAULT_ADDRESS },
-	[pecorinoHost.id]: { ETH: require_helpers.DEFAULT_ADDRESS }
+	[pecorinoSignet.id]: { USD: require_zod.DEFAULT_ADDRESS },
+	[pecorinoHost.id]: { ETH: require_zod.DEFAULT_ADDRESS }
 };
 function getTestnetTokenAddresses(chainId) {
 	return testnetTokenAddresses[chainId] || {};

package/dist/chains/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["OtimEnvironment","base","baseSepolia","mainnet","base","arbitrum","optimism","bsc","unichain","polygon","sepolia","baseSepolia","sepolia","DEFAULT_ADDRESS","baseSepolia","bscTestnet","polygonAmoy","unichain","mainnet","ethereumTokens","base","baseTokens","arbitrum","arbitrumTokens","optimism","optimismTokens","bsc","bscTokens","polygon","polygonTokens","mainnet","base","arbitrum","optimism","bsc","polygon","avalanche","unichain","sepolia","baseSepolia","polygonAmoy"],"sources":["../../src/chains/config/custom-chains.ts","../../src/chains/config/all-chains.ts","../../src/chains/config/mainnet-chains.ts","../../src/chains/config/testnet-chains.ts","../../src/chains/tokens/testnet-token-addresses.ts","../../src/chains/tokens/testnet-token-metadata.ts","../../src/chains/tokens/arbitrum-token-list.json","../../src/chains/tokens/base-token-list.json","../../src/chains/tokens/bsc-token-list.json","../../src/chains/tokens/ethereum-token-list.json","../../src/chains/tokens/optimism-token-list.json","../../src/chains/tokens/polygon-token-list.json","../../src/chains/tokens/token-lists.ts","../../src/chains/tokens/chain-tokens.ts","../../src/chains/config/supported-chains.ts","../../src/chains/utils/filter-tokens.ts","../../src/chains/utils/token-maps.ts","../../src/chains/utils/stablecoin.ts","../../src/chains/lambda/chain-mapping.ts","../../src/chains/config/chain-metadata.ts"],"sourcesContent":["import type { Chain } from \"viem/chains\";\n\nexport const pecorinoSignet = {\n  id: 14174,\n  name: \"Pecorino Signet\",\n  nativeCurrency: {\n    decimals: 18,\n    name: \"USD\",\n    symbol: \"USD\",\n  },\n  rpcUrls: {\n    default: { http: [\"https://rpc.pecorino.signet.sh/\"] },\n    public: { http: [\"https://rpc.pecorino.signet.sh/\"] },\n  },\n  blockExplorers: {\n    default: {\n      name: \"Pecorino Signet Explorer\",\n      url: \"https://explorer.pecorino.signet.sh/\",\n    },\n  },\n  testnet: true,\n} as const satisfies Chain;\n\nexport const pecorinoHost = {\n  id: 3151908,\n  name: \"Pecorino Host\",\n  nativeCurrency: {\n    decimals: 18,\n    name: \"ETH\",\n    symbol: \"ETH\",\n  },\n  rpcUrls: {\n    default: { http: [\"https://host-rpc.pecorino.signet.sh/\"] },\n    public: { http: [\"https://host-rpc.pecorino.signet.sh/\"] },\n  },\n  blockExplorers: {\n    default: {\n      name: \"Pecorino Host Explorer\",\n      url: \"https://explorer-host.pecorino.signet.sh/\",\n    },\n  },\n  testnet: true,\n} as const satisfies Chain;\n","import {\n  arbitrum,\n  base,\n  baseSepolia,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n  polygonAmoy,\n  sepolia,\n  unichain,\n} from \"viem/chains\";\n\nimport { pecorinoHost, pecorinoSignet } from \"./custom-chains\";\nimport { OtimEnvironment } from \"../../config/api-urls\";\n\nexport const supportedChains = {\n  mainnet: {\n    mainnet,\n    base,\n    arbitrum,\n    optimism,\n    bsc,\n    polygon,\n  },\n  testnet: {\n    sepolia,\n    baseSepolia,\n  },\n} as const;\n\nexport const allSupportedChains = {\n  mainnet,\n  base,\n  arbitrum,\n  optimism,\n  bsc,\n  unichain,\n  polygon,\n  sepolia,\n  baseSepolia,\n  polygonAmoy,\n  pecorinoHost,\n  pecorinoSignet,\n} as const;\n\n/**\n * Get the default chain ID based on the provided environment.\n * Production: Base mainnet (8453)\n * Local/Sandbox: Base Sepolia (84532)\n *\n * @param environment - The Otim environment (local | sandbox | production)\n * @returns The default chain ID for the environment\n */\nexport const getDefaultChainId = (environment: OtimEnvironment): number => {\n  return environment === OtimEnvironment.Production ? base.id : baseSepolia.id;\n};\n\n/**\n * Get the default chain based on the provided environment.\n * Production: Base mainnet\n * Local/Sandbox: Base Sepolia\n *\n * @param environment - The Otim environment (local | sandbox | production)\n * @returns The default chain for the environment\n */\nexport const getDefaultChain = (environment: OtimEnvironment) => {\n  return environment === OtimEnvironment.Production ? base : baseSepolia;\n};\n\nexport type SupportedChainName = keyof typeof allSupportedChains;\nexport type MainnetChainName = keyof typeof supportedChains.mainnet;\nexport type TestnetChainName = keyof typeof supportedChains.testnet;\n","import type { Optional } from \"@otim/utils/helpers\";\nimport type { Chain } from \"viem/chains\";\n\nimport {\n  arbitrum,\n  base,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n  unichain,\n} from \"viem/chains\";\n\nexport const mainnetChains = [\n  mainnet,\n  base,\n  arbitrum,\n  optimism,\n  bsc,\n  unichain,\n  polygon,\n] as const;\n\nexport const mainnetChainsById = new Map<number, Chain>(\n  mainnetChains.map((chain) => [chain.id, chain]),\n);\n\nexport function getMainnetChain(chainId: number): Optional<Chain> {\n  return mainnetChainsById.get(chainId);\n}\n\nexport function isMainnetChain(chainId: number): boolean {\n  return mainnetChainsById.has(chainId);\n}\n","import type { Optional } from \"@otim/utils/helpers\";\nimport type { Chain } from \"viem/chains\";\n\nimport {\n  baseSepolia,\n  sepolia,\n} from \"viem/chains\";\n\nexport const testnetChains = [\n  sepolia,\n  baseSepolia,\n] as const;\n\nexport const testnetChainsById = new Map<number, Chain>(\n  testnetChains.map((chain) => [chain.id, chain]),\n);\n\nexport function getTestnetChain(chainId: number): Optional<Chain> {\n  return testnetChainsById.get(chainId);\n}\n\nexport function isTestnetChain(chainId: number): boolean {\n  return testnetChainsById.has(chainId);\n}\n","import type { ChainTokenAddresses } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\nimport type { Address } from \"@otim/utils/schemas\";\n\nimport {\n  baseSepolia,\n  bscTestnet,\n  polygonAmoy,\n  sepolia,\n  unichain,\n} from \"viem/chains\";\n\nimport { DEFAULT_ADDRESS } from \"../../helpers\";\nimport { pecorinoHost, pecorinoSignet } from \"../config/custom-chains\";\n\n/**\n * Token addresses for testnets and custom chains.\n * Mainnets use JSON token lists (see token-lists.ts).\n */\nexport const testnetTokenAddresses: Record<number, ChainTokenAddresses> = {\n  // TESTNETS\n  [sepolia.id]: {\n    ETH: DEFAULT_ADDRESS,\n    WETH: \"0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14\",\n    USDC: \"0x1c7d4b196cb0c7b01d743fbc6116a902379c7238\",\n    USDT: \"0xaa8e23fb1079ea71e0a56f48a2aa51851d8433d0\",\n  },\n  [baseSepolia.id]: {\n    ETH: DEFAULT_ADDRESS,\n    WETH: \"0x4200000000000000000000000000000000000006\",\n    USDC: \"0x036CbD53842c5426634e7929541eC2318f3dCF7e\",\n    USDT: \"0x323e78f944A9a1FcF3a10efcC5319DBb0bB6e673\",\n  },\n  [bscTestnet.id]: {\n    BNB: DEFAULT_ADDRESS,\n    WBNB: \"0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd\",\n    USDC: \"0x64544969ed7EBf5f083679233325356EbE738930\",\n  },\n  [polygonAmoy.id]: {\n    POL: DEFAULT_ADDRESS,\n    WMATIC: \"0x360ad4f9a9A8EFe9A8DCB5f461c4Cc1047E1Dcf9\",\n    USDC: \"0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582\",\n  },\n  // CUSTOM CHAINS\n  [unichain.id]: {\n    ETH: DEFAULT_ADDRESS,\n    WETH: \"0x4200000000000000000000000000000000000006\",\n    USDC: \"0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA\",\n  },\n  [pecorinoSignet.id]: {\n    USD: DEFAULT_ADDRESS,\n  },\n  [pecorinoHost.id]: {\n    ETH: DEFAULT_ADDRESS,\n  },\n};\n\nexport function getTestnetTokenAddresses(chainId: number): ChainTokenAddresses {\n  return testnetTokenAddresses[chainId] || {};\n}\n\nexport function getTestnetTokenAddress(\n  chainId: number,\n  symbol: string,\n): Optional<Address> {\n  const addresses = getTestnetTokenAddresses(chainId);\n  return addresses[symbol.toUpperCase()];\n}\n\nexport function isTestnetTokenSupported(\n  chainId: number,\n  symbol: string,\n): boolean {\n  return getTestnetTokenAddress(chainId, symbol) !== undefined;\n}\n\n\n","import type { TokenMetadata } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\n\n/**\n * Token metadata for testnets and custom chains.\n * Mainnets use JSON token lists (see token-lists.ts).\n */\nexport const testnetTokenMetadata: Record<string, TokenMetadata> = {\n  USD: {\n    name: \"US Dollar\",\n    symbol: \"USD\",\n    decimals: 18,\n    logoURI: \"/tokens/usd.svg\",\n  },\n  ETH: {\n    name: \"Ethereum\",\n    symbol: \"ETH\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\",\n  },\n  WETH: {\n    name: \"Wrapped Ether\",\n    symbol: \"WETH\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\",\n    type: \"ERC20\",\n  },\n  USDC: {\n    name: \"USDC\",\n    symbol: \"USDC\",\n    decimals: 6,\n    logoURI:\n      \"https://assets-cdn.trustwallet.com/blockchains/ethereum/assets/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48/logo.png\",\n    type: \"ERC20\",\n  },\n  USDT: {\n    name: \"Tether USD\",\n    symbol: \"USDT\",\n    decimals: 6,\n    logoURI:\n      \"https://assets-cdn.trustwallet.com/blockchains/ethereum/assets/0xdAC17F958D2ee523a2206206994597C13D831ec7/logo.png\",\n    type: \"ERC20\",\n  },\n  BNB: {\n    name: \"BNB\",\n    symbol: \"BNB\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add BNB logo\n    type: \"ERC20\",\n  },\n  WBNB: {\n    name: \"Wrapped BNB\",\n    symbol: \"WBNB\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add BNB logo\n    type: \"ERC20\",\n  },\n  POL: {\n    name: \"Polygon\",\n    symbol: \"POL\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add POL logo\n    type: \"ERC20\",\n  },\n  WPOL: {\n    name: \"Wrapped Polygon\",\n    symbol: \"WPOL\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add POL logo\n    type: \"ERC20\",\n  },\n  WMATIC: {\n    name: \"Wrapped MATIC\",\n    symbol: \"WMATIC\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add MATIC logo\n    type: \"ERC20\",\n  },\n};\n\nexport function getTestnetTokenMetadata(symbol: string): Optional<TokenMetadata> {\n  return testnetTokenMetadata[symbol.toUpperCase()];\n}\n\n\n","","","","","","","import type { ChainToken } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\nimport type { Address } from \"@otim/utils/schemas\";\n\nimport {\n  arbitrum,\n  base,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n} from \"viem/chains\";\n\n// Static imports - these will be inlined at build time by the bundler\nimport arbitrumTokens from \"./arbitrum-token-list.json\";\nimport baseTokens from \"./base-token-list.json\";\nimport bscTokens from \"./bsc-token-list.json\";\nimport ethereumTokens from \"./ethereum-token-list.json\";\nimport optimismTokens from \"./optimism-token-list.json\";\nimport polygonTokens from \"./polygon-token-list.json\";\n\n/**\n * Token data from CoinGecko-generated JSON files\n */\nexport interface TokenListEntry {\n  chainId: number;\n  address: string;\n  symbol: string;\n  name: string;\n  coingeckoId: string;\n  marketCapRank: number;\n  logoUrl: string;\n  decimals: number;\n}\n\n/**\n * Chain ID to token list mapping\n */\nconst CHAIN_TOKEN_LISTS: Record<number, TokenListEntry[]> = {\n  [mainnet.id]: ethereumTokens as TokenListEntry[],\n  [base.id]: baseTokens as TokenListEntry[],\n  [arbitrum.id]: arbitrumTokens as TokenListEntry[],\n  [optimism.id]: optimismTokens as TokenListEntry[],\n  [bsc.id]: bscTokens as TokenListEntry[],\n  [polygon.id]: polygonTokens as TokenListEntry[],\n};\n\n/**\n * Convert TokenListEntry to ChainToken format\n */\nfunction toChainToken(entry: TokenListEntry): ChainToken {\n  // Decimals are always present in the JSON token lists\n  const decimals = entry.decimals;\n  \n  return {\n    chainId: entry.chainId,\n    address: entry.address as Address,\n    symbol: entry.symbol,\n    name: entry.name,\n    decimals,\n    logoURI: entry.logoUrl,\n    type: \"ERC20\",\n  };\n}\n\n/**\n * Load token list for a specific chain\n */\nexport function loadTokenList(chainId: number): TokenListEntry[] {\n  return CHAIN_TOKEN_LISTS[chainId] || [];\n}\n\n/**\n * Get token list as ChainToken[] for a specific chain\n */\nexport function getTokenListTokens(chainId: number): ChainToken[] {\n  const entries = loadTokenList(chainId);\n  return entries.map(toChainToken);\n}\n\n/**\n * Get a token from the token list by address\n */\nexport function getTokenListTokenByAddress(\n  chainId: number,\n  address: string,\n): Optional<ChainToken> {\n  const entries = loadTokenList(chainId);\n  const entry = entries.find(\n    (t) => t.address.toLowerCase() === address.toLowerCase(),\n  );\n  return entry ? toChainToken(entry) : undefined;\n}\n\n/**\n * Get a token from the token list by symbol\n */\nexport function getTokenListTokenBySymbol(\n  chainId: number,\n  symbol: string,\n): Optional<ChainToken> {\n  const entries = loadTokenList(chainId);\n  const entry = entries.find(\n    (t) => t.symbol.toUpperCase() === symbol.toUpperCase(),\n  );\n  return entry ? toChainToken(entry) : undefined;\n}\n\n/**\n * Get raw token list entries (with CoinGecko metadata)\n */\nexport function getTokenListEntries(chainId: number): TokenListEntry[] {\n  return loadTokenList(chainId);\n}\n\n/**\n * Check if a chain has a token list available\n */\nexport function hasTokenList(chainId: number): boolean {\n  return chainId in CHAIN_TOKEN_LISTS;\n}\n","import type { ChainToken } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\n\nimport {\n  getTestnetTokenAddress,\n  getTestnetTokenAddresses,\n} from \"./testnet-token-addresses\";\nimport { getTestnetTokenMetadata } from \"./testnet-token-metadata\";\nimport {\n  getTokenListTokenBySymbol,\n  getTokenListTokens,\n  hasTokenList,\n} from \"./token-lists\";\n\n/**\n * Get all tokens for a chain.\n * \n * Mainnets (Ethereum, Base, Arbitrum, Optimism, BSC, Polygon):\n * - Uses comprehensive JSON token lists (top 50 by market cap)\n * \n * Testnets and custom chains:\n * - Uses hardcoded token addresses and metadata\n */\nexport function getChainTokens(chainId: number): ChainToken[] {\n  // Use JSON token lists for supported mainnets\n  if (hasTokenList(chainId)) {\n    return getTokenListTokens(chainId);\n  }\n\n  // Use testnet/custom chain system\n  const addresses = getTestnetTokenAddresses(chainId);\n  const tokens: ChainToken[] = [];\n\n  for (const [symbol, address] of Object.entries(addresses)) {\n    const metadata = getTestnetTokenMetadata(symbol);\n\n    if (metadata && address) {\n      tokens.push({ ...metadata, address, chainId });\n    }\n  }\n\n  return tokens;\n}\n\nexport function getChainToken(\n  chainId: number,\n  symbol: string,\n): Optional<ChainToken> {\n  const tokens = getChainTokens(chainId);\n  return tokens.find(\n    (token) => token.symbol.toUpperCase() === symbol.toUpperCase(),\n  );\n}\n\nexport function getChainTokenByAddress(\n  chainId: number,\n  address: string,\n): Optional<ChainToken> {\n  const tokens = getChainTokens(chainId);\n  return tokens.find(\n    (token) => token.address.toLowerCase() === address.toLowerCase(),\n  );\n}\n\n/**\n * Get token address by symbol for a chain.\n * Works for both mainnets (from JSON lists) and testnets (from hardcoded addresses).\n */\nexport function getTokenAddress(\n  chainId: number,\n  symbol: string,\n): Optional<string> {\n  // Try JSON lists first (mainnets)\n  if (hasTokenList(chainId)) {\n    const token = getTokenListTokenBySymbol(chainId, symbol);\n    return token?.address;\n  }\n\n  // Fallback to testnet addresses\n  return getTestnetTokenAddress(chainId, symbol);\n}\n\n/**\n * Get all token addresses for a chain as a symbol -> address mapping.\n * Compatible with the old tokenAddresses structure for backward compatibility.\n */\nexport function getTokenAddresses(\n  chainId: number,\n): Record<string, string> {\n  const tokens = getChainTokens(chainId);\n  const addresses: Record<string, string> = {};\n\n  for (const token of tokens) {\n    addresses[token.symbol.toUpperCase()] = token.address;\n  }\n\n  return addresses;\n}\n","import type { ChainConfig } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\nimport type { Chain } from \"viem/chains\";\n\nimport { mainnetChains } from \"./mainnet-chains\";\nimport { testnetChains } from \"./testnet-chains\";\nimport { getChainTokens } from \"../tokens/chain-tokens\";\n\nexport const allChains = [...mainnetChains, ...testnetChains] as const;\n\nexport type SupportedChainId = (typeof allChains)[number][\"id\"];\n\nexport const chainById = new Map<number, Chain>(\n  allChains.map((chain) => [chain.id, chain]),\n);\n\nexport function getChainById(chainId: number): Optional<Chain> {\n  return chainById.get(chainId);\n}\n\nexport function getChainConfig(chainId: number): Optional<ChainConfig> {\n  const chain = getChainById(chainId);\n  if (!chain) return undefined;\n\n  return {\n    chain,\n    isTestnet: chain.testnet ?? false,\n    tokens: getChainTokens(chain.id),\n  };\n}\n\nexport function getMainnetChains(): ChainConfig[] {\n  return mainnetChains.map((chain) => ({\n    chain,\n    isTestnet: false,\n    tokens: getChainTokens(chain.id),\n  }));\n}\n\nexport function getTestnetChains(): ChainConfig[] {\n  return testnetChains.map((chain) => ({\n    chain,\n    isTestnet: true,\n    tokens: getChainTokens(chain.id),\n  }));\n}\n\nexport function getAllChains(): ChainConfig[] {\n  return [...getMainnetChains(), ...getTestnetChains()];\n}\n\nexport function isSupportedChain(chainId: number): boolean {\n  return chainById.has(chainId);\n}\n","import type { ChainToken } from \"../types\";\n\nexport function filterTokens(\n  tokens: ChainToken[],\n  allowedSymbols: string[],\n  disabledSymbols: string[],\n): ChainToken[] {\n  let result = tokens;\n\n  if (disabledSymbols.length > 0) {\n    result = result.filter(\n      (token) => !disabledSymbols.includes(token.symbol.toUpperCase()),\n    );\n  }\n\n  if (allowedSymbols && allowedSymbols.length > 0) {\n    result = result.filter((token) =>\n      allowedSymbols.includes(token.symbol.toUpperCase()),\n    );\n  }\n\n  return result;\n}\n","import type { ChainToken } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\n\nexport interface TokenMaps {\n  byAddress: Map<string, ChainToken>;\n  bySymbol: Map<string, ChainToken>;\n}\n\nexport function createTokenMaps(tokens: ChainToken[]): TokenMaps {\n  const byAddress = new Map<string, ChainToken>();\n  const bySymbol = new Map<string, ChainToken>();\n\n  tokens.forEach((token) => {\n    byAddress.set(token.address.toLowerCase(), token);\n    bySymbol.set(token.symbol.toLowerCase(), token);\n  });\n\n  return { byAddress, bySymbol };\n}\n\nexport function getTokenByAddress(\n  maps: TokenMaps,\n  address: string,\n): Optional<ChainToken> {\n  if (!address) return undefined;\n  return maps.byAddress.get(address.toLowerCase());\n}\n\nexport function getTokenBySymbol(\n  maps: TokenMaps,\n  symbol: string,\n): Optional<ChainToken> {\n  if (!symbol) return undefined;\n  return maps.bySymbol.get(symbol.toLowerCase());\n}\n","/**\n * List of supported stablecoin symbols\n */\nconst stablecoinSymbols = [\"USDC\", \"USDT\"] as const;\n\n/**\n * Checks if a token symbol is a stablecoin\n * @param symbol - Token symbol to check (e.g., \"USDC\", \"ETH\")\n * @returns true if the symbol is a recognized stablecoin\n */\nexport function isStablecoin(symbol: string | string[]): boolean {\n  if (typeof symbol === \"string\") {\n    return stablecoinSymbols.includes(\n      symbol as (typeof stablecoinSymbols)[number],\n    );\n  }\n\n  return symbol.every((s) =>\n    stablecoinSymbols.includes(s as (typeof stablecoinSymbols)[number]),\n  );\n}\n","import type { Optional } from \"@otim/utils/helpers\";\n\n/**\n * Mapping between chain ID numbers (used internally by otim) and\n * Lambda API chain ID strings (used by Lambda's API endpoints).\n *\n * Lambda uses string identifiers for chains while we use numeric chain IDs\n * from viem/wagmi. This map provides bidirectional conversion.\n */\n\n/**\n * Map from numeric chain ID to Lambda chain ID string\n */\nexport const CHAIN_ID_TO_LAMBDA_ID: Record<number, string> = {\n  /* Mainnet chains */\n  1: \"ethereum\",\n  8453: \"base\",\n  42161: \"arbitrum\",\n  10: \"optimism\",\n  56: \"binance-smart-chain\",\n  130: \"unichain\",\n  137: \"polygon\",\n} as const;\n\n/**\n * Map from Lambda chain ID string to numeric chain ID\n */\nexport const LAMBDA_ID_TO_CHAIN_ID: Record<string, number> = {\n  ethereum: 1,\n  base: 8453,\n  arbitrum: 42161,\n  optimism: 10,\n  \"binance-smart-chain\": 56,\n  unichain: 130,\n  polygon: 137,\n} as const;\n\n/**\n * Convert a numeric chain ID to Lambda's chain ID string\n * @param chainId - The numeric chain ID\n * @returns The Lambda chain ID string, or undefined if not supported by Lambda\n */\n\nexport function chainIdToLambdaId(chainId: number): Optional<string> {\n  return CHAIN_ID_TO_LAMBDA_ID[chainId];\n}\n\n/**\n * Convert a Lambda chain ID string to numeric chain ID\n * @param lambdaId - The Lambda chain ID string\n * @returns The numeric chain ID, or undefined if not recognized\n */\nexport function lambdaIdToChainId(lambdaId: string): Optional<number> {\n  return LAMBDA_ID_TO_CHAIN_ID[lambdaId];\n}\n\n/**\n * Check if a chain ID is supported by Lambda\n * @param chainId - The numeric chain ID to check\n * @returns true if the chain is supported by Lambda\n */\nexport function isLambdaSupportedChain(chainId: number): boolean {\n  return chainId in CHAIN_ID_TO_LAMBDA_ID;\n}\n\n/**\n * Get all chain IDs supported by Lambda\n * @returns Array of numeric chain IDs that are supported by Lambda\n */\nexport function getLambdaSupportedChainIds(): number[] {\n  return Object.keys(CHAIN_ID_TO_LAMBDA_ID).map(Number);\n}\n\n/**\n * Get all Lambda chain ID strings\n * @returns Array of Lambda chain ID strings\n */\nexport function getLambdaChainIds(): string[] {\n  return Object.values(CHAIN_ID_TO_LAMBDA_ID);\n}\n","import type { Optional } from \"@otim/utils/helpers\";\n\nimport {\n  arbitrum,\n  avalanche,\n  base,\n  baseSepolia,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n  polygonAmoy,\n  sepolia,\n  unichain,\n} from \"viem/chains\";\n\nimport { pecorinoHost, pecorinoSignet } from \"./custom-chains\";\n\nexport interface ChainMetadata {\n  name: string;\n  iconUrl?: string;\n  // Add other chain metadata fields as needed\n}\n\n/**\n * Chain metadata including icon URLs and display names.\n * Icon URLs can be IPFS hashes or HTTP URLs.\n * \n * To get chain icon URLs, you can:\n * 1. Extract from Lambda portfolio API (chain_icon_url field)\n * 2. Use chain explorer APIs\n * 3. Use trusted sources like ChainList\n */\nexport const chainMetadata: Record<number, ChainMetadata> = {\n  [mainnet.id]: {\n    name: \"Ethereum\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/ethereum.png\",\n  },\n  [base.id]: {\n    name: \"Base\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/base.png\",\n  },\n  [arbitrum.id]: {\n    name: \"Arbitrum One\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/arbitrum.png\",\n  },\n  [optimism.id]: {\n    name: \"OP Mainnet\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/optimism.png\",\n  },\n  [bsc.id]: {\n    name: \"Binance Smart Chain\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/binance-smart-chain.png\",\n  },\n  [polygon.id]: {\n    name: \"Polygon\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/polygon.png\",\n  },\n  [avalanche.id]: {\n    name: \"Avalanche\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/avalanche.png\",\n  },\n  [unichain.id]: {\n    name: \"Unichain\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/unichain.png\",\n  },\n  [sepolia.id]: {\n    name: \"Sepolia\",\n  },\n  [baseSepolia.id]: {\n    name: \"Base Sepolia\",\n  },\n  [polygonAmoy.id]: {\n    name: \"Polygon Amoy\",\n  },\n  [pecorinoSignet.id]: {\n    name: \"Pecorino Signet\",\n  },\n  [pecorinoHost.id]: {\n    name: \"Pecorino Host\",\n  },\n};\n\n/**\n * Get chain metadata by chain ID\n * @param chainId - The numeric chain ID\n * @returns Chain metadata or undefined if not found\n */\nexport function getChainMetadata(chainId: number): Optional<ChainMetadata> {\n  return chainMetadata[chainId];\n}\n\n/**\n * Get chain icon URL by chain ID\n * @param chainId - The numeric chain ID\n * @returns Chain icon URL or undefined if not found\n */\nexport function getChainIconUrl(chainId: number): Optional<string> {\n  return chainMetadata[chainId]?.iconUrl;\n}\n\n/**\n * Get chain display name by chain ID\n * @param chainId - The numeric chain ID\n * @returns Chain name or undefined if not found\n */\nexport function getChainDisplayName(chainId: number): Optional<string> {\n  return chainMetadata[chainId]?.name;\n}\n\n"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"index.js","names":["OtimEnvironment","base","baseSepolia","mainnet","base","arbitrum","optimism","bsc","unichain","polygon","sepolia","baseSepolia","sepolia","DEFAULT_ADDRESS","baseSepolia","bscTestnet","polygonAmoy","unichain","mainnet","ethereumTokens","base","baseTokens","arbitrum","arbitrumTokens","optimism","optimismTokens","bsc","bscTokens","polygon","polygonTokens","mainnet","base","arbitrum","optimism","bsc","polygon","avalanche","unichain","sepolia","baseSepolia","polygonAmoy"],"sources":["../../src/chains/config/custom-chains.ts","../../src/chains/config/all-chains.ts","../../src/chains/config/mainnet-chains.ts","../../src/chains/config/testnet-chains.ts","../../src/chains/tokens/testnet-token-addresses.ts","../../src/chains/tokens/testnet-token-metadata.ts","../../src/chains/tokens/arbitrum-token-list.json","../../src/chains/tokens/base-token-list.json","../../src/chains/tokens/bsc-token-list.json","../../src/chains/tokens/ethereum-token-list.json","../../src/chains/tokens/optimism-token-list.json","../../src/chains/tokens/polygon-token-list.json","../../src/chains/tokens/token-lists.ts","../../src/chains/tokens/chain-tokens.ts","../../src/chains/config/supported-chains.ts","../../src/chains/utils/filter-tokens.ts","../../src/chains/utils/token-maps.ts","../../src/chains/utils/stablecoin.ts","../../src/chains/lambda/chain-mapping.ts","../../src/chains/config/chain-metadata.ts"],"sourcesContent":["import type { Chain } from \"viem/chains\";\n\nexport const pecorinoSignet = {\n  id: 14174,\n  name: \"Pecorino Signet\",\n  nativeCurrency: {\n    decimals: 18,\n    name: \"USD\",\n    symbol: \"USD\",\n  },\n  rpcUrls: {\n    default: { http: [\"https://rpc.pecorino.signet.sh/\"] },\n    public: { http: [\"https://rpc.pecorino.signet.sh/\"] },\n  },\n  blockExplorers: {\n    default: {\n      name: \"Pecorino Signet Explorer\",\n      url: \"https://explorer.pecorino.signet.sh/\",\n    },\n  },\n  testnet: true,\n} as const satisfies Chain;\n\nexport const pecorinoHost = {\n  id: 3151908,\n  name: \"Pecorino Host\",\n  nativeCurrency: {\n    decimals: 18,\n    name: \"ETH\",\n    symbol: \"ETH\",\n  },\n  rpcUrls: {\n    default: { http: [\"https://host-rpc.pecorino.signet.sh/\"] },\n    public: { http: [\"https://host-rpc.pecorino.signet.sh/\"] },\n  },\n  blockExplorers: {\n    default: {\n      name: \"Pecorino Host Explorer\",\n      url: \"https://explorer-host.pecorino.signet.sh/\",\n    },\n  },\n  testnet: true,\n} as const satisfies Chain;\n","import {\n  arbitrum,\n  base,\n  baseSepolia,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n  polygonAmoy,\n  sepolia,\n  unichain,\n} from \"viem/chains\";\n\nimport { pecorinoHost, pecorinoSignet } from \"./custom-chains\";\nimport { OtimEnvironment } from \"../../config/api-urls\";\n\nexport const supportedChains = {\n  mainnet: {\n    mainnet,\n    base,\n  },\n  testnet: {\n    sepolia,\n    baseSepolia,\n  },\n} as const;\n\nexport const allSupportedChains = {\n  mainnet,\n  base,\n  arbitrum,\n  optimism,\n  bsc,\n  unichain,\n  polygon,\n  sepolia,\n  baseSepolia,\n  polygonAmoy,\n  pecorinoHost,\n  pecorinoSignet,\n} as const;\n\n/**\n * Get the default chain ID based on the provided environment.\n * Production: Base mainnet (8453)\n * Local/Sandbox: Base Sepolia (84532)\n *\n * @param environment - The Otim environment (local | sandbox | production)\n * @returns The default chain ID for the environment\n */\nexport const getDefaultChainId = (environment: OtimEnvironment): number => {\n  return environment === OtimEnvironment.Production ? base.id : baseSepolia.id;\n};\n\n/**\n * Get the default chain based on the provided environment.\n * Production: Base mainnet\n * Local/Sandbox: Base Sepolia\n *\n * @param environment - The Otim environment (local | sandbox | production)\n * @returns The default chain for the environment\n */\nexport const getDefaultChain = (environment: OtimEnvironment) => {\n  return environment === OtimEnvironment.Production ? base : baseSepolia;\n};\n\nexport type SupportedChainName = keyof typeof allSupportedChains;\nexport type MainnetChainName = keyof typeof supportedChains.mainnet;\nexport type TestnetChainName = keyof typeof supportedChains.testnet;\n","import type { Optional } from \"@otim/utils/helpers\";\nimport type { Chain } from \"viem/chains\";\n\nimport {\n  arbitrum,\n  base,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n  unichain,\n} from \"viem/chains\";\n\nexport const mainnetChains = [\n  mainnet,\n  base,\n  arbitrum,\n  optimism,\n  bsc,\n  unichain,\n  polygon,\n] as const;\n\nexport const mainnetChainsById = new Map<number, Chain>(\n  mainnetChains.map((chain) => [chain.id, chain]),\n);\n\nexport function getMainnetChain(chainId: number): Optional<Chain> {\n  return mainnetChainsById.get(chainId);\n}\n\nexport function isMainnetChain(chainId: number): boolean {\n  return mainnetChainsById.has(chainId);\n}\n","import type { Optional } from \"@otim/utils/helpers\";\nimport type { Chain } from \"viem/chains\";\n\nimport {\n  baseSepolia,\n  sepolia,\n} from \"viem/chains\";\n\nexport const testnetChains = [\n  sepolia,\n  baseSepolia,\n] as const;\n\nexport const testnetChainsById = new Map<number, Chain>(\n  testnetChains.map((chain) => [chain.id, chain]),\n);\n\nexport function getTestnetChain(chainId: number): Optional<Chain> {\n  return testnetChainsById.get(chainId);\n}\n\nexport function isTestnetChain(chainId: number): boolean {\n  return testnetChainsById.has(chainId);\n}\n","import type { ChainTokenAddresses } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\nimport type { Address } from \"@otim/utils/schemas\";\n\nimport {\n  baseSepolia,\n  bscTestnet,\n  polygonAmoy,\n  sepolia,\n  unichain,\n} from \"viem/chains\";\n\nimport { DEFAULT_ADDRESS } from \"../../helpers\";\nimport { pecorinoHost, pecorinoSignet } from \"../config/custom-chains\";\n\n/**\n * Token addresses for testnets and custom chains.\n * Mainnets use JSON token lists (see token-lists.ts).\n */\nexport const testnetTokenAddresses: Record<number, ChainTokenAddresses> = {\n  // TESTNETS\n  [sepolia.id]: {\n    ETH: DEFAULT_ADDRESS,\n    WETH: \"0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14\",\n    USDC: \"0x1c7d4b196cb0c7b01d743fbc6116a902379c7238\",\n    USDT: \"0xaa8e23fb1079ea71e0a56f48a2aa51851d8433d0\",\n  },\n  [baseSepolia.id]: {\n    ETH: DEFAULT_ADDRESS,\n    WETH: \"0x4200000000000000000000000000000000000006\",\n    USDC: \"0x036CbD53842c5426634e7929541eC2318f3dCF7e\",\n    USDT: \"0x323e78f944A9a1FcF3a10efcC5319DBb0bB6e673\",\n  },\n  [bscTestnet.id]: {\n    BNB: DEFAULT_ADDRESS,\n    WBNB: \"0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd\",\n    USDC: \"0x64544969ed7EBf5f083679233325356EbE738930\",\n  },\n  [polygonAmoy.id]: {\n    POL: DEFAULT_ADDRESS,\n    WMATIC: \"0x360ad4f9a9A8EFe9A8DCB5f461c4Cc1047E1Dcf9\",\n    USDC: \"0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582\",\n  },\n  // CUSTOM CHAINS\n  [unichain.id]: {\n    ETH: DEFAULT_ADDRESS,\n    WETH: \"0x4200000000000000000000000000000000000006\",\n    USDC: \"0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA\",\n  },\n  [pecorinoSignet.id]: {\n    USD: DEFAULT_ADDRESS,\n  },\n  [pecorinoHost.id]: {\n    ETH: DEFAULT_ADDRESS,\n  },\n};\n\nexport function getTestnetTokenAddresses(chainId: number): ChainTokenAddresses {\n  return testnetTokenAddresses[chainId] || {};\n}\n\nexport function getTestnetTokenAddress(\n  chainId: number,\n  symbol: string,\n): Optional<Address> {\n  const addresses = getTestnetTokenAddresses(chainId);\n  return addresses[symbol.toUpperCase()];\n}\n\nexport function isTestnetTokenSupported(\n  chainId: number,\n  symbol: string,\n): boolean {\n  return getTestnetTokenAddress(chainId, symbol) !== undefined;\n}\n\n\n","import type { TokenMetadata } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\n\n/**\n * Token metadata for testnets and custom chains.\n * Mainnets use JSON token lists (see token-lists.ts).\n */\nexport const testnetTokenMetadata: Record<string, TokenMetadata> = {\n  USD: {\n    name: \"US Dollar\",\n    symbol: \"USD\",\n    decimals: 18,\n    logoURI: \"/tokens/usd.svg\",\n  },\n  ETH: {\n    name: \"Ethereum\",\n    symbol: \"ETH\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\",\n  },\n  WETH: {\n    name: \"Wrapped Ether\",\n    symbol: \"WETH\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\",\n    type: \"ERC20\",\n  },\n  USDC: {\n    name: \"USDC\",\n    symbol: \"USDC\",\n    decimals: 6,\n    logoURI:\n      \"https://assets-cdn.trustwallet.com/blockchains/ethereum/assets/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48/logo.png\",\n    type: \"ERC20\",\n  },\n  USDT: {\n    name: \"Tether USD\",\n    symbol: \"USDT\",\n    decimals: 6,\n    logoURI:\n      \"https://assets-cdn.trustwallet.com/blockchains/ethereum/assets/0xdAC17F958D2ee523a2206206994597C13D831ec7/logo.png\",\n    type: \"ERC20\",\n  },\n  BNB: {\n    name: \"BNB\",\n    symbol: \"BNB\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add BNB logo\n    type: \"ERC20\",\n  },\n  WBNB: {\n    name: \"Wrapped BNB\",\n    symbol: \"WBNB\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add BNB logo\n    type: \"ERC20\",\n  },\n  POL: {\n    name: \"Polygon\",\n    symbol: \"POL\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add POL logo\n    type: \"ERC20\",\n  },\n  WPOL: {\n    name: \"Wrapped Polygon\",\n    symbol: \"WPOL\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add POL logo\n    type: \"ERC20\",\n  },\n  WMATIC: {\n    name: \"Wrapped MATIC\",\n    symbol: \"WMATIC\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add MATIC logo\n    type: \"ERC20\",\n  },\n};\n\nexport function getTestnetTokenMetadata(symbol: string): Optional<TokenMetadata> {\n  return testnetTokenMetadata[symbol.toUpperCase()];\n}\n\n\n","","","","","","","import type { ChainToken } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\nimport type { Address } from \"@otim/utils/schemas\";\n\nimport {\n  arbitrum,\n  base,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n} from \"viem/chains\";\n\n// Static imports - these will be inlined at build time by the bundler\nimport arbitrumTokens from \"./arbitrum-token-list.json\";\nimport baseTokens from \"./base-token-list.json\";\nimport bscTokens from \"./bsc-token-list.json\";\nimport ethereumTokens from \"./ethereum-token-list.json\";\nimport optimismTokens from \"./optimism-token-list.json\";\nimport polygonTokens from \"./polygon-token-list.json\";\n\n/**\n * Token data from CoinGecko-generated JSON files\n */\nexport interface TokenListEntry {\n  chainId: number;\n  address: string;\n  symbol: string;\n  name: string;\n  coingeckoId: string;\n  marketCapRank: number;\n  logoUrl: string;\n  decimals: number;\n}\n\n/**\n * Chain ID to token list mapping\n */\nconst CHAIN_TOKEN_LISTS: Record<number, TokenListEntry[]> = {\n  [mainnet.id]: ethereumTokens as TokenListEntry[],\n  [base.id]: baseTokens as TokenListEntry[],\n  [arbitrum.id]: arbitrumTokens as TokenListEntry[],\n  [optimism.id]: optimismTokens as TokenListEntry[],\n  [bsc.id]: bscTokens as TokenListEntry[],\n  [polygon.id]: polygonTokens as TokenListEntry[],\n};\n\n/**\n * Convert TokenListEntry to ChainToken format\n */\nfunction toChainToken(entry: TokenListEntry): ChainToken {\n  // Decimals are always present in the JSON token lists\n  const decimals = entry.decimals;\n  \n  return {\n    chainId: entry.chainId,\n    address: entry.address as Address,\n    symbol: entry.symbol,\n    name: entry.name,\n    decimals,\n    logoURI: entry.logoUrl,\n    type: \"ERC20\",\n  };\n}\n\n/**\n * Load token list for a specific chain\n */\nexport function loadTokenList(chainId: number): TokenListEntry[] {\n  return CHAIN_TOKEN_LISTS[chainId] || [];\n}\n\n/**\n * Get token list as ChainToken[] for a specific chain\n */\nexport function getTokenListTokens(chainId: number): ChainToken[] {\n  const entries = loadTokenList(chainId);\n  return entries.map(toChainToken);\n}\n\n/**\n * Get a token from the token list by address\n */\nexport function getTokenListTokenByAddress(\n  chainId: number,\n  address: string,\n): Optional<ChainToken> {\n  const entries = loadTokenList(chainId);\n  const entry = entries.find(\n    (t) => t.address.toLowerCase() === address.toLowerCase(),\n  );\n  return entry ? toChainToken(entry) : undefined;\n}\n\n/**\n * Get a token from the token list by symbol\n */\nexport function getTokenListTokenBySymbol(\n  chainId: number,\n  symbol: string,\n): Optional<ChainToken> {\n  const entries = loadTokenList(chainId);\n  const entry = entries.find(\n    (t) => t.symbol.toUpperCase() === symbol.toUpperCase(),\n  );\n  return entry ? toChainToken(entry) : undefined;\n}\n\n/**\n * Get raw token list entries (with CoinGecko metadata)\n */\nexport function getTokenListEntries(chainId: number): TokenListEntry[] {\n  return loadTokenList(chainId);\n}\n\n/**\n * Check if a chain has a token list available\n */\nexport function hasTokenList(chainId: number): boolean {\n  return chainId in CHAIN_TOKEN_LISTS;\n}\n","import type { ChainToken } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\n\nimport {\n  getTestnetTokenAddress,\n  getTestnetTokenAddresses,\n} from \"./testnet-token-addresses\";\nimport { getTestnetTokenMetadata } from \"./testnet-token-metadata\";\nimport {\n  getTokenListTokenBySymbol,\n  getTokenListTokens,\n  hasTokenList,\n} from \"./token-lists\";\n\n/**\n * Get all tokens for a chain.\n * \n * Mainnets (Ethereum, Base, Arbitrum, Optimism, BSC, Polygon):\n * - Uses comprehensive JSON token lists (top 50 by market cap)\n * \n * Testnets and custom chains:\n * - Uses hardcoded token addresses and metadata\n */\nexport function getChainTokens(chainId: number): ChainToken[] {\n  // Use JSON token lists for supported mainnets\n  if (hasTokenList(chainId)) {\n    return getTokenListTokens(chainId);\n  }\n\n  // Use testnet/custom chain system\n  const addresses = getTestnetTokenAddresses(chainId);\n  const tokens: ChainToken[] = [];\n\n  for (const [symbol, address] of Object.entries(addresses)) {\n    const metadata = getTestnetTokenMetadata(symbol);\n\n    if (metadata && address) {\n      tokens.push({ ...metadata, address, chainId });\n    }\n  }\n\n  return tokens;\n}\n\nexport function getChainToken(\n  chainId: number,\n  symbol: string,\n): Optional<ChainToken> {\n  const tokens = getChainTokens(chainId);\n  return tokens.find(\n    (token) => token.symbol.toUpperCase() === symbol.toUpperCase(),\n  );\n}\n\nexport function getChainTokenByAddress(\n  chainId: number,\n  address: string,\n): Optional<ChainToken> {\n  const tokens = getChainTokens(chainId);\n  return tokens.find(\n    (token) => token.address.toLowerCase() === address.toLowerCase(),\n  );\n}\n\n/**\n * Get token address by symbol for a chain.\n * Works for both mainnets (from JSON lists) and testnets (from hardcoded addresses).\n */\nexport function getTokenAddress(\n  chainId: number,\n  symbol: string,\n): Optional<string> {\n  // Try JSON lists first (mainnets)\n  if (hasTokenList(chainId)) {\n    const token = getTokenListTokenBySymbol(chainId, symbol);\n    return token?.address;\n  }\n\n  // Fallback to testnet addresses\n  return getTestnetTokenAddress(chainId, symbol);\n}\n\n/**\n * Get all token addresses for a chain as a symbol -> address mapping.\n * Compatible with the old tokenAddresses structure for backward compatibility.\n */\nexport function getTokenAddresses(\n  chainId: number,\n): Record<string, string> {\n  const tokens = getChainTokens(chainId);\n  const addresses: Record<string, string> = {};\n\n  for (const token of tokens) {\n    addresses[token.symbol.toUpperCase()] = token.address;\n  }\n\n  return addresses;\n}\n","import type { ChainConfig } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\nimport type { Chain } from \"viem/chains\";\n\nimport { mainnetChains } from \"./mainnet-chains\";\nimport { testnetChains } from \"./testnet-chains\";\nimport { getChainTokens } from \"../tokens/chain-tokens\";\n\nexport const allChains = [...mainnetChains, ...testnetChains] as const;\n\nexport type SupportedChainId = (typeof allChains)[number][\"id\"];\n\nexport const chainById = new Map<number, Chain>(\n  allChains.map((chain) => [chain.id, chain]),\n);\n\nexport function getChainById(chainId: number): Optional<Chain> {\n  return chainById.get(chainId);\n}\n\nexport function getChainConfig(chainId: number): Optional<ChainConfig> {\n  const chain = getChainById(chainId);\n  if (!chain) return undefined;\n\n  return {\n    chain,\n    isTestnet: chain.testnet ?? false,\n    tokens: getChainTokens(chain.id),\n  };\n}\n\nexport function getMainnetChains(): ChainConfig[] {\n  return mainnetChains.map((chain) => ({\n    chain,\n    isTestnet: false,\n    tokens: getChainTokens(chain.id),\n  }));\n}\n\nexport function getTestnetChains(): ChainConfig[] {\n  return testnetChains.map((chain) => ({\n    chain,\n    isTestnet: true,\n    tokens: getChainTokens(chain.id),\n  }));\n}\n\nexport function getAllChains(): ChainConfig[] {\n  return [...getMainnetChains(), ...getTestnetChains()];\n}\n\nexport function isSupportedChain(chainId: number): boolean {\n  return chainById.has(chainId);\n}\n","import type { ChainToken } from \"../types\";\n\nexport function filterTokens(\n  tokens: ChainToken[],\n  allowedSymbols: string[],\n  disabledSymbols: string[],\n): ChainToken[] {\n  let result = tokens;\n\n  if (disabledSymbols.length > 0) {\n    result = result.filter(\n      (token) => !disabledSymbols.includes(token.symbol.toUpperCase()),\n    );\n  }\n\n  if (allowedSymbols && allowedSymbols.length > 0) {\n    result = result.filter((token) =>\n      allowedSymbols.includes(token.symbol.toUpperCase()),\n    );\n  }\n\n  return result;\n}\n","import type { ChainToken } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\n\nexport interface TokenMaps {\n  byAddress: Map<string, ChainToken>;\n  bySymbol: Map<string, ChainToken>;\n}\n\nexport function createTokenMaps(tokens: ChainToken[]): TokenMaps {\n  const byAddress = new Map<string, ChainToken>();\n  const bySymbol = new Map<string, ChainToken>();\n\n  tokens.forEach((token) => {\n    byAddress.set(token.address.toLowerCase(), token);\n    bySymbol.set(token.symbol.toLowerCase(), token);\n  });\n\n  return { byAddress, bySymbol };\n}\n\nexport function getTokenByAddress(\n  maps: TokenMaps,\n  address: string,\n): Optional<ChainToken> {\n  if (!address) return undefined;\n  return maps.byAddress.get(address.toLowerCase());\n}\n\nexport function getTokenBySymbol(\n  maps: TokenMaps,\n  symbol: string,\n): Optional<ChainToken> {\n  if (!symbol) return undefined;\n  return maps.bySymbol.get(symbol.toLowerCase());\n}\n","/**\n * List of supported stablecoin symbols\n */\nconst stablecoinSymbols = [\"USDC\", \"USDT\"] as const;\n\n/**\n * Checks if a token symbol is a stablecoin\n * @param symbol - Token symbol to check (e.g., \"USDC\", \"ETH\")\n * @returns true if the symbol is a recognized stablecoin\n */\nexport function isStablecoin(symbol: string | string[]): boolean {\n  if (typeof symbol === \"string\") {\n    return stablecoinSymbols.includes(\n      symbol as (typeof stablecoinSymbols)[number],\n    );\n  }\n\n  return symbol.every((s) =>\n    stablecoinSymbols.includes(s as (typeof stablecoinSymbols)[number]),\n  );\n}\n","import type { Optional } from \"@otim/utils/helpers\";\n\n/**\n * Mapping between chain ID numbers (used internally by otim) and\n * Lambda API chain ID strings (used by Lambda's API endpoints).\n *\n * Lambda uses string identifiers for chains while we use numeric chain IDs\n * from viem/wagmi. This map provides bidirectional conversion.\n */\n\n/**\n * Map from numeric chain ID to Lambda chain ID string\n */\nexport const CHAIN_ID_TO_LAMBDA_ID: Record<number, string> = {\n  /* Mainnet chains */\n  1: \"ethereum\",\n  8453: \"base\",\n  42161: \"arbitrum\",\n  10: \"optimism\",\n  56: \"binance-smart-chain\",\n  130: \"unichain\",\n  137: \"polygon\",\n} as const;\n\n/**\n * Map from Lambda chain ID string to numeric chain ID\n */\nexport const LAMBDA_ID_TO_CHAIN_ID: Record<string, number> = {\n  ethereum: 1,\n  base: 8453,\n  arbitrum: 42161,\n  optimism: 10,\n  \"binance-smart-chain\": 56,\n  unichain: 130,\n  polygon: 137,\n} as const;\n\n/**\n * Convert a numeric chain ID to Lambda's chain ID string\n * @param chainId - The numeric chain ID\n * @returns The Lambda chain ID string, or undefined if not supported by Lambda\n */\n\nexport function chainIdToLambdaId(chainId: number): Optional<string> {\n  return CHAIN_ID_TO_LAMBDA_ID[chainId];\n}\n\n/**\n * Convert a Lambda chain ID string to numeric chain ID\n * @param lambdaId - The Lambda chain ID string\n * @returns The numeric chain ID, or undefined if not recognized\n */\nexport function lambdaIdToChainId(lambdaId: string): Optional<number> {\n  return LAMBDA_ID_TO_CHAIN_ID[lambdaId];\n}\n\n/**\n * Check if a chain ID is supported by Lambda\n * @param chainId - The numeric chain ID to check\n * @returns true if the chain is supported by Lambda\n */\nexport function isLambdaSupportedChain(chainId: number): boolean {\n  return chainId in CHAIN_ID_TO_LAMBDA_ID;\n}\n\n/**\n * Get all chain IDs supported by Lambda\n * @returns Array of numeric chain IDs that are supported by Lambda\n */\nexport function getLambdaSupportedChainIds(): number[] {\n  return Object.keys(CHAIN_ID_TO_LAMBDA_ID).map(Number);\n}\n\n/**\n * Get all Lambda chain ID strings\n * @returns Array of Lambda chain ID strings\n */\nexport function getLambdaChainIds(): string[] {\n  return Object.values(CHAIN_ID_TO_LAMBDA_ID);\n}\n","import type { Optional } from \"@otim/utils/helpers\";\n\nimport {\n  arbitrum,\n  avalanche,\n  base,\n  baseSepolia,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n  polygonAmoy,\n  sepolia,\n  unichain,\n} from \"viem/chains\";\n\nimport { pecorinoHost, pecorinoSignet } from \"./custom-chains\";\n\nexport interface ChainMetadata {\n  name: string;\n  iconUrl?: string;\n  // Add other chain metadata fields as needed\n}\n\n/**\n * Chain metadata including icon URLs and display names.\n * Icon URLs can be IPFS hashes or HTTP URLs.\n * \n * To get chain icon URLs, you can:\n * 1. Extract from Lambda portfolio API (chain_icon_url field)\n * 2. Use chain explorer APIs\n * 3. Use trusted sources like ChainList\n */\nexport const chainMetadata: Record<number, ChainMetadata> = {\n  [mainnet.id]: {\n    name: \"Ethereum\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/ethereum.png\",\n  },\n  [base.id]: {\n    name: \"Base\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/base.png\",\n  },\n  [arbitrum.id]: {\n    name: \"Arbitrum One\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/arbitrum.png\",\n  },\n  [optimism.id]: {\n    name: \"OP Mainnet\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/optimism.png\",\n  },\n  [bsc.id]: {\n    name: \"Binance Smart Chain\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/binance-smart-chain.png\",\n  },\n  [polygon.id]: {\n    name: \"Polygon\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/polygon.png\",\n  },\n  [avalanche.id]: {\n    name: \"Avalanche\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/avalanche.png\",\n  },\n  [unichain.id]: {\n    name: \"Unichain\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/unichain.png\",\n  },\n  [sepolia.id]: {\n    name: \"Sepolia\",\n  },\n  [baseSepolia.id]: {\n    name: \"Base Sepolia\",\n  },\n  [polygonAmoy.id]: {\n    name: \"Polygon Amoy\",\n  },\n  [pecorinoSignet.id]: {\n    name: \"Pecorino Signet\",\n  },\n  [pecorinoHost.id]: {\n    name: \"Pecorino Host\",\n  },\n};\n\n/**\n * Get chain metadata by chain ID\n * @param chainId - The numeric chain ID\n * @returns Chain metadata or undefined if not found\n */\nexport function getChainMetadata(chainId: number): Optional<ChainMetadata> {\n  return chainMetadata[chainId];\n}\n\n/**\n * Get chain icon URL by chain ID\n * @param chainId - The numeric chain ID\n * @returns Chain icon URL or undefined if not found\n */\nexport function getChainIconUrl(chainId: number): Optional<string> {\n  return chainMetadata[chainId]?.iconUrl;\n}\n\n/**\n * Get chain display name by chain ID\n * @param chainId - The numeric chain ID\n * @returns Chain name or undefined if not found\n */\nexport function getChainDisplayName(chainId: number): Optional<string> {\n  return chainMetadata[chainId]?.name;\n}\n\n"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/chains/index.mjs

@@ -1,5 +1,5 @@
-import { t as OtimEnvironment } from "../api-urls-DJcIKBCy.mjs";
-import { J as DEFAULT_ADDRESS } from "../helpers-BNiSxjGq.mjs";
+import { t as OtimEnvironment } from "../api-urls-B6RnXSRD.mjs";
+import { J as DEFAULT_ADDRESS } from "../zod-CFr-iyX9.mjs";
 import { arbitrum, avalanche, base, baseSepolia, bsc, bscTestnet, mainnet, optimism, polygon, polygonAmoy, sepolia, unichain } from "viem/chains";
 
 //#region src/chains/config/custom-chains.ts
@@ -45,11 +45,7 @@ const pecorinoHost = {
 const supportedChains = {
 	mainnet: {
 		mainnet,
-		base,
-		arbitrum,
-		optimism,
-		bsc,
-		polygon
+		base
 	},
 	testnet: {
 		sepolia,

package/dist/chains/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["ethereumTokens","baseTokens","arbitrumTokens","optimismTokens","bscTokens","polygonTokens"],"sources":["../../src/chains/config/custom-chains.ts","../../src/chains/config/all-chains.ts","../../src/chains/config/mainnet-chains.ts","../../src/chains/config/testnet-chains.ts","../../src/chains/tokens/testnet-token-addresses.ts","../../src/chains/tokens/testnet-token-metadata.ts","../../src/chains/tokens/arbitrum-token-list.json","../../src/chains/tokens/base-token-list.json","../../src/chains/tokens/bsc-token-list.json","../../src/chains/tokens/ethereum-token-list.json","../../src/chains/tokens/optimism-token-list.json","../../src/chains/tokens/polygon-token-list.json","../../src/chains/tokens/token-lists.ts","../../src/chains/tokens/chain-tokens.ts","../../src/chains/config/supported-chains.ts","../../src/chains/utils/filter-tokens.ts","../../src/chains/utils/token-maps.ts","../../src/chains/utils/stablecoin.ts","../../src/chains/lambda/chain-mapping.ts","../../src/chains/config/chain-metadata.ts"],"sourcesContent":["import type { Chain } from \"viem/chains\";\n\nexport const pecorinoSignet = {\n  id: 14174,\n  name: \"Pecorino Signet\",\n  nativeCurrency: {\n    decimals: 18,\n    name: \"USD\",\n    symbol: \"USD\",\n  },\n  rpcUrls: {\n    default: { http: [\"https://rpc.pecorino.signet.sh/\"] },\n    public: { http: [\"https://rpc.pecorino.signet.sh/\"] },\n  },\n  blockExplorers: {\n    default: {\n      name: \"Pecorino Signet Explorer\",\n      url: \"https://explorer.pecorino.signet.sh/\",\n    },\n  },\n  testnet: true,\n} as const satisfies Chain;\n\nexport const pecorinoHost = {\n  id: 3151908,\n  name: \"Pecorino Host\",\n  nativeCurrency: {\n    decimals: 18,\n    name: \"ETH\",\n    symbol: \"ETH\",\n  },\n  rpcUrls: {\n    default: { http: [\"https://host-rpc.pecorino.signet.sh/\"] },\n    public: { http: [\"https://host-rpc.pecorino.signet.sh/\"] },\n  },\n  blockExplorers: {\n    default: {\n      name: \"Pecorino Host Explorer\",\n      url: \"https://explorer-host.pecorino.signet.sh/\",\n    },\n  },\n  testnet: true,\n} as const satisfies Chain;\n","import {\n  arbitrum,\n  base,\n  baseSepolia,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n  polygonAmoy,\n  sepolia,\n  unichain,\n} from \"viem/chains\";\n\nimport { pecorinoHost, pecorinoSignet } from \"./custom-chains\";\nimport { OtimEnvironment } from \"../../config/api-urls\";\n\nexport const supportedChains = {\n  mainnet: {\n    mainnet,\n    base,\n    arbitrum,\n    optimism,\n    bsc,\n    polygon,\n  },\n  testnet: {\n    sepolia,\n    baseSepolia,\n  },\n} as const;\n\nexport const allSupportedChains = {\n  mainnet,\n  base,\n  arbitrum,\n  optimism,\n  bsc,\n  unichain,\n  polygon,\n  sepolia,\n  baseSepolia,\n  polygonAmoy,\n  pecorinoHost,\n  pecorinoSignet,\n} as const;\n\n/**\n * Get the default chain ID based on the provided environment.\n * Production: Base mainnet (8453)\n * Local/Sandbox: Base Sepolia (84532)\n *\n * @param environment - The Otim environment (local | sandbox | production)\n * @returns The default chain ID for the environment\n */\nexport const getDefaultChainId = (environment: OtimEnvironment): number => {\n  return environment === OtimEnvironment.Production ? base.id : baseSepolia.id;\n};\n\n/**\n * Get the default chain based on the provided environment.\n * Production: Base mainnet\n * Local/Sandbox: Base Sepolia\n *\n * @param environment - The Otim environment (local | sandbox | production)\n * @returns The default chain for the environment\n */\nexport const getDefaultChain = (environment: OtimEnvironment) => {\n  return environment === OtimEnvironment.Production ? base : baseSepolia;\n};\n\nexport type SupportedChainName = keyof typeof allSupportedChains;\nexport type MainnetChainName = keyof typeof supportedChains.mainnet;\nexport type TestnetChainName = keyof typeof supportedChains.testnet;\n","import type { Optional } from \"@otim/utils/helpers\";\nimport type { Chain } from \"viem/chains\";\n\nimport {\n  arbitrum,\n  base,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n  unichain,\n} from \"viem/chains\";\n\nexport const mainnetChains = [\n  mainnet,\n  base,\n  arbitrum,\n  optimism,\n  bsc,\n  unichain,\n  polygon,\n] as const;\n\nexport const mainnetChainsById = new Map<number, Chain>(\n  mainnetChains.map((chain) => [chain.id, chain]),\n);\n\nexport function getMainnetChain(chainId: number): Optional<Chain> {\n  return mainnetChainsById.get(chainId);\n}\n\nexport function isMainnetChain(chainId: number): boolean {\n  return mainnetChainsById.has(chainId);\n}\n","import type { Optional } from \"@otim/utils/helpers\";\nimport type { Chain } from \"viem/chains\";\n\nimport {\n  baseSepolia,\n  sepolia,\n} from \"viem/chains\";\n\nexport const testnetChains = [\n  sepolia,\n  baseSepolia,\n] as const;\n\nexport const testnetChainsById = new Map<number, Chain>(\n  testnetChains.map((chain) => [chain.id, chain]),\n);\n\nexport function getTestnetChain(chainId: number): Optional<Chain> {\n  return testnetChainsById.get(chainId);\n}\n\nexport function isTestnetChain(chainId: number): boolean {\n  return testnetChainsById.has(chainId);\n}\n","import type { ChainTokenAddresses } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\nimport type { Address } from \"@otim/utils/schemas\";\n\nimport {\n  baseSepolia,\n  bscTestnet,\n  polygonAmoy,\n  sepolia,\n  unichain,\n} from \"viem/chains\";\n\nimport { DEFAULT_ADDRESS } from \"../../helpers\";\nimport { pecorinoHost, pecorinoSignet } from \"../config/custom-chains\";\n\n/**\n * Token addresses for testnets and custom chains.\n * Mainnets use JSON token lists (see token-lists.ts).\n */\nexport const testnetTokenAddresses: Record<number, ChainTokenAddresses> = {\n  // TESTNETS\n  [sepolia.id]: {\n    ETH: DEFAULT_ADDRESS,\n    WETH: \"0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14\",\n    USDC: \"0x1c7d4b196cb0c7b01d743fbc6116a902379c7238\",\n    USDT: \"0xaa8e23fb1079ea71e0a56f48a2aa51851d8433d0\",\n  },\n  [baseSepolia.id]: {\n    ETH: DEFAULT_ADDRESS,\n    WETH: \"0x4200000000000000000000000000000000000006\",\n    USDC: \"0x036CbD53842c5426634e7929541eC2318f3dCF7e\",\n    USDT: \"0x323e78f944A9a1FcF3a10efcC5319DBb0bB6e673\",\n  },\n  [bscTestnet.id]: {\n    BNB: DEFAULT_ADDRESS,\n    WBNB: \"0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd\",\n    USDC: \"0x64544969ed7EBf5f083679233325356EbE738930\",\n  },\n  [polygonAmoy.id]: {\n    POL: DEFAULT_ADDRESS,\n    WMATIC: \"0x360ad4f9a9A8EFe9A8DCB5f461c4Cc1047E1Dcf9\",\n    USDC: \"0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582\",\n  },\n  // CUSTOM CHAINS\n  [unichain.id]: {\n    ETH: DEFAULT_ADDRESS,\n    WETH: \"0x4200000000000000000000000000000000000006\",\n    USDC: \"0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA\",\n  },\n  [pecorinoSignet.id]: {\n    USD: DEFAULT_ADDRESS,\n  },\n  [pecorinoHost.id]: {\n    ETH: DEFAULT_ADDRESS,\n  },\n};\n\nexport function getTestnetTokenAddresses(chainId: number): ChainTokenAddresses {\n  return testnetTokenAddresses[chainId] || {};\n}\n\nexport function getTestnetTokenAddress(\n  chainId: number,\n  symbol: string,\n): Optional<Address> {\n  const addresses = getTestnetTokenAddresses(chainId);\n  return addresses[symbol.toUpperCase()];\n}\n\nexport function isTestnetTokenSupported(\n  chainId: number,\n  symbol: string,\n): boolean {\n  return getTestnetTokenAddress(chainId, symbol) !== undefined;\n}\n\n\n","import type { TokenMetadata } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\n\n/**\n * Token metadata for testnets and custom chains.\n * Mainnets use JSON token lists (see token-lists.ts).\n */\nexport const testnetTokenMetadata: Record<string, TokenMetadata> = {\n  USD: {\n    name: \"US Dollar\",\n    symbol: \"USD\",\n    decimals: 18,\n    logoURI: \"/tokens/usd.svg\",\n  },\n  ETH: {\n    name: \"Ethereum\",\n    symbol: \"ETH\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\",\n  },\n  WETH: {\n    name: \"Wrapped Ether\",\n    symbol: \"WETH\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\",\n    type: \"ERC20\",\n  },\n  USDC: {\n    name: \"USDC\",\n    symbol: \"USDC\",\n    decimals: 6,\n    logoURI:\n      \"https://assets-cdn.trustwallet.com/blockchains/ethereum/assets/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48/logo.png\",\n    type: \"ERC20\",\n  },\n  USDT: {\n    name: \"Tether USD\",\n    symbol: \"USDT\",\n    decimals: 6,\n    logoURI:\n      \"https://assets-cdn.trustwallet.com/blockchains/ethereum/assets/0xdAC17F958D2ee523a2206206994597C13D831ec7/logo.png\",\n    type: \"ERC20\",\n  },\n  BNB: {\n    name: \"BNB\",\n    symbol: \"BNB\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add BNB logo\n    type: \"ERC20\",\n  },\n  WBNB: {\n    name: \"Wrapped BNB\",\n    symbol: \"WBNB\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add BNB logo\n    type: \"ERC20\",\n  },\n  POL: {\n    name: \"Polygon\",\n    symbol: \"POL\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add POL logo\n    type: \"ERC20\",\n  },\n  WPOL: {\n    name: \"Wrapped Polygon\",\n    symbol: \"WPOL\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add POL logo\n    type: \"ERC20\",\n  },\n  WMATIC: {\n    name: \"Wrapped MATIC\",\n    symbol: \"WMATIC\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add MATIC logo\n    type: \"ERC20\",\n  },\n};\n\nexport function getTestnetTokenMetadata(symbol: string): Optional<TokenMetadata> {\n  return testnetTokenMetadata[symbol.toUpperCase()];\n}\n\n\n","","","","","","","import type { ChainToken } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\nimport type { Address } from \"@otim/utils/schemas\";\n\nimport {\n  arbitrum,\n  base,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n} from \"viem/chains\";\n\n// Static imports - these will be inlined at build time by the bundler\nimport arbitrumTokens from \"./arbitrum-token-list.json\";\nimport baseTokens from \"./base-token-list.json\";\nimport bscTokens from \"./bsc-token-list.json\";\nimport ethereumTokens from \"./ethereum-token-list.json\";\nimport optimismTokens from \"./optimism-token-list.json\";\nimport polygonTokens from \"./polygon-token-list.json\";\n\n/**\n * Token data from CoinGecko-generated JSON files\n */\nexport interface TokenListEntry {\n  chainId: number;\n  address: string;\n  symbol: string;\n  name: string;\n  coingeckoId: string;\n  marketCapRank: number;\n  logoUrl: string;\n  decimals: number;\n}\n\n/**\n * Chain ID to token list mapping\n */\nconst CHAIN_TOKEN_LISTS: Record<number, TokenListEntry[]> = {\n  [mainnet.id]: ethereumTokens as TokenListEntry[],\n  [base.id]: baseTokens as TokenListEntry[],\n  [arbitrum.id]: arbitrumTokens as TokenListEntry[],\n  [optimism.id]: optimismTokens as TokenListEntry[],\n  [bsc.id]: bscTokens as TokenListEntry[],\n  [polygon.id]: polygonTokens as TokenListEntry[],\n};\n\n/**\n * Convert TokenListEntry to ChainToken format\n */\nfunction toChainToken(entry: TokenListEntry): ChainToken {\n  // Decimals are always present in the JSON token lists\n  const decimals = entry.decimals;\n  \n  return {\n    chainId: entry.chainId,\n    address: entry.address as Address,\n    symbol: entry.symbol,\n    name: entry.name,\n    decimals,\n    logoURI: entry.logoUrl,\n    type: \"ERC20\",\n  };\n}\n\n/**\n * Load token list for a specific chain\n */\nexport function loadTokenList(chainId: number): TokenListEntry[] {\n  return CHAIN_TOKEN_LISTS[chainId] || [];\n}\n\n/**\n * Get token list as ChainToken[] for a specific chain\n */\nexport function getTokenListTokens(chainId: number): ChainToken[] {\n  const entries = loadTokenList(chainId);\n  return entries.map(toChainToken);\n}\n\n/**\n * Get a token from the token list by address\n */\nexport function getTokenListTokenByAddress(\n  chainId: number,\n  address: string,\n): Optional<ChainToken> {\n  const entries = loadTokenList(chainId);\n  const entry = entries.find(\n    (t) => t.address.toLowerCase() === address.toLowerCase(),\n  );\n  return entry ? toChainToken(entry) : undefined;\n}\n\n/**\n * Get a token from the token list by symbol\n */\nexport function getTokenListTokenBySymbol(\n  chainId: number,\n  symbol: string,\n): Optional<ChainToken> {\n  const entries = loadTokenList(chainId);\n  const entry = entries.find(\n    (t) => t.symbol.toUpperCase() === symbol.toUpperCase(),\n  );\n  return entry ? toChainToken(entry) : undefined;\n}\n\n/**\n * Get raw token list entries (with CoinGecko metadata)\n */\nexport function getTokenListEntries(chainId: number): TokenListEntry[] {\n  return loadTokenList(chainId);\n}\n\n/**\n * Check if a chain has a token list available\n */\nexport function hasTokenList(chainId: number): boolean {\n  return chainId in CHAIN_TOKEN_LISTS;\n}\n","import type { ChainToken } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\n\nimport {\n  getTestnetTokenAddress,\n  getTestnetTokenAddresses,\n} from \"./testnet-token-addresses\";\nimport { getTestnetTokenMetadata } from \"./testnet-token-metadata\";\nimport {\n  getTokenListTokenBySymbol,\n  getTokenListTokens,\n  hasTokenList,\n} from \"./token-lists\";\n\n/**\n * Get all tokens for a chain.\n * \n * Mainnets (Ethereum, Base, Arbitrum, Optimism, BSC, Polygon):\n * - Uses comprehensive JSON token lists (top 50 by market cap)\n * \n * Testnets and custom chains:\n * - Uses hardcoded token addresses and metadata\n */\nexport function getChainTokens(chainId: number): ChainToken[] {\n  // Use JSON token lists for supported mainnets\n  if (hasTokenList(chainId)) {\n    return getTokenListTokens(chainId);\n  }\n\n  // Use testnet/custom chain system\n  const addresses = getTestnetTokenAddresses(chainId);\n  const tokens: ChainToken[] = [];\n\n  for (const [symbol, address] of Object.entries(addresses)) {\n    const metadata = getTestnetTokenMetadata(symbol);\n\n    if (metadata && address) {\n      tokens.push({ ...metadata, address, chainId });\n    }\n  }\n\n  return tokens;\n}\n\nexport function getChainToken(\n  chainId: number,\n  symbol: string,\n): Optional<ChainToken> {\n  const tokens = getChainTokens(chainId);\n  return tokens.find(\n    (token) => token.symbol.toUpperCase() === symbol.toUpperCase(),\n  );\n}\n\nexport function getChainTokenByAddress(\n  chainId: number,\n  address: string,\n): Optional<ChainToken> {\n  const tokens = getChainTokens(chainId);\n  return tokens.find(\n    (token) => token.address.toLowerCase() === address.toLowerCase(),\n  );\n}\n\n/**\n * Get token address by symbol for a chain.\n * Works for both mainnets (from JSON lists) and testnets (from hardcoded addresses).\n */\nexport function getTokenAddress(\n  chainId: number,\n  symbol: string,\n): Optional<string> {\n  // Try JSON lists first (mainnets)\n  if (hasTokenList(chainId)) {\n    const token = getTokenListTokenBySymbol(chainId, symbol);\n    return token?.address;\n  }\n\n  // Fallback to testnet addresses\n  return getTestnetTokenAddress(chainId, symbol);\n}\n\n/**\n * Get all token addresses for a chain as a symbol -> address mapping.\n * Compatible with the old tokenAddresses structure for backward compatibility.\n */\nexport function getTokenAddresses(\n  chainId: number,\n): Record<string, string> {\n  const tokens = getChainTokens(chainId);\n  const addresses: Record<string, string> = {};\n\n  for (const token of tokens) {\n    addresses[token.symbol.toUpperCase()] = token.address;\n  }\n\n  return addresses;\n}\n","import type { ChainConfig } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\nimport type { Chain } from \"viem/chains\";\n\nimport { mainnetChains } from \"./mainnet-chains\";\nimport { testnetChains } from \"./testnet-chains\";\nimport { getChainTokens } from \"../tokens/chain-tokens\";\n\nexport const allChains = [...mainnetChains, ...testnetChains] as const;\n\nexport type SupportedChainId = (typeof allChains)[number][\"id\"];\n\nexport const chainById = new Map<number, Chain>(\n  allChains.map((chain) => [chain.id, chain]),\n);\n\nexport function getChainById(chainId: number): Optional<Chain> {\n  return chainById.get(chainId);\n}\n\nexport function getChainConfig(chainId: number): Optional<ChainConfig> {\n  const chain = getChainById(chainId);\n  if (!chain) return undefined;\n\n  return {\n    chain,\n    isTestnet: chain.testnet ?? false,\n    tokens: getChainTokens(chain.id),\n  };\n}\n\nexport function getMainnetChains(): ChainConfig[] {\n  return mainnetChains.map((chain) => ({\n    chain,\n    isTestnet: false,\n    tokens: getChainTokens(chain.id),\n  }));\n}\n\nexport function getTestnetChains(): ChainConfig[] {\n  return testnetChains.map((chain) => ({\n    chain,\n    isTestnet: true,\n    tokens: getChainTokens(chain.id),\n  }));\n}\n\nexport function getAllChains(): ChainConfig[] {\n  return [...getMainnetChains(), ...getTestnetChains()];\n}\n\nexport function isSupportedChain(chainId: number): boolean {\n  return chainById.has(chainId);\n}\n","import type { ChainToken } from \"../types\";\n\nexport function filterTokens(\n  tokens: ChainToken[],\n  allowedSymbols: string[],\n  disabledSymbols: string[],\n): ChainToken[] {\n  let result = tokens;\n\n  if (disabledSymbols.length > 0) {\n    result = result.filter(\n      (token) => !disabledSymbols.includes(token.symbol.toUpperCase()),\n    );\n  }\n\n  if (allowedSymbols && allowedSymbols.length > 0) {\n    result = result.filter((token) =>\n      allowedSymbols.includes(token.symbol.toUpperCase()),\n    );\n  }\n\n  return result;\n}\n","import type { ChainToken } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\n\nexport interface TokenMaps {\n  byAddress: Map<string, ChainToken>;\n  bySymbol: Map<string, ChainToken>;\n}\n\nexport function createTokenMaps(tokens: ChainToken[]): TokenMaps {\n  const byAddress = new Map<string, ChainToken>();\n  const bySymbol = new Map<string, ChainToken>();\n\n  tokens.forEach((token) => {\n    byAddress.set(token.address.toLowerCase(), token);\n    bySymbol.set(token.symbol.toLowerCase(), token);\n  });\n\n  return { byAddress, bySymbol };\n}\n\nexport function getTokenByAddress(\n  maps: TokenMaps,\n  address: string,\n): Optional<ChainToken> {\n  if (!address) return undefined;\n  return maps.byAddress.get(address.toLowerCase());\n}\n\nexport function getTokenBySymbol(\n  maps: TokenMaps,\n  symbol: string,\n): Optional<ChainToken> {\n  if (!symbol) return undefined;\n  return maps.bySymbol.get(symbol.toLowerCase());\n}\n","/**\n * List of supported stablecoin symbols\n */\nconst stablecoinSymbols = [\"USDC\", \"USDT\"] as const;\n\n/**\n * Checks if a token symbol is a stablecoin\n * @param symbol - Token symbol to check (e.g., \"USDC\", \"ETH\")\n * @returns true if the symbol is a recognized stablecoin\n */\nexport function isStablecoin(symbol: string | string[]): boolean {\n  if (typeof symbol === \"string\") {\n    return stablecoinSymbols.includes(\n      symbol as (typeof stablecoinSymbols)[number],\n    );\n  }\n\n  return symbol.every((s) =>\n    stablecoinSymbols.includes(s as (typeof stablecoinSymbols)[number]),\n  );\n}\n","import type { Optional } from \"@otim/utils/helpers\";\n\n/**\n * Mapping between chain ID numbers (used internally by otim) and\n * Lambda API chain ID strings (used by Lambda's API endpoints).\n *\n * Lambda uses string identifiers for chains while we use numeric chain IDs\n * from viem/wagmi. This map provides bidirectional conversion.\n */\n\n/**\n * Map from numeric chain ID to Lambda chain ID string\n */\nexport const CHAIN_ID_TO_LAMBDA_ID: Record<number, string> = {\n  /* Mainnet chains */\n  1: \"ethereum\",\n  8453: \"base\",\n  42161: \"arbitrum\",\n  10: \"optimism\",\n  56: \"binance-smart-chain\",\n  130: \"unichain\",\n  137: \"polygon\",\n} as const;\n\n/**\n * Map from Lambda chain ID string to numeric chain ID\n */\nexport const LAMBDA_ID_TO_CHAIN_ID: Record<string, number> = {\n  ethereum: 1,\n  base: 8453,\n  arbitrum: 42161,\n  optimism: 10,\n  \"binance-smart-chain\": 56,\n  unichain: 130,\n  polygon: 137,\n} as const;\n\n/**\n * Convert a numeric chain ID to Lambda's chain ID string\n * @param chainId - The numeric chain ID\n * @returns The Lambda chain ID string, or undefined if not supported by Lambda\n */\n\nexport function chainIdToLambdaId(chainId: number): Optional<string> {\n  return CHAIN_ID_TO_LAMBDA_ID[chainId];\n}\n\n/**\n * Convert a Lambda chain ID string to numeric chain ID\n * @param lambdaId - The Lambda chain ID string\n * @returns The numeric chain ID, or undefined if not recognized\n */\nexport function lambdaIdToChainId(lambdaId: string): Optional<number> {\n  return LAMBDA_ID_TO_CHAIN_ID[lambdaId];\n}\n\n/**\n * Check if a chain ID is supported by Lambda\n * @param chainId - The numeric chain ID to check\n * @returns true if the chain is supported by Lambda\n */\nexport function isLambdaSupportedChain(chainId: number): boolean {\n  return chainId in CHAIN_ID_TO_LAMBDA_ID;\n}\n\n/**\n * Get all chain IDs supported by Lambda\n * @returns Array of numeric chain IDs that are supported by Lambda\n */\nexport function getLambdaSupportedChainIds(): number[] {\n  return Object.keys(CHAIN_ID_TO_LAMBDA_ID).map(Number);\n}\n\n/**\n * Get all Lambda chain ID strings\n * @returns Array of Lambda chain ID strings\n */\nexport function getLambdaChainIds(): string[] {\n  return Object.values(CHAIN_ID_TO_LAMBDA_ID);\n}\n","import type { Optional } from \"@otim/utils/helpers\";\n\nimport {\n  arbitrum,\n  avalanche,\n  base,\n  baseSepolia,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n  polygonAmoy,\n  sepolia,\n  unichain,\n} from \"viem/chains\";\n\nimport { pecorinoHost, pecorinoSignet } from \"./custom-chains\";\n\nexport interface ChainMetadata {\n  name: string;\n  iconUrl?: string;\n  // Add other chain metadata fields as needed\n}\n\n/**\n * Chain metadata including icon URLs and display names.\n * Icon URLs can be IPFS hashes or HTTP URLs.\n * \n * To get chain icon URLs, you can:\n * 1. Extract from Lambda portfolio API (chain_icon_url field)\n * 2. Use chain explorer APIs\n * 3. Use trusted sources like ChainList\n */\nexport const chainMetadata: Record<number, ChainMetadata> = {\n  [mainnet.id]: {\n    name: \"Ethereum\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/ethereum.png\",\n  },\n  [base.id]: {\n    name: \"Base\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/base.png\",\n  },\n  [arbitrum.id]: {\n    name: \"Arbitrum One\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/arbitrum.png\",\n  },\n  [optimism.id]: {\n    name: \"OP Mainnet\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/optimism.png\",\n  },\n  [bsc.id]: {\n    name: \"Binance Smart Chain\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/binance-smart-chain.png\",\n  },\n  [polygon.id]: {\n    name: \"Polygon\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/polygon.png\",\n  },\n  [avalanche.id]: {\n    name: \"Avalanche\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/avalanche.png\",\n  },\n  [unichain.id]: {\n    name: \"Unichain\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/unichain.png\",\n  },\n  [sepolia.id]: {\n    name: \"Sepolia\",\n  },\n  [baseSepolia.id]: {\n    name: \"Base Sepolia\",\n  },\n  [polygonAmoy.id]: {\n    name: \"Polygon Amoy\",\n  },\n  [pecorinoSignet.id]: {\n    name: \"Pecorino Signet\",\n  },\n  [pecorinoHost.id]: {\n    name: \"Pecorino Host\",\n  },\n};\n\n/**\n * Get chain metadata by chain ID\n * @param chainId - The numeric chain ID\n * @returns Chain metadata or undefined if not found\n */\nexport function getChainMetadata(chainId: number): Optional<ChainMetadata> {\n  return chainMetadata[chainId];\n}\n\n/**\n * Get chain icon URL by chain ID\n * @param chainId - The numeric chain ID\n * @returns Chain icon URL or undefined if not found\n */\nexport function getChainIconUrl(chainId: number): Optional<string> {\n  return chainMetadata[chainId]?.iconUrl;\n}\n\n/**\n * Get chain display name by chain ID\n * @param chainId - The numeric chain ID\n * @returns Chain name or undefined if not found\n */\nexport function getChainDisplayName(chainId: number): Optional<string> {\n  return chainMetadata[chainId]?.name;\n}\n\n"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"index.mjs","names":["ethereumTokens","baseTokens","arbitrumTokens","optimismTokens","bscTokens","polygonTokens"],"sources":["../../src/chains/config/custom-chains.ts","../../src/chains/config/all-chains.ts","../../src/chains/config/mainnet-chains.ts","../../src/chains/config/testnet-chains.ts","../../src/chains/tokens/testnet-token-addresses.ts","../../src/chains/tokens/testnet-token-metadata.ts","../../src/chains/tokens/arbitrum-token-list.json","../../src/chains/tokens/base-token-list.json","../../src/chains/tokens/bsc-token-list.json","../../src/chains/tokens/ethereum-token-list.json","../../src/chains/tokens/optimism-token-list.json","../../src/chains/tokens/polygon-token-list.json","../../src/chains/tokens/token-lists.ts","../../src/chains/tokens/chain-tokens.ts","../../src/chains/config/supported-chains.ts","../../src/chains/utils/filter-tokens.ts","../../src/chains/utils/token-maps.ts","../../src/chains/utils/stablecoin.ts","../../src/chains/lambda/chain-mapping.ts","../../src/chains/config/chain-metadata.ts"],"sourcesContent":["import type { Chain } from \"viem/chains\";\n\nexport const pecorinoSignet = {\n  id: 14174,\n  name: \"Pecorino Signet\",\n  nativeCurrency: {\n    decimals: 18,\n    name: \"USD\",\n    symbol: \"USD\",\n  },\n  rpcUrls: {\n    default: { http: [\"https://rpc.pecorino.signet.sh/\"] },\n    public: { http: [\"https://rpc.pecorino.signet.sh/\"] },\n  },\n  blockExplorers: {\n    default: {\n      name: \"Pecorino Signet Explorer\",\n      url: \"https://explorer.pecorino.signet.sh/\",\n    },\n  },\n  testnet: true,\n} as const satisfies Chain;\n\nexport const pecorinoHost = {\n  id: 3151908,\n  name: \"Pecorino Host\",\n  nativeCurrency: {\n    decimals: 18,\n    name: \"ETH\",\n    symbol: \"ETH\",\n  },\n  rpcUrls: {\n    default: { http: [\"https://host-rpc.pecorino.signet.sh/\"] },\n    public: { http: [\"https://host-rpc.pecorino.signet.sh/\"] },\n  },\n  blockExplorers: {\n    default: {\n      name: \"Pecorino Host Explorer\",\n      url: \"https://explorer-host.pecorino.signet.sh/\",\n    },\n  },\n  testnet: true,\n} as const satisfies Chain;\n","import {\n  arbitrum,\n  base,\n  baseSepolia,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n  polygonAmoy,\n  sepolia,\n  unichain,\n} from \"viem/chains\";\n\nimport { pecorinoHost, pecorinoSignet } from \"./custom-chains\";\nimport { OtimEnvironment } from \"../../config/api-urls\";\n\nexport const supportedChains = {\n  mainnet: {\n    mainnet,\n    base,\n  },\n  testnet: {\n    sepolia,\n    baseSepolia,\n  },\n} as const;\n\nexport const allSupportedChains = {\n  mainnet,\n  base,\n  arbitrum,\n  optimism,\n  bsc,\n  unichain,\n  polygon,\n  sepolia,\n  baseSepolia,\n  polygonAmoy,\n  pecorinoHost,\n  pecorinoSignet,\n} as const;\n\n/**\n * Get the default chain ID based on the provided environment.\n * Production: Base mainnet (8453)\n * Local/Sandbox: Base Sepolia (84532)\n *\n * @param environment - The Otim environment (local | sandbox | production)\n * @returns The default chain ID for the environment\n */\nexport const getDefaultChainId = (environment: OtimEnvironment): number => {\n  return environment === OtimEnvironment.Production ? base.id : baseSepolia.id;\n};\n\n/**\n * Get the default chain based on the provided environment.\n * Production: Base mainnet\n * Local/Sandbox: Base Sepolia\n *\n * @param environment - The Otim environment (local | sandbox | production)\n * @returns The default chain for the environment\n */\nexport const getDefaultChain = (environment: OtimEnvironment) => {\n  return environment === OtimEnvironment.Production ? base : baseSepolia;\n};\n\nexport type SupportedChainName = keyof typeof allSupportedChains;\nexport type MainnetChainName = keyof typeof supportedChains.mainnet;\nexport type TestnetChainName = keyof typeof supportedChains.testnet;\n","import type { Optional } from \"@otim/utils/helpers\";\nimport type { Chain } from \"viem/chains\";\n\nimport {\n  arbitrum,\n  base,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n  unichain,\n} from \"viem/chains\";\n\nexport const mainnetChains = [\n  mainnet,\n  base,\n  arbitrum,\n  optimism,\n  bsc,\n  unichain,\n  polygon,\n] as const;\n\nexport const mainnetChainsById = new Map<number, Chain>(\n  mainnetChains.map((chain) => [chain.id, chain]),\n);\n\nexport function getMainnetChain(chainId: number): Optional<Chain> {\n  return mainnetChainsById.get(chainId);\n}\n\nexport function isMainnetChain(chainId: number): boolean {\n  return mainnetChainsById.has(chainId);\n}\n","import type { Optional } from \"@otim/utils/helpers\";\nimport type { Chain } from \"viem/chains\";\n\nimport {\n  baseSepolia,\n  sepolia,\n} from \"viem/chains\";\n\nexport const testnetChains = [\n  sepolia,\n  baseSepolia,\n] as const;\n\nexport const testnetChainsById = new Map<number, Chain>(\n  testnetChains.map((chain) => [chain.id, chain]),\n);\n\nexport function getTestnetChain(chainId: number): Optional<Chain> {\n  return testnetChainsById.get(chainId);\n}\n\nexport function isTestnetChain(chainId: number): boolean {\n  return testnetChainsById.has(chainId);\n}\n","import type { ChainTokenAddresses } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\nimport type { Address } from \"@otim/utils/schemas\";\n\nimport {\n  baseSepolia,\n  bscTestnet,\n  polygonAmoy,\n  sepolia,\n  unichain,\n} from \"viem/chains\";\n\nimport { DEFAULT_ADDRESS } from \"../../helpers\";\nimport { pecorinoHost, pecorinoSignet } from \"../config/custom-chains\";\n\n/**\n * Token addresses for testnets and custom chains.\n * Mainnets use JSON token lists (see token-lists.ts).\n */\nexport const testnetTokenAddresses: Record<number, ChainTokenAddresses> = {\n  // TESTNETS\n  [sepolia.id]: {\n    ETH: DEFAULT_ADDRESS,\n    WETH: \"0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14\",\n    USDC: \"0x1c7d4b196cb0c7b01d743fbc6116a902379c7238\",\n    USDT: \"0xaa8e23fb1079ea71e0a56f48a2aa51851d8433d0\",\n  },\n  [baseSepolia.id]: {\n    ETH: DEFAULT_ADDRESS,\n    WETH: \"0x4200000000000000000000000000000000000006\",\n    USDC: \"0x036CbD53842c5426634e7929541eC2318f3dCF7e\",\n    USDT: \"0x323e78f944A9a1FcF3a10efcC5319DBb0bB6e673\",\n  },\n  [bscTestnet.id]: {\n    BNB: DEFAULT_ADDRESS,\n    WBNB: \"0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd\",\n    USDC: \"0x64544969ed7EBf5f083679233325356EbE738930\",\n  },\n  [polygonAmoy.id]: {\n    POL: DEFAULT_ADDRESS,\n    WMATIC: \"0x360ad4f9a9A8EFe9A8DCB5f461c4Cc1047E1Dcf9\",\n    USDC: \"0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582\",\n  },\n  // CUSTOM CHAINS\n  [unichain.id]: {\n    ETH: DEFAULT_ADDRESS,\n    WETH: \"0x4200000000000000000000000000000000000006\",\n    USDC: \"0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA\",\n  },\n  [pecorinoSignet.id]: {\n    USD: DEFAULT_ADDRESS,\n  },\n  [pecorinoHost.id]: {\n    ETH: DEFAULT_ADDRESS,\n  },\n};\n\nexport function getTestnetTokenAddresses(chainId: number): ChainTokenAddresses {\n  return testnetTokenAddresses[chainId] || {};\n}\n\nexport function getTestnetTokenAddress(\n  chainId: number,\n  symbol: string,\n): Optional<Address> {\n  const addresses = getTestnetTokenAddresses(chainId);\n  return addresses[symbol.toUpperCase()];\n}\n\nexport function isTestnetTokenSupported(\n  chainId: number,\n  symbol: string,\n): boolean {\n  return getTestnetTokenAddress(chainId, symbol) !== undefined;\n}\n\n\n","import type { TokenMetadata } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\n\n/**\n * Token metadata for testnets and custom chains.\n * Mainnets use JSON token lists (see token-lists.ts).\n */\nexport const testnetTokenMetadata: Record<string, TokenMetadata> = {\n  USD: {\n    name: \"US Dollar\",\n    symbol: \"USD\",\n    decimals: 18,\n    logoURI: \"/tokens/usd.svg\",\n  },\n  ETH: {\n    name: \"Ethereum\",\n    symbol: \"ETH\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\",\n  },\n  WETH: {\n    name: \"Wrapped Ether\",\n    symbol: \"WETH\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\",\n    type: \"ERC20\",\n  },\n  USDC: {\n    name: \"USDC\",\n    symbol: \"USDC\",\n    decimals: 6,\n    logoURI:\n      \"https://assets-cdn.trustwallet.com/blockchains/ethereum/assets/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48/logo.png\",\n    type: \"ERC20\",\n  },\n  USDT: {\n    name: \"Tether USD\",\n    symbol: \"USDT\",\n    decimals: 6,\n    logoURI:\n      \"https://assets-cdn.trustwallet.com/blockchains/ethereum/assets/0xdAC17F958D2ee523a2206206994597C13D831ec7/logo.png\",\n    type: \"ERC20\",\n  },\n  BNB: {\n    name: \"BNB\",\n    symbol: \"BNB\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add BNB logo\n    type: \"ERC20\",\n  },\n  WBNB: {\n    name: \"Wrapped BNB\",\n    symbol: \"WBNB\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add BNB logo\n    type: \"ERC20\",\n  },\n  POL: {\n    name: \"Polygon\",\n    symbol: \"POL\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add POL logo\n    type: \"ERC20\",\n  },\n  WPOL: {\n    name: \"Wrapped Polygon\",\n    symbol: \"WPOL\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add POL logo\n    type: \"ERC20\",\n  },\n  WMATIC: {\n    name: \"Wrapped MATIC\",\n    symbol: \"WMATIC\",\n    decimals: 18,\n    logoURI: \"/tokens/eth.svg\", // TODO: Add MATIC logo\n    type: \"ERC20\",\n  },\n};\n\nexport function getTestnetTokenMetadata(symbol: string): Optional<TokenMetadata> {\n  return testnetTokenMetadata[symbol.toUpperCase()];\n}\n\n\n","","","","","","","import type { ChainToken } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\nimport type { Address } from \"@otim/utils/schemas\";\n\nimport {\n  arbitrum,\n  base,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n} from \"viem/chains\";\n\n// Static imports - these will be inlined at build time by the bundler\nimport arbitrumTokens from \"./arbitrum-token-list.json\";\nimport baseTokens from \"./base-token-list.json\";\nimport bscTokens from \"./bsc-token-list.json\";\nimport ethereumTokens from \"./ethereum-token-list.json\";\nimport optimismTokens from \"./optimism-token-list.json\";\nimport polygonTokens from \"./polygon-token-list.json\";\n\n/**\n * Token data from CoinGecko-generated JSON files\n */\nexport interface TokenListEntry {\n  chainId: number;\n  address: string;\n  symbol: string;\n  name: string;\n  coingeckoId: string;\n  marketCapRank: number;\n  logoUrl: string;\n  decimals: number;\n}\n\n/**\n * Chain ID to token list mapping\n */\nconst CHAIN_TOKEN_LISTS: Record<number, TokenListEntry[]> = {\n  [mainnet.id]: ethereumTokens as TokenListEntry[],\n  [base.id]: baseTokens as TokenListEntry[],\n  [arbitrum.id]: arbitrumTokens as TokenListEntry[],\n  [optimism.id]: optimismTokens as TokenListEntry[],\n  [bsc.id]: bscTokens as TokenListEntry[],\n  [polygon.id]: polygonTokens as TokenListEntry[],\n};\n\n/**\n * Convert TokenListEntry to ChainToken format\n */\nfunction toChainToken(entry: TokenListEntry): ChainToken {\n  // Decimals are always present in the JSON token lists\n  const decimals = entry.decimals;\n  \n  return {\n    chainId: entry.chainId,\n    address: entry.address as Address,\n    symbol: entry.symbol,\n    name: entry.name,\n    decimals,\n    logoURI: entry.logoUrl,\n    type: \"ERC20\",\n  };\n}\n\n/**\n * Load token list for a specific chain\n */\nexport function loadTokenList(chainId: number): TokenListEntry[] {\n  return CHAIN_TOKEN_LISTS[chainId] || [];\n}\n\n/**\n * Get token list as ChainToken[] for a specific chain\n */\nexport function getTokenListTokens(chainId: number): ChainToken[] {\n  const entries = loadTokenList(chainId);\n  return entries.map(toChainToken);\n}\n\n/**\n * Get a token from the token list by address\n */\nexport function getTokenListTokenByAddress(\n  chainId: number,\n  address: string,\n): Optional<ChainToken> {\n  const entries = loadTokenList(chainId);\n  const entry = entries.find(\n    (t) => t.address.toLowerCase() === address.toLowerCase(),\n  );\n  return entry ? toChainToken(entry) : undefined;\n}\n\n/**\n * Get a token from the token list by symbol\n */\nexport function getTokenListTokenBySymbol(\n  chainId: number,\n  symbol: string,\n): Optional<ChainToken> {\n  const entries = loadTokenList(chainId);\n  const entry = entries.find(\n    (t) => t.symbol.toUpperCase() === symbol.toUpperCase(),\n  );\n  return entry ? toChainToken(entry) : undefined;\n}\n\n/**\n * Get raw token list entries (with CoinGecko metadata)\n */\nexport function getTokenListEntries(chainId: number): TokenListEntry[] {\n  return loadTokenList(chainId);\n}\n\n/**\n * Check if a chain has a token list available\n */\nexport function hasTokenList(chainId: number): boolean {\n  return chainId in CHAIN_TOKEN_LISTS;\n}\n","import type { ChainToken } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\n\nimport {\n  getTestnetTokenAddress,\n  getTestnetTokenAddresses,\n} from \"./testnet-token-addresses\";\nimport { getTestnetTokenMetadata } from \"./testnet-token-metadata\";\nimport {\n  getTokenListTokenBySymbol,\n  getTokenListTokens,\n  hasTokenList,\n} from \"./token-lists\";\n\n/**\n * Get all tokens for a chain.\n * \n * Mainnets (Ethereum, Base, Arbitrum, Optimism, BSC, Polygon):\n * - Uses comprehensive JSON token lists (top 50 by market cap)\n * \n * Testnets and custom chains:\n * - Uses hardcoded token addresses and metadata\n */\nexport function getChainTokens(chainId: number): ChainToken[] {\n  // Use JSON token lists for supported mainnets\n  if (hasTokenList(chainId)) {\n    return getTokenListTokens(chainId);\n  }\n\n  // Use testnet/custom chain system\n  const addresses = getTestnetTokenAddresses(chainId);\n  const tokens: ChainToken[] = [];\n\n  for (const [symbol, address] of Object.entries(addresses)) {\n    const metadata = getTestnetTokenMetadata(symbol);\n\n    if (metadata && address) {\n      tokens.push({ ...metadata, address, chainId });\n    }\n  }\n\n  return tokens;\n}\n\nexport function getChainToken(\n  chainId: number,\n  symbol: string,\n): Optional<ChainToken> {\n  const tokens = getChainTokens(chainId);\n  return tokens.find(\n    (token) => token.symbol.toUpperCase() === symbol.toUpperCase(),\n  );\n}\n\nexport function getChainTokenByAddress(\n  chainId: number,\n  address: string,\n): Optional<ChainToken> {\n  const tokens = getChainTokens(chainId);\n  return tokens.find(\n    (token) => token.address.toLowerCase() === address.toLowerCase(),\n  );\n}\n\n/**\n * Get token address by symbol for a chain.\n * Works for both mainnets (from JSON lists) and testnets (from hardcoded addresses).\n */\nexport function getTokenAddress(\n  chainId: number,\n  symbol: string,\n): Optional<string> {\n  // Try JSON lists first (mainnets)\n  if (hasTokenList(chainId)) {\n    const token = getTokenListTokenBySymbol(chainId, symbol);\n    return token?.address;\n  }\n\n  // Fallback to testnet addresses\n  return getTestnetTokenAddress(chainId, symbol);\n}\n\n/**\n * Get all token addresses for a chain as a symbol -> address mapping.\n * Compatible with the old tokenAddresses structure for backward compatibility.\n */\nexport function getTokenAddresses(\n  chainId: number,\n): Record<string, string> {\n  const tokens = getChainTokens(chainId);\n  const addresses: Record<string, string> = {};\n\n  for (const token of tokens) {\n    addresses[token.symbol.toUpperCase()] = token.address;\n  }\n\n  return addresses;\n}\n","import type { ChainConfig } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\nimport type { Chain } from \"viem/chains\";\n\nimport { mainnetChains } from \"./mainnet-chains\";\nimport { testnetChains } from \"./testnet-chains\";\nimport { getChainTokens } from \"../tokens/chain-tokens\";\n\nexport const allChains = [...mainnetChains, ...testnetChains] as const;\n\nexport type SupportedChainId = (typeof allChains)[number][\"id\"];\n\nexport const chainById = new Map<number, Chain>(\n  allChains.map((chain) => [chain.id, chain]),\n);\n\nexport function getChainById(chainId: number): Optional<Chain> {\n  return chainById.get(chainId);\n}\n\nexport function getChainConfig(chainId: number): Optional<ChainConfig> {\n  const chain = getChainById(chainId);\n  if (!chain) return undefined;\n\n  return {\n    chain,\n    isTestnet: chain.testnet ?? false,\n    tokens: getChainTokens(chain.id),\n  };\n}\n\nexport function getMainnetChains(): ChainConfig[] {\n  return mainnetChains.map((chain) => ({\n    chain,\n    isTestnet: false,\n    tokens: getChainTokens(chain.id),\n  }));\n}\n\nexport function getTestnetChains(): ChainConfig[] {\n  return testnetChains.map((chain) => ({\n    chain,\n    isTestnet: true,\n    tokens: getChainTokens(chain.id),\n  }));\n}\n\nexport function getAllChains(): ChainConfig[] {\n  return [...getMainnetChains(), ...getTestnetChains()];\n}\n\nexport function isSupportedChain(chainId: number): boolean {\n  return chainById.has(chainId);\n}\n","import type { ChainToken } from \"../types\";\n\nexport function filterTokens(\n  tokens: ChainToken[],\n  allowedSymbols: string[],\n  disabledSymbols: string[],\n): ChainToken[] {\n  let result = tokens;\n\n  if (disabledSymbols.length > 0) {\n    result = result.filter(\n      (token) => !disabledSymbols.includes(token.symbol.toUpperCase()),\n    );\n  }\n\n  if (allowedSymbols && allowedSymbols.length > 0) {\n    result = result.filter((token) =>\n      allowedSymbols.includes(token.symbol.toUpperCase()),\n    );\n  }\n\n  return result;\n}\n","import type { ChainToken } from \"../types\";\nimport type { Optional } from \"@otim/utils/helpers\";\n\nexport interface TokenMaps {\n  byAddress: Map<string, ChainToken>;\n  bySymbol: Map<string, ChainToken>;\n}\n\nexport function createTokenMaps(tokens: ChainToken[]): TokenMaps {\n  const byAddress = new Map<string, ChainToken>();\n  const bySymbol = new Map<string, ChainToken>();\n\n  tokens.forEach((token) => {\n    byAddress.set(token.address.toLowerCase(), token);\n    bySymbol.set(token.symbol.toLowerCase(), token);\n  });\n\n  return { byAddress, bySymbol };\n}\n\nexport function getTokenByAddress(\n  maps: TokenMaps,\n  address: string,\n): Optional<ChainToken> {\n  if (!address) return undefined;\n  return maps.byAddress.get(address.toLowerCase());\n}\n\nexport function getTokenBySymbol(\n  maps: TokenMaps,\n  symbol: string,\n): Optional<ChainToken> {\n  if (!symbol) return undefined;\n  return maps.bySymbol.get(symbol.toLowerCase());\n}\n","/**\n * List of supported stablecoin symbols\n */\nconst stablecoinSymbols = [\"USDC\", \"USDT\"] as const;\n\n/**\n * Checks if a token symbol is a stablecoin\n * @param symbol - Token symbol to check (e.g., \"USDC\", \"ETH\")\n * @returns true if the symbol is a recognized stablecoin\n */\nexport function isStablecoin(symbol: string | string[]): boolean {\n  if (typeof symbol === \"string\") {\n    return stablecoinSymbols.includes(\n      symbol as (typeof stablecoinSymbols)[number],\n    );\n  }\n\n  return symbol.every((s) =>\n    stablecoinSymbols.includes(s as (typeof stablecoinSymbols)[number]),\n  );\n}\n","import type { Optional } from \"@otim/utils/helpers\";\n\n/**\n * Mapping between chain ID numbers (used internally by otim) and\n * Lambda API chain ID strings (used by Lambda's API endpoints).\n *\n * Lambda uses string identifiers for chains while we use numeric chain IDs\n * from viem/wagmi. This map provides bidirectional conversion.\n */\n\n/**\n * Map from numeric chain ID to Lambda chain ID string\n */\nexport const CHAIN_ID_TO_LAMBDA_ID: Record<number, string> = {\n  /* Mainnet chains */\n  1: \"ethereum\",\n  8453: \"base\",\n  42161: \"arbitrum\",\n  10: \"optimism\",\n  56: \"binance-smart-chain\",\n  130: \"unichain\",\n  137: \"polygon\",\n} as const;\n\n/**\n * Map from Lambda chain ID string to numeric chain ID\n */\nexport const LAMBDA_ID_TO_CHAIN_ID: Record<string, number> = {\n  ethereum: 1,\n  base: 8453,\n  arbitrum: 42161,\n  optimism: 10,\n  \"binance-smart-chain\": 56,\n  unichain: 130,\n  polygon: 137,\n} as const;\n\n/**\n * Convert a numeric chain ID to Lambda's chain ID string\n * @param chainId - The numeric chain ID\n * @returns The Lambda chain ID string, or undefined if not supported by Lambda\n */\n\nexport function chainIdToLambdaId(chainId: number): Optional<string> {\n  return CHAIN_ID_TO_LAMBDA_ID[chainId];\n}\n\n/**\n * Convert a Lambda chain ID string to numeric chain ID\n * @param lambdaId - The Lambda chain ID string\n * @returns The numeric chain ID, or undefined if not recognized\n */\nexport function lambdaIdToChainId(lambdaId: string): Optional<number> {\n  return LAMBDA_ID_TO_CHAIN_ID[lambdaId];\n}\n\n/**\n * Check if a chain ID is supported by Lambda\n * @param chainId - The numeric chain ID to check\n * @returns true if the chain is supported by Lambda\n */\nexport function isLambdaSupportedChain(chainId: number): boolean {\n  return chainId in CHAIN_ID_TO_LAMBDA_ID;\n}\n\n/**\n * Get all chain IDs supported by Lambda\n * @returns Array of numeric chain IDs that are supported by Lambda\n */\nexport function getLambdaSupportedChainIds(): number[] {\n  return Object.keys(CHAIN_ID_TO_LAMBDA_ID).map(Number);\n}\n\n/**\n * Get all Lambda chain ID strings\n * @returns Array of Lambda chain ID strings\n */\nexport function getLambdaChainIds(): string[] {\n  return Object.values(CHAIN_ID_TO_LAMBDA_ID);\n}\n","import type { Optional } from \"@otim/utils/helpers\";\n\nimport {\n  arbitrum,\n  avalanche,\n  base,\n  baseSepolia,\n  bsc,\n  mainnet,\n  optimism,\n  polygon,\n  polygonAmoy,\n  sepolia,\n  unichain,\n} from \"viem/chains\";\n\nimport { pecorinoHost, pecorinoSignet } from \"./custom-chains\";\n\nexport interface ChainMetadata {\n  name: string;\n  iconUrl?: string;\n  // Add other chain metadata fields as needed\n}\n\n/**\n * Chain metadata including icon URLs and display names.\n * Icon URLs can be IPFS hashes or HTTP URLs.\n * \n * To get chain icon URLs, you can:\n * 1. Extract from Lambda portfolio API (chain_icon_url field)\n * 2. Use chain explorer APIs\n * 3. Use trusted sources like ChainList\n */\nexport const chainMetadata: Record<number, ChainMetadata> = {\n  [mainnet.id]: {\n    name: \"Ethereum\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/ethereum.png\",\n  },\n  [base.id]: {\n    name: \"Base\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/base.png\",\n  },\n  [arbitrum.id]: {\n    name: \"Arbitrum One\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/arbitrum.png\",\n  },\n  [optimism.id]: {\n    name: \"OP Mainnet\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/optimism.png\",\n  },\n  [bsc.id]: {\n    name: \"Binance Smart Chain\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/binance-smart-chain.png\",\n  },\n  [polygon.id]: {\n    name: \"Polygon\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/polygon.png\",\n  },\n  [avalanche.id]: {\n    name: \"Avalanche\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/avalanche.png\",\n  },\n  [unichain.id]: {\n    name: \"Unichain\",\n    iconUrl: \"https://static.lambda.p2p.org/chains/unichain.png\",\n  },\n  [sepolia.id]: {\n    name: \"Sepolia\",\n  },\n  [baseSepolia.id]: {\n    name: \"Base Sepolia\",\n  },\n  [polygonAmoy.id]: {\n    name: \"Polygon Amoy\",\n  },\n  [pecorinoSignet.id]: {\n    name: \"Pecorino Signet\",\n  },\n  [pecorinoHost.id]: {\n    name: \"Pecorino Host\",\n  },\n};\n\n/**\n * Get chain metadata by chain ID\n * @param chainId - The numeric chain ID\n * @returns Chain metadata or undefined if not found\n */\nexport function getChainMetadata(chainId: number): Optional<ChainMetadata> {\n  return chainMetadata[chainId];\n}\n\n/**\n * Get chain icon URL by chain ID\n * @param chainId - The numeric chain ID\n * @returns Chain icon URL or undefined if not found\n */\nexport function getChainIconUrl(chainId: number): Optional<string> {\n  return chainMetadata[chainId]?.iconUrl;\n}\n\n/**\n * Get chain display name by chain ID\n * @param chainId - The numeric chain ID\n * @returns Chain name or undefined if not found\n */\nexport function getChainDisplayName(chainId: number): Optional<string> {\n  return chainMetadata[chainId]?.name;\n}\n\n"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AO3ClD,MAAM,oBAAsD;EACzD,QAAQ,KAAKA;EACb,KAAK,KAAKC;EACV,SAAS,KAAKC;EACd,SAAS,KAAKC;EACd,IAAI,KAAKC;EACT,QAAQ,KAAKC;CACf;;;;AAKD,SAAS,aAAa,OAAmC;CAEvD,MAAM,WAAW,MAAM;AAEvB,QAAO;EACL,SAAS,MAAM;EACf,SAAS,MAAM;EACf,QAAQ,MAAM;EACd,MAAM,MAAM;EACZ;EACA,SAAS,MAAM;EACf,MAAM;EACP;;;;;AAMH,SAAgB,cAAc,SAAmC;AAC/D,QAAO,kBAAkB,YAAY,EAAE;;;;;AAMzC,SAAgB,mBAAmB,SAA+B;AAEhE,QADgB,cAAc,QAAQ,CACvB,IAAI,aAAa;;;;;AAMlC,SAAgB,2BACd,SACA,SACsB;CAEtB,MAAM,QADU,cAAc,QAAQ,CAChB,MACnB,MAAM,EAAE,QAAQ,aAAa,KAAK,QAAQ,aAAa,CACzD;AACD,QAAO,QAAQ,aAAa,MAAM,GAAG;;;;;AAMvC,SAAgB,0BACd,SACA,QACsB;CAEtB,MAAM,QADU,cAAc,QAAQ,CAChB,MACnB,MAAM,EAAE,OAAO,aAAa,KAAK,OAAO,aAAa,CACvD;AACD,QAAO,QAAQ,aAAa,MAAM,GAAG;;;;;AAMvC,SAAgB,oBAAoB,SAAmC;AACrE,QAAO,cAAc,QAAQ;;;;;AAM/B,SAAgB,aAAa,SAA0B;AACrD,QAAO,WAAW;;;;;;;;;;;;;;AChGpB,SAAgB,eAAe,SAA+B;AAE5D,KAAI,aAAa,QAAQ,CACvB,QAAO,mBAAmB,QAAQ;CAIpC,MAAM,YAAY,yBAAyB,QAAQ;CACnD,MAAM,SAAuB,EAAE;AAE/B,MAAK,MAAM,CAAC,QAAQ,YAAY,OAAO,QAAQ,UAAU,EAAE;EACzD,MAAM,WAAW,wBAAwB,OAAO;AAEhD,MAAI,YAAY,QACd,QAAO,KAAK;GAAE,GAAG;GAAU;GAAS;GAAS,CAAC;;AAIlD,QAAO;;AAGT,SAAgB,cACd,SACA,QACsB;AAEtB,QADe,eAAe,QAAQ,CACxB,MACX,UAAU,MAAM,OAAO,aAAa,KAAK,OAAO,aAAa,CAC/D;;AAGH,SAAgB,uBACd,SACA,SACsB;AAEtB,QADe,eAAe,QAAQ,CACxB,MACX,UAAU,MAAM,QAAQ,aAAa,KAAK,QAAQ,aAAa,CACjE;;;;;;AAOH,SAAgB,gBACd,SACA,QACkB;AAElB,KAAI,aAAa,QAAQ,CAEvB,QADc,0BAA0B,SAAS,OAAO,EAC1C;AAIhB,QAAO,uBAAuB,SAAS,OAAO;;;;;;AAOhD,SAAgB,kBACd,SACwB;CACxB,MAAM,SAAS,eAAe,QAAQ;CACtC,MAAM,YAAoC,EAAE;AAE5C,MAAK,MAAM,SAAS,OAClB,WAAU,MAAM,OAAO,aAAa,IAAI,MAAM;AAGhD,QAAO;;;;;ACxFT,MAAa,YAAY,CAAC,GAAG,eAAe,GAAG,cAAc;AAI7D,MAAa,YAAY,IAAI,IAC3B,UAAU,KAAK,UAAU,CAAC,MAAM,IAAI,MAAM,CAAC,CAC5C;AAED,SAAgB,aAAa,SAAkC;AAC7D,QAAO,UAAU,IAAI,QAAQ;;AAG/B,SAAgB,eAAe,SAAwC;CACrE,MAAM,QAAQ,aAAa,QAAQ;AACnC,KAAI,CAAC,MAAO,QAAO;AAEnB,QAAO;EACL;EACA,WAAW,MAAM,WAAW;EAC5B,QAAQ,eAAe,MAAM,GAAG;EACjC;;AAGH,SAAgB,mBAAkC;AAChD,QAAO,cAAc,KAAK,WAAW;EACnC;EACA,WAAW;EACX,QAAQ,eAAe,MAAM,GAAG;EACjC,EAAE;;AAGL,SAAgB,mBAAkC;AAChD,QAAO,cAAc,KAAK,WAAW;EACnC;EACA,WAAW;EACX,QAAQ,eAAe,MAAM,GAAG;EACjC,EAAE;;AAGL,SAAgB,eAA8B;AAC5C,QAAO,CAAC,GAAG,kBAAkB,EAAE,GAAG,kBAAkB,CAAC;;AAGvD,SAAgB,iBAAiB,SAA0B;AACzD,QAAO,UAAU,IAAI,QAAQ;;;;;AClD/B,SAAgB,aACd,QACA,gBACA,iBACc;CACd,IAAI,SAAS;AAEb,KAAI,gBAAgB,SAAS,EAC3B,UAAS,OAAO,QACb,UAAU,CAAC,gBAAgB,SAAS,MAAM,OAAO,aAAa,CAAC,CACjE;AAGH,KAAI,kBAAkB,eAAe,SAAS,EAC5C,UAAS,OAAO,QAAQ,UACtB,eAAe,SAAS,MAAM,OAAO,aAAa,CAAC,CACpD;AAGH,QAAO;;;;;ACbT,SAAgB,gBAAgB,QAAiC;CAC/D,MAAM,4BAAY,IAAI,KAAyB;CAC/C,MAAM,2BAAW,IAAI,KAAyB;AAE9C,QAAO,SAAS,UAAU;AACxB,YAAU,IAAI,MAAM,QAAQ,aAAa,EAAE,MAAM;AACjD,WAAS,IAAI,MAAM,OAAO,aAAa,EAAE,MAAM;GAC/C;AAEF,QAAO;EAAE;EAAW;EAAU;;AAGhC,SAAgB,kBACd,MACA,SACsB;AACtB,KAAI,CAAC,QAAS,QAAO;AACrB,QAAO,KAAK,UAAU,IAAI,QAAQ,aAAa,CAAC;;AAGlD,SAAgB,iBACd,MACA,QACsB;AACtB,KAAI,CAAC,OAAQ,QAAO;AACpB,QAAO,KAAK,SAAS,IAAI,OAAO,aAAa,CAAC;;;;;;;;AC9BhD,MAAM,oBAAoB,CAAC,QAAQ,OAAO;;;;;;AAO1C,SAAgB,aAAa,QAAoC;AAC/D,KAAI,OAAO,WAAW,SACpB,QAAO,kBAAkB,SACvB,OACD;AAGH,QAAO,OAAO,OAAO,MACnB,kBAAkB,SAAS,EAAwC,CACpE;;;;;;;;;;;;;;;ACNH,MAAa,wBAAgD;CAE3D,GAAG;CACH,MAAM;CACN,OAAO;CACP,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,KAAK;CACN;;;;AAKD,MAAa,wBAAgD;CAC3D,UAAU;CACV,MAAM;CACN,UAAU;CACV,UAAU;CACV,uBAAuB;CACvB,UAAU;CACV,SAAS;CACV;;;;;;AAQD,SAAgB,kBAAkB,SAAmC;AACnE,QAAO,sBAAsB;;;;;;;AAQ/B,SAAgB,kBAAkB,UAAoC;AACpE,QAAO,sBAAsB;;;;;;;AAQ/B,SAAgB,uBAAuB,SAA0B;AAC/D,QAAO,WAAW;;;;;;AAOpB,SAAgB,6BAAuC;AACrD,QAAO,OAAO,KAAK,sBAAsB,CAAC,IAAI,OAAO;;;;;;AAOvD,SAAgB,oBAA8B;AAC5C,QAAO,OAAO,OAAO,sBAAsB;;;;;;;;;;;;;;AC7C7C,MAAa,gBAA+C;EACzD,QAAQ,KAAK;EACZ,MAAM;EACN,SAAS;EACV;EACA,KAAK,KAAK;EACT,MAAM;EACN,SAAS;EACV;EACA,SAAS,KAAK;EACb,MAAM;EACN,SAAS;EACV;EACA,SAAS,KAAK;EACb,MAAM;EACN,SAAS;EACV;EACA,IAAI,KAAK;EACR,MAAM;EACN,SAAS;EACV;EACA,QAAQ,KAAK;EACZ,MAAM;EACN,SAAS;EACV;EACA,UAAU,KAAK;EACd,MAAM;EACN,SAAS;EACV;EACA,SAAS,KAAK;EACb,MAAM;EACN,SAAS;EACV;EACA,QAAQ,KAAK,EACZ,MAAM,WACP;EACA,YAAY,KAAK,EAChB,MAAM,gBACP;EACA,YAAY,KAAK,EAChB,MAAM,gBACP;EACA,eAAe,KAAK,EACnB,MAAM,mBACP;EACA,aAAa,KAAK,EACjB,MAAM,iBACP;CACF;;;;;;AAOD,SAAgB,iBAAiB,SAA0C;AACzE,QAAO,cAAc;;;;;;;AAQvB,SAAgB,gBAAgB,SAAmC;AACjE,QAAO,cAAc,UAAU;;;;;;;AAQjC,SAAgB,oBAAoB,SAAmC;AACrE,QAAO,cAAc,UAAU"}

package/dist/{chunk-kSYXY2_d.js → chunk-BE-pF4vm.js}

@@ -1,4 +1,4 @@
-//#region rolldown:runtime
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;

package/dist/{client-factory-C3A4RPdj.d.ts → client-factory-B12uLPUI.d.ts}

@@ -1,4 +1,4 @@
-import { t as OtimEnvironment } from "./api-urls-SKeIQMoZ.js";
+import { t as OtimEnvironment } from "./api-urls-Dgxfefmy.js";
 import { AxiosInstance } from "axios";
 
 //#region src/server/client-factory.d.ts
@@ -19,4 +19,4 @@ type ApiClient = AxiosInstance;
 declare function createApiClient(config: ApiClientConfig): ApiClient;
 //#endregion
 export { ApiClientConfig as n, createApiClient as r, ApiClient as t };
-//# sourceMappingURL=client-factory-C3A4RPdj.d.ts.map
+//# sourceMappingURL=client-factory-B12uLPUI.d.ts.map

package/dist/client-factory-B12uLPUI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-factory-B12uLPUI.d.ts","names":[],"sources":["../src/server/client-factory.ts"],"mappings":";;;;UAUiB,eAAA;EAEf,WAAA,EAAa,eAAA;EAEb,eAAA,SAAwB,OAAA;EAExB,OAAA;EAEA,OAAA;AAAA;AAAA,KAIU,SAAA,GAAY,aAAA;;;;;;;;iBAsBR,eAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,SAAA"}

package/dist/{client-factory-7xUSPC9I.mjs → client-factory-DY6UNuuV.mjs}

@@ -1,4 +1,4 @@
-import { a as getPlatformApiUrl } from "./api-urls-DJcIKBCy.mjs";
+import { a as getPlatformApiUrl } from "./api-urls-B6RnXSRD.mjs";
 import axios from "axios";
 import { isString, logger } from "@otim/utils/helpers";
 
@@ -39,4 +39,4 @@ function createApiClient(config) {
 
 //#endregion
 export { createApiClient as t };
-//# sourceMappingURL=client-factory-7xUSPC9I.mjs.map
+//# sourceMappingURL=client-factory-DY6UNuuV.mjs.map

package/dist/{client-factory-7xUSPC9I.mjs.map → client-factory-DY6UNuuV.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"client-factory-7xUSPC9I.mjs","names":[],"sources":["../src/server/client-factory.ts"],"sourcesContent":["import type { OtimEnvironment } from \"../config/api-urls\";\nimport type { AxiosInstance } from \"axios\";\n\nimport axios from \"axios\";\n\nimport { isString, logger } from \"@otim/utils/helpers\";\n\nimport { getPlatformApiUrl } from \"../config/api-urls\";\n\n/* Configuration for creating an API client instance */\nexport interface ApiClientConfig {\n  /* Required: The environment to use (sandbox or production) */\n  environment: OtimEnvironment;\n  /* Optional: Custom auth token getter for this client instance */\n  authTokenGetter?: () => Promise<string | undefined>;\n  /* Optional: Override the base URL (defaults to environment URL) */\n  baseURL?: string;\n  /* Optional: Request timeout in milliseconds (default: 30000) */\n  timeout?: number;\n}\n\n/* Type alias for the API client instance */\nexport type ApiClient = AxiosInstance;\n\n/* Gets the Platform API URL for the specified environment */\nfunction getApiUrlForEnvironment(environment: OtimEnvironment): string {\n  const url = getPlatformApiUrl(environment);\n\n  if (!isString(url) || url.trim() === \"\") {\n    const errorMessage = `Invalid API URL for environment: ${environment}`;\n    logger.error(errorMessage, { context: \"API Client Factory\" });\n    throw new Error(errorMessage);\n  }\n\n  return url;\n}\n\n/**\n * Creates a new API client instance with the specified configuration.\n * Each client is independent and can have its own auth token getter.\n *\n * @param config - The configuration for the API client\n * @returns An axios instance configured for the specified environment\n */\nexport function createApiClient(config: ApiClientConfig): ApiClient {\n  const { environment, authTokenGetter, timeout = 30000 } = config;\n\n  const baseURL = config.baseURL ?? getApiUrlForEnvironment(environment);\n\n  const client = axios.create({\n    baseURL,\n    timeout,\n  });\n\n  // Setup auth token interceptor if provided\n  if (authTokenGetter) {\n    client.interceptors.request.use(async (requestConfig) => {\n      const token = await authTokenGetter();\n      if (token) {\n        requestConfig.headers = requestConfig.headers ?? {};\n        requestConfig.headers.Authorization = `Bearer ${token}`;\n      }\n      return requestConfig;\n    });\n  }\n\n  return client;\n}\n"],"mappings":";;;;;AAyBA,SAAS,wBAAwB,aAAsC;CACrE,MAAM,MAAM,kBAAkB,YAAY;AAE1C,KAAI,CAAC,SAAS,IAAI,IAAI,IAAI,MAAM,KAAK,IAAI;EACvC,MAAM,eAAe,oCAAoC;AACzD,SAAO,MAAM,cAAc,EAAE,SAAS,sBAAsB,CAAC;AAC7D,QAAM,IAAI,MAAM,aAAa;;AAG/B,QAAO;;;;;;;;;AAUT,SAAgB,gBAAgB,QAAoC;CAClE,MAAM,EAAE,aAAa,iBAAiB,UAAU,QAAU;CAE1D,MAAM,UAAU,OAAO,WAAW,wBAAwB,YAAY;CAEtE,MAAM,SAAS,MAAM,OAAO;EAC1B;EACA;EACD,CAAC;AAGF,KAAI,gBACF,QAAO,aAAa,QAAQ,IAAI,OAAO,kBAAkB;EACvD,MAAM,QAAQ,MAAM,iBAAiB;AACrC,MAAI,OAAO;AACT,iBAAc,UAAU,cAAc,WAAW,EAAE;AACnD,iBAAc,QAAQ,gBAAgB,UAAU;;AAElD,SAAO;GACP;AAGJ,QAAO"}
+{"version":3,"file":"client-factory-DY6UNuuV.mjs","names":[],"sources":["../src/server/client-factory.ts"],"sourcesContent":["import type { OtimEnvironment } from \"../config/api-urls\";\nimport type { AxiosInstance } from \"axios\";\n\nimport axios from \"axios\";\n\nimport { isString, logger } from \"@otim/utils/helpers\";\n\nimport { getPlatformApiUrl } from \"../config/api-urls\";\n\n/* Configuration for creating an API client instance */\nexport interface ApiClientConfig {\n  /* Required: The environment to use (sandbox or production) */\n  environment: OtimEnvironment;\n  /* Optional: Custom auth token getter for this client instance */\n  authTokenGetter?: () => Promise<string | undefined>;\n  /* Optional: Override the base URL (defaults to environment URL) */\n  baseURL?: string;\n  /* Optional: Request timeout in milliseconds (default: 30000) */\n  timeout?: number;\n}\n\n/* Type alias for the API client instance */\nexport type ApiClient = AxiosInstance;\n\n/* Gets the Platform API URL for the specified environment */\nfunction getApiUrlForEnvironment(environment: OtimEnvironment): string {\n  const url = getPlatformApiUrl(environment);\n\n  if (!isString(url) || url.trim() === \"\") {\n    const errorMessage = `Invalid API URL for environment: ${environment}`;\n    logger.error(errorMessage, { context: \"API Client Factory\" });\n    throw new Error(errorMessage);\n  }\n\n  return url;\n}\n\n/**\n * Creates a new API client instance with the specified configuration.\n * Each client is independent and can have its own auth token getter.\n *\n * @param config - The configuration for the API client\n * @returns An axios instance configured for the specified environment\n */\nexport function createApiClient(config: ApiClientConfig): ApiClient {\n  const { environment, authTokenGetter, timeout = 30000 } = config;\n\n  const baseURL = config.baseURL ?? getApiUrlForEnvironment(environment);\n\n  const client = axios.create({\n    baseURL,\n    timeout,\n  });\n\n  // Setup auth token interceptor if provided\n  if (authTokenGetter) {\n    client.interceptors.request.use(async (requestConfig) => {\n      const token = await authTokenGetter();\n      if (token) {\n        requestConfig.headers = requestConfig.headers ?? {};\n        requestConfig.headers.Authorization = `Bearer ${token}`;\n      }\n      return requestConfig;\n    });\n  }\n\n  return client;\n}\n"],"mappings":";;;;;AAyBA,SAAS,wBAAwB,aAAsC;CACrE,MAAM,MAAM,kBAAkB,YAAY;AAE1C,KAAI,CAAC,SAAS,IAAI,IAAI,IAAI,MAAM,KAAK,IAAI;EACvC,MAAM,eAAe,oCAAoC;AACzD,SAAO,MAAM,cAAc,EAAE,SAAS,sBAAsB,CAAC;AAC7D,QAAM,IAAI,MAAM,aAAa;;AAG/B,QAAO;;;;;;;;;AAUT,SAAgB,gBAAgB,QAAoC;CAClE,MAAM,EAAE,aAAa,iBAAiB,UAAU,QAAU;CAE1D,MAAM,UAAU,OAAO,WAAW,wBAAwB,YAAY;CAEtE,MAAM,SAAS,MAAM,OAAO;EAC1B;EACA;EACD,CAAC;AAGF,KAAI,gBACF,QAAO,aAAa,QAAQ,IAAI,OAAO,kBAAkB;EACvD,MAAM,QAAQ,MAAM,iBAAiB;AACrC,MAAI,OAAO;AACT,iBAAc,UAAU,cAAc,WAAW,EAAE;AACnD,iBAAc,QAAQ,gBAAgB,UAAU;;AAElD,SAAO;GACP;AAGJ,QAAO"}

package/dist/{client-factory-CTI_Nt35.js → client-factory-Drsy2vfF.js}

@@ -1,4 +1,4 @@
-const require_chunk = require('./chunk-kSYXY2_d.js');
+const require_chunk = require('./chunk-BE-pF4vm.js');
 const require_api_urls = require('./api-urls-Cd20DG4i.js');
 let axios = require("axios");
 axios = require_chunk.__toESM(axios);
@@ -46,4 +46,4 @@ Object.defineProperty(exports, 'createApiClient', {
     return createApiClient;
   }
 });
-//# sourceMappingURL=client-factory-CTI_Nt35.js.map
+//# sourceMappingURL=client-factory-Drsy2vfF.js.map

package/dist/{client-factory-CTI_Nt35.js.map → client-factory-Drsy2vfF.js.map}

@@ -1 +1 @@
-{"version":3,"file":"client-factory-CTI_Nt35.js","names":["getPlatformApiUrl"],"sources":["../src/server/client-factory.ts"],"sourcesContent":["import type { OtimEnvironment } from \"../config/api-urls\";\nimport type { AxiosInstance } from \"axios\";\n\nimport axios from \"axios\";\n\nimport { isString, logger } from \"@otim/utils/helpers\";\n\nimport { getPlatformApiUrl } from \"../config/api-urls\";\n\n/* Configuration for creating an API client instance */\nexport interface ApiClientConfig {\n  /* Required: The environment to use (sandbox or production) */\n  environment: OtimEnvironment;\n  /* Optional: Custom auth token getter for this client instance */\n  authTokenGetter?: () => Promise<string | undefined>;\n  /* Optional: Override the base URL (defaults to environment URL) */\n  baseURL?: string;\n  /* Optional: Request timeout in milliseconds (default: 30000) */\n  timeout?: number;\n}\n\n/* Type alias for the API client instance */\nexport type ApiClient = AxiosInstance;\n\n/* Gets the Platform API URL for the specified environment */\nfunction getApiUrlForEnvironment(environment: OtimEnvironment): string {\n  const url = getPlatformApiUrl(environment);\n\n  if (!isString(url) || url.trim() === \"\") {\n    const errorMessage = `Invalid API URL for environment: ${environment}`;\n    logger.error(errorMessage, { context: \"API Client Factory\" });\n    throw new Error(errorMessage);\n  }\n\n  return url;\n}\n\n/**\n * Creates a new API client instance with the specified configuration.\n * Each client is independent and can have its own auth token getter.\n *\n * @param config - The configuration for the API client\n * @returns An axios instance configured for the specified environment\n */\nexport function createApiClient(config: ApiClientConfig): ApiClient {\n  const { environment, authTokenGetter, timeout = 30000 } = config;\n\n  const baseURL = config.baseURL ?? getApiUrlForEnvironment(environment);\n\n  const client = axios.create({\n    baseURL,\n    timeout,\n  });\n\n  // Setup auth token interceptor if provided\n  if (authTokenGetter) {\n    client.interceptors.request.use(async (requestConfig) => {\n      const token = await authTokenGetter();\n      if (token) {\n        requestConfig.headers = requestConfig.headers ?? {};\n        requestConfig.headers.Authorization = `Bearer ${token}`;\n      }\n      return requestConfig;\n    });\n  }\n\n  return client;\n}\n"],"mappings":";;;;;;;AAyBA,SAAS,wBAAwB,aAAsC;CACrE,MAAM,MAAMA,mCAAkB,YAAY;AAE1C,KAAI,mCAAU,IAAI,IAAI,IAAI,MAAM,KAAK,IAAI;EACvC,MAAM,eAAe,oCAAoC;AACzD,6BAAO,MAAM,cAAc,EAAE,SAAS,sBAAsB,CAAC;AAC7D,QAAM,IAAI,MAAM,aAAa;;AAG/B,QAAO;;;;;;;;;AAUT,SAAgB,gBAAgB,QAAoC;CAClE,MAAM,EAAE,aAAa,iBAAiB,UAAU,QAAU;CAE1D,MAAM,UAAU,OAAO,WAAW,wBAAwB,YAAY;CAEtE,MAAM,SAAS,cAAM,OAAO;EAC1B;EACA;EACD,CAAC;AAGF,KAAI,gBACF,QAAO,aAAa,QAAQ,IAAI,OAAO,kBAAkB;EACvD,MAAM,QAAQ,MAAM,iBAAiB;AACrC,MAAI,OAAO;AACT,iBAAc,UAAU,cAAc,WAAW,EAAE;AACnD,iBAAc,QAAQ,gBAAgB,UAAU;;AAElD,SAAO;GACP;AAGJ,QAAO"}
+{"version":3,"file":"client-factory-Drsy2vfF.js","names":["getPlatformApiUrl"],"sources":["../src/server/client-factory.ts"],"sourcesContent":["import type { OtimEnvironment } from \"../config/api-urls\";\nimport type { AxiosInstance } from \"axios\";\n\nimport axios from \"axios\";\n\nimport { isString, logger } from \"@otim/utils/helpers\";\n\nimport { getPlatformApiUrl } from \"../config/api-urls\";\n\n/* Configuration for creating an API client instance */\nexport interface ApiClientConfig {\n  /* Required: The environment to use (sandbox or production) */\n  environment: OtimEnvironment;\n  /* Optional: Custom auth token getter for this client instance */\n  authTokenGetter?: () => Promise<string | undefined>;\n  /* Optional: Override the base URL (defaults to environment URL) */\n  baseURL?: string;\n  /* Optional: Request timeout in milliseconds (default: 30000) */\n  timeout?: number;\n}\n\n/* Type alias for the API client instance */\nexport type ApiClient = AxiosInstance;\n\n/* Gets the Platform API URL for the specified environment */\nfunction getApiUrlForEnvironment(environment: OtimEnvironment): string {\n  const url = getPlatformApiUrl(environment);\n\n  if (!isString(url) || url.trim() === \"\") {\n    const errorMessage = `Invalid API URL for environment: ${environment}`;\n    logger.error(errorMessage, { context: \"API Client Factory\" });\n    throw new Error(errorMessage);\n  }\n\n  return url;\n}\n\n/**\n * Creates a new API client instance with the specified configuration.\n * Each client is independent and can have its own auth token getter.\n *\n * @param config - The configuration for the API client\n * @returns An axios instance configured for the specified environment\n */\nexport function createApiClient(config: ApiClientConfig): ApiClient {\n  const { environment, authTokenGetter, timeout = 30000 } = config;\n\n  const baseURL = config.baseURL ?? getApiUrlForEnvironment(environment);\n\n  const client = axios.create({\n    baseURL,\n    timeout,\n  });\n\n  // Setup auth token interceptor if provided\n  if (authTokenGetter) {\n    client.interceptors.request.use(async (requestConfig) => {\n      const token = await authTokenGetter();\n      if (token) {\n        requestConfig.headers = requestConfig.headers ?? {};\n        requestConfig.headers.Authorization = `Bearer ${token}`;\n      }\n      return requestConfig;\n    });\n  }\n\n  return client;\n}\n"],"mappings":";;;;;;;AAyBA,SAAS,wBAAwB,aAAsC;CACrE,MAAM,MAAMA,mCAAkB,YAAY;AAE1C,KAAI,mCAAU,IAAI,IAAI,IAAI,MAAM,KAAK,IAAI;EACvC,MAAM,eAAe,oCAAoC;AACzD,6BAAO,MAAM,cAAc,EAAE,SAAS,sBAAsB,CAAC;AAC7D,QAAM,IAAI,MAAM,aAAa;;AAG/B,QAAO;;;;;;;;;AAUT,SAAgB,gBAAgB,QAAoC;CAClE,MAAM,EAAE,aAAa,iBAAiB,UAAU,QAAU;CAE1D,MAAM,UAAU,OAAO,WAAW,wBAAwB,YAAY;CAEtE,MAAM,SAAS,cAAM,OAAO;EAC1B;EACA;EACD,CAAC;AAGF,KAAI,gBACF,QAAO,aAAa,QAAQ,IAAI,OAAO,kBAAkB;EACvD,MAAM,QAAQ,MAAM,iBAAiB;AACrC,MAAI,OAAO;AACT,iBAAc,UAAU,cAAc,WAAW,EAAE;AACnD,iBAAc,QAAQ,gBAAgB,UAAU;;AAElD,SAAO;GACP;AAGJ,QAAO"}

package/dist/{client-factory-DOL0ZTWy.d.mts → client-factory-Dt4S4yZY.d.mts}

@@ -1,4 +1,4 @@
-import { t as OtimEnvironment } from "./api-urls-B-GTEiT3.mjs";
+import { t as OtimEnvironment } from "./api-urls-DacG9Q5P.mjs";
 import { AxiosInstance } from "axios";
 
 //#region src/server/client-factory.d.ts
@@ -19,4 +19,4 @@ type ApiClient = AxiosInstance;
 declare function createApiClient(config: ApiClientConfig): ApiClient;
 //#endregion
 export { ApiClientConfig as n, createApiClient as r, ApiClient as t };
-//# sourceMappingURL=client-factory-DOL0ZTWy.d.mts.map
+//# sourceMappingURL=client-factory-Dt4S4yZY.d.mts.map

package/dist/client-factory-Dt4S4yZY.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-factory-Dt4S4yZY.d.mts","names":[],"sources":["../src/server/client-factory.ts"],"mappings":";;;;UAUiB,eAAA;EAEf,WAAA,EAAa,eAAA;EAEb,eAAA,SAAwB,OAAA;EAExB,OAAA;EAEA,OAAA;AAAA;AAAA,KAIU,SAAA,GAAY,aAAA;;;;;;;;iBAsBR,eAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,SAAA"}

package/dist/constants.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.mts","names":[],"sources":["../src/constants.ts"],"sourcesContent":[],"mappings":";;AAOA;AACA;AAGA;AAGA;AACA;AACA;AAEa,cAXA,yBAAA,GAWkB,cAAA;AAGlB,cAbA,yBAAA,GAaK,OAAA;AAGL,cAbA,sBAAA,GAa0B,EAAA;AAC1B,cAXA,OAAA,GAWe,kBAAA;cAVf,OAAA;cACA,kBAAA;cAEA,kBAAA;cAGA,KAAA;cAGA,0BAAA;cACA,eAAA"}
+{"version":3,"file":"constants.d.mts","names":[],"sources":["../src/constants.ts"],"mappings":";;AAOA;;;;;AACA;cADa,yBAAA;AAAA,cACA,yBAAA;AAAA,cAGA,sBAAA;AAAA,cAGA,OAAA;AAAA,cACA,OAAA;AAAA,cACA,kBAAA;AAAA,cAEA,kBAAA;AAAA,cAGA,KAAA;AAAA,cAGA,0BAAA;AAAA,cACA,eAAA"}

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","names":[],"sources":["../src/constants.ts"],"sourcesContent":[],"mappings":";;AAOA;AACA;AAGA;AAGA;AACA;AACA;AAEa,cAXA,yBAAA,GAWkB,cAAA;AAGlB,cAbA,yBAAA,GAaK,OAAA;AAGL,cAbA,sBAAA,GAa0B,EAAA;AAC1B,cAXA,OAAA,GAWe,kBAAA;cAVf,OAAA;cACA,kBAAA;cAEA,kBAAA;cAGA,KAAA;cAGA,0BAAA;cACA,eAAA"}
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../src/constants.ts"],"mappings":";;AAOA;;;;;AACA;cADa,yBAAA;AAAA,cACA,yBAAA;AAAA,cAGA,sBAAA;AAAA,cAGA,OAAA;AAAA,cACA,OAAA;AAAA,cACA,kBAAA;AAAA,cAEA,kBAAA;AAAA,cAGA,KAAA;AAAA,cAGA,0BAAA;AAAA,cACA,eAAA"}

package/dist/constants.js

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/constants.ts
 /**

package/dist/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Cookies\n *\n * @description\n * These cookies are used to store the user's authentication token,\n * preferences, and session information.\n */\nexport const SESSION_TOKEN_COOKIE_NAME = \"sessionToken\";\nexport const SESSION_THEME_COOKIE_NAME = \"theme\";\n\n/* Pagination */\nexport const DEFAULT_ITEMS_PER_PAGE = 50;\n\n/* URLs */\nexport const APP_URL = \"https://otim.com\";\nexport const TAC_URL = `${APP_URL}/tac`;\nexport const PRIVACY_POLICY_URL = `${APP_URL}/pp`;\n\nexport const TELEGRAM_GROUP_URL = \"https://t.me/otimlabs\";\n\n/* Network Constants */\nexport const ERC20 = \"ERC20\";\n\n/* Wallet */\nexport const WAGMI_RECENT_CONNECTOR_KEY = \"wagmi.recentConnectorId\";\nexport const WAGMI_STORE_KEY = \"wagmi.store\";\n"],"mappings":";;;;;;;;;AAOA,MAAa,4BAA4B;AACzC,MAAa,4BAA4B;AAGzC,MAAa,yBAAyB;AAGtC,MAAa,UAAU;AACvB,MAAa,UAAU,GAAG,QAAQ;AAClC,MAAa,qBAAqB,GAAG,QAAQ;AAE7C,MAAa,qBAAqB;AAGlC,MAAa,QAAQ;AAGrB,MAAa,6BAA6B;AAC1C,MAAa,kBAAkB"}
+{"version":3,"file":"constants.js","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Cookies\n *\n * @description\n * These cookies are used to store the user's authentication token,\n * preferences, and session information.\n */\nexport const SESSION_TOKEN_COOKIE_NAME = \"sessionToken\";\nexport const SESSION_THEME_COOKIE_NAME = \"theme\";\n\n/* Pagination */\nexport const DEFAULT_ITEMS_PER_PAGE = 50;\n\n/* URLs */\nexport const APP_URL = \"https://otim.com\";\nexport const TAC_URL = `${APP_URL}/tac`;\nexport const PRIVACY_POLICY_URL = `${APP_URL}/pp`;\n\nexport const TELEGRAM_GROUP_URL = \"https://t.me/otimlabs\";\n\n/* Network Constants */\nexport const ERC20 = \"ERC20\";\n\n/* Wallet */\nexport const WAGMI_RECENT_CONNECTOR_KEY = \"wagmi.recentConnectorId\";\nexport const WAGMI_STORE_KEY = \"wagmi.store\";\n"],"mappings":";;;;;;;;;;AAOA,MAAa,4BAA4B;AACzC,MAAa,4BAA4B;AAGzC,MAAa,yBAAyB;AAGtC,MAAa,UAAU;AACvB,MAAa,UAAU,GAAG,QAAQ;AAClC,MAAa,qBAAqB,GAAG,QAAQ;AAE7C,MAAa,qBAAqB;AAGlC,MAAa,QAAQ;AAGrB,MAAa,6BAA6B;AAC1C,MAAa,kBAAkB"}

package/dist/{date-gBac-Om9.mjs → date-BGw9dSBT.mjs}

@@ -310,4 +310,4 @@ const validateIso8601Date = (dueDate) => {
 
 //#endregion
 export { isError as A, safeFormatDate as C, extractString as D, extractNumber as E, isObject as F, isString as I, isUndefined as L, isNotNull as M, isNull as N, isBoolean as O, isNumber as P, parseDateTime as S, logger as T, isDateInRange as _, formatDateToYYYYMMDD as a, isValidDate as b, formatLongDateTime as c, formatToShortDate as d, formatToShortDateWithYear as f, isDateInPast as g, isDateEpoc as h, formatDateTime as i, isFunction as j, isEmpty as k, formatTime as l, getRelativeDateDescription as m, formatDateAsISO as n, formatFullDate as o, getPluralizedUnit as p, formatDateAsUSStandard as r, formatLongDate as s, TimeUnit as t, formatToJustDate as u, isDateInvalid as v, validateIso8601Date as w, iso8601DateSchema as x, isSameDate as y };
-//# sourceMappingURL=date-gBac-Om9.mjs.map
+//# sourceMappingURL=date-BGw9dSBT.mjs.map