@otim/utils 0.0.11 → 0.0.13

package/dist/chains/index.js

@@ -1,7 +1,9 @@
-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");
+let viem = require("viem");
 
 //#region src/chains/config/custom-chains.ts
 const pecorinoSignet = {
@@ -48,8 +50,6 @@ const supportedChains = {
 		mainnet: viem_chains.mainnet,
 		base: viem_chains.base,
 		arbitrum: viem_chains.arbitrum,
-		optimism: viem_chains.optimism,
-		bsc: viem_chains.bsc,
 		polygon: viem_chains.polygon
 	},
 	testnet: {
@@ -132,34 +132,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] || {};
@@ -3483,6 +3483,25 @@ function isStablecoin(symbol) {
 	return symbol.every((s) => stablecoinSymbols.includes(s));
 }
 
+//#endregion
+//#region src/chains/transport.ts
+/**
+* Default custom RPC URL overrides per chain ID.
+* Used by {@link getChainTransport} when no caller-provided override exists.
+*/
+const customRpcUrls = { [viem_chains.polygon.id]: "https://polygon.drpc.org" };
+/**
+* Returns an HTTP transport for the given chain.
+* Resolves the RPC URL in priority order:
+*   1. Caller-provided `overrides`
+*   2. {@link customRpcUrls} defaults
+*   3. viem's built-in public RPC (bare `http()`)
+*/
+function getChainTransport(chainId, overrides) {
+	const rpcUrl = overrides?.[chainId] ?? customRpcUrls[chainId];
+	return rpcUrl ? (0, viem.http)(rpcUrl) : (0, viem.http)();
+}
+
 //#endregion
 //#region src/chains/lambda/chain-mapping.ts
 /**
@@ -3639,6 +3658,7 @@ exports.chainById = chainById;
 exports.chainIdToLambdaId = chainIdToLambdaId;
 exports.chainMetadata = chainMetadata;
 exports.createTokenMaps = createTokenMaps;
+exports.customRpcUrls = customRpcUrls;
 exports.filterTokens = filterTokens;
 exports.getAllChains = getAllChains;
 exports.getChainById = getChainById;
@@ -3649,6 +3669,7 @@ exports.getChainMetadata = getChainMetadata;
 exports.getChainToken = getChainToken;
 exports.getChainTokenByAddress = getChainTokenByAddress;
 exports.getChainTokens = getChainTokens;
+exports.getChainTransport = getChainTransport;
 exports.getDefaultChain = getDefaultChain;
 exports.getDefaultChainId = getDefaultChainId;
 exports.getLambdaChainIds = getLambdaChainIds;

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","polygon","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/transport.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    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 { http } from \"viem\";\nimport { polygon } from \"viem/chains\";\n\nexport type ChainRpcOverrides = Readonly<Record<number, string>>;\n\n/**\n * Default custom RPC URL overrides per chain ID.\n * Used by {@link getChainTransport} when no caller-provided override exists.\n */\nexport const customRpcUrls: ChainRpcOverrides = {\n  [polygon.id]: \"https://polygon.drpc.org\",\n} as const;\n\n/**\n * Returns an HTTP transport for the given chain.\n * Resolves the RPC URL in priority order:\n *   1. Caller-provided `overrides`\n *   2. {@link customRpcUrls} defaults\n *   3. viem's built-in public RPC (bare `http()`)\n */\nexport function getChainTransport(\n  chainId: number,\n  overrides?: ChainRpcOverrides,\n) {\n  const rpcUrl = overrides?.[chainId] ?? customRpcUrls[chainId];\n  return rpcUrl ? http(rpcUrl) : http();\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,6 +1,7 @@
-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";
+import { http } from "viem";
 
 //#region src/chains/config/custom-chains.ts
 const pecorinoSignet = {
@@ -47,8 +48,6 @@ const supportedChains = {
 		mainnet,
 		base,
 		arbitrum,
-		optimism,
-		bsc,
 		polygon
 	},
 	testnet: {
@@ -3482,6 +3481,25 @@ function isStablecoin(symbol) {
 	return symbol.every((s) => stablecoinSymbols.includes(s));
 }
 
+//#endregion
+//#region src/chains/transport.ts
+/**
+* Default custom RPC URL overrides per chain ID.
+* Used by {@link getChainTransport} when no caller-provided override exists.
+*/
+const customRpcUrls = { [polygon.id]: "https://polygon.drpc.org" };
+/**
+* Returns an HTTP transport for the given chain.
+* Resolves the RPC URL in priority order:
+*   1. Caller-provided `overrides`
+*   2. {@link customRpcUrls} defaults
+*   3. viem's built-in public RPC (bare `http()`)
+*/
+function getChainTransport(chainId, overrides) {
+	const rpcUrl = overrides?.[chainId] ?? customRpcUrls[chainId];
+	return rpcUrl ? http(rpcUrl) : http();
+}
+
 //#endregion
 //#region src/chains/lambda/chain-mapping.ts
 /**
@@ -3630,5 +3648,5 @@ function getChainDisplayName(chainId) {
 }
 
 //#endregion
-export { CHAIN_ID_TO_LAMBDA_ID, LAMBDA_ID_TO_CHAIN_ID, allChains, allSupportedChains, chainById, chainIdToLambdaId, chainMetadata, createTokenMaps, filterTokens, getAllChains, getChainById, getChainConfig, getChainDisplayName, getChainIconUrl, getChainMetadata, getChainToken, getChainTokenByAddress, getChainTokens, getDefaultChain, getDefaultChainId, getLambdaChainIds, getLambdaSupportedChainIds, getMainnetChain, getMainnetChains, getTestnetChain, getTestnetChains, getTestnetTokenAddress, getTestnetTokenAddresses, getTestnetTokenMetadata, getTokenAddress, getTokenAddresses, getTokenByAddress, getTokenBySymbol, getTokenListEntries, getTokenListTokenByAddress, getTokenListTokenBySymbol, getTokenListTokens, hasTokenList, isLambdaSupportedChain, isMainnetChain, isStablecoin, isSupportedChain, isTestnetChain, isTestnetTokenSupported, lambdaIdToChainId, loadTokenList, mainnetChains, mainnetChainsById, pecorinoHost, pecorinoSignet, supportedChains, testnetChains, testnetChainsById, testnetTokenAddresses, testnetTokenMetadata };
+export { CHAIN_ID_TO_LAMBDA_ID, LAMBDA_ID_TO_CHAIN_ID, allChains, allSupportedChains, chainById, chainIdToLambdaId, chainMetadata, createTokenMaps, customRpcUrls, filterTokens, getAllChains, getChainById, getChainConfig, getChainDisplayName, getChainIconUrl, getChainMetadata, getChainToken, getChainTokenByAddress, getChainTokens, getChainTransport, getDefaultChain, getDefaultChainId, getLambdaChainIds, getLambdaSupportedChainIds, getMainnetChain, getMainnetChains, getTestnetChain, getTestnetChains, getTestnetTokenAddress, getTestnetTokenAddresses, getTestnetTokenMetadata, getTokenAddress, getTokenAddresses, getTokenByAddress, getTokenBySymbol, getTokenListEntries, getTokenListTokenByAddress, getTokenListTokenBySymbol, getTokenListTokens, hasTokenList, isLambdaSupportedChain, isMainnetChain, isStablecoin, isSupportedChain, isTestnetChain, isTestnetTokenSupported, lambdaIdToChainId, loadTokenList, mainnetChains, mainnetChainsById, pecorinoHost, pecorinoSignet, supportedChains, testnetChains, testnetChainsById, testnetTokenAddresses, testnetTokenMetadata };
 //# sourceMappingURL=index.mjs.map

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/transport.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    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 { http } from \"viem\";\nimport { polygon } from \"viem/chains\";\n\nexport type ChainRpcOverrides = Readonly<Record<number, string>>;\n\n/**\n * Default custom RPC URL overrides per chain ID.\n * Used by {@link getChainTransport} when no caller-provided override exists.\n */\nexport const customRpcUrls: ChainRpcOverrides = {\n  [polygon.id]: \"https://polygon.drpc.org\",\n} as const;\n\n/**\n * Returns an HTTP transport for the given chain.\n * Resolves the RPC URL in priority order:\n *   1. Caller-provided `overrides`\n *   2. {@link customRpcUrls} defaults\n *   3. viem's built-in public RPC (bare `http()`)\n */\nexport function getChainTransport(\n  chainId: number,\n  overrides?: ChainRpcOverrides,\n) {\n  const rpcUrl = overrides?.[chainId] ?? customRpcUrls[chainId];\n  return rpcUrl ? http(rpcUrl) : http();\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;;;;;;;;;ACVH,MAAa,gBAAmC,GAC7C,QAAQ,KAAK,4BACf;;;;;;;;AASD,SAAgB,kBACd,SACA,WACA;CACA,MAAM,SAAS,YAAY,YAAY,cAAc;AACrD,QAAO,SAAS,KAAK,OAAO,GAAG,MAAM;;;;;;;;;;;;;;;ACZvC,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"}