@heyanon/sdk 2.3.2 → 2.3.3

package/dist/adapter/misc.d.ts

@@ -1,14 +1,49 @@
+/**
+ * Tags for categorizing different types of adapters in the ecosystem
+ * @enum AdapterTag
+ * @example
+ * ```typescript
+ * // Using in adapter configuration
+ * const swapAdapter: AdapterExport = {
+ *   tags: [AdapterTag.DEX, AdapterTag.LP],
+ *   // ... other properties
+ * };
+ *
+ * // Filtering adapters by tag
+ * const dexAdapters = adapters.filter(adapter =>
+ *   adapter.tags.includes(AdapterTag.DEX)
+ * );
+ *
+ * // Multiple tags for complex protocols
+ * const compoundAdapter = {
+ *   tags: [AdapterTag.LENDING, AdapterTag.FARM],
+ *   // ... other properties
+ * };
+ * ```
+ */
 export declare enum AdapterTag {
+    /** Automated Liquidity Management protocols */
     ALM = "ALM",
+    /** Staking protocols and validators */
     STAKE = "Stake",
+    /** Lending and borrowing protocols */
     LENDING = "Lending",
+    /** Yield farming and liquidity mining */
     FARM = "Farm",
+    /** Perpetual trading and derivatives */
     PERPETUALS = "Perpetuals",
+    /** Cross-chain bridges */
     BRIDGE = "Bridge",
+    /** Limit order protocols */
     LIMIT_ORDER = "Limit orders",
+    /** Decentralized exchanges */
     DEX = "DEX",
+    /** Liquidity provision protocols */
     LP = "LP",
+    /** Gaming and GameFi protocols */
     GAMES = "Games",
+    /** Centralized exchange integrations */
     CEX = "CEX",
+    /** Token launchpads and IDO platforms */
     LAUNCHPAD = "Launchpad"
 }

package/dist/adapter/transformers/toResult.d.ts

@@ -1,2 +1,26 @@
 import { FunctionReturn } from '../types';
+/**
+ * Transforms data into a standardized FunctionReturn format
+ * @param data - The data to transform (string, object, or array)
+ * @param error - Whether this represents an error state (default: false)
+ * @returns Standardized function result with success status and formatted data
+ * @example
+ * ```typescript
+ * // Success case with string data
+ * const result = toResult("Transaction completed");
+ * // { success: true, data: "Transaction completed" }
+ *
+ * // Success case with object data
+ * const result = toResult({ hash: "0x123", amount: "100" });
+ * // { success: true, data: '{"hash":"0x123","amount":"100"}' }
+ *
+ * // Error case
+ * const result = toResult("Network timeout", true);
+ * // { success: false, data: "ERROR: Network timeout" }
+ *
+ * // Error case with object
+ * const result = toResult({ code: 404, message: "Not found" }, true);
+ * // { success: false, data: 'ERROR: {"code":404,"message":"Not found"}' }
+ * ```
+ */
 export declare function toResult(data: string | Object | Array<any>, error?: boolean): FunctionReturn;

package/dist/adapter/types.d.ts

@@ -6,59 +6,175 @@ import { AdapterTag } from './misc';
 import { Address as TonAddress } from '@ton/ton';
 import { DeployContractProps } from '../blockchain/evm/types';
 import { Exchange, exchanges } from 'ccxt';
+/**
+ * Result of adapter function execution
+ * @interface FunctionReturn
+ * @example
+ * ```typescript
+ * const result: FunctionReturn = {
+ *   success: true,
+ *   data: "Transaction hash: 0x123..."
+ * };
+ * ```
+ */
 export interface FunctionReturn {
+    /** Success status of the operation */
     readonly success: boolean;
+    /** Result data as string */
     readonly data: string;
 }
 type SignTypedDataParameters = Omit<ViemSignTypedDataParameters, 'account'>;
+/**
+ * Options for working with EVM blockchains
+ * @interface EvmFunctionOptions
+ * @example
+ * ```typescript
+ * const evmOptions: EvmFunctionOptions = {
+ *   getAddress: async () => "0x742d35Cc6634C0532925a3b8D4C2CA1c1DfF0bE8",
+ *   getProvider: (chainId) => new PublicClient({ chain: { id: chainId } }),
+ *   sendTransactions: async (props) => ({ success: true, hash: "0x..." }),
+ *   deployContracts: async (props) => ["0x123..."]
+ * };
+ * ```
+ */
 export interface EvmFunctionOptions {
+    /** Get wallet address */
     readonly getAddress: () => Promise<Address>;
+    /** Get provider for specified chain */
     readonly getProvider: (chainId: number) => PublicClient;
+    /** Send transactions */
     readonly sendTransactions: (props: EVM.types.SendTransactionProps) => Promise<EVM.types.TransactionReturn>;
+    /** Deploy smart contracts */
     readonly deployContracts: (props: DeployContractProps) => Promise<Address[]>;
+    /** Sign messages (optional) */
     readonly signMessages?: (messages: Hex[]) => Promise<SignMessageReturnType[]>;
+    /** Sign typed data (optional) */
     readonly signTypedDatas?: (args: SignTypedDataParameters[]) => Promise<SignTypedDataReturnType[]>;
 }
+/**
+ * Options for working with Solana blockchain
+ * @interface SolanaFunctionOptions
+ * @example
+ * ```typescript
+ * const solanaOptions: SolanaFunctionOptions = {
+ *   getConnection: () => new Connection("https://api.mainnet-beta.solana.com"),
+ *   getPublicKey: async () => new PublicKey("11111111111111111111111111111112"),
+ *   sendTransactions: async (props) => ({ success: true, signature: "5VT..." })
+ * };
+ * ```
+ */
 export interface SolanaFunctionOptions {
+    /** Get Solana connection */
     readonly getConnection: () => Connection;
+    /** Get wallet public key */
     readonly getPublicKey: () => Promise<PublicKey>;
+    /** Send transactions */
     readonly sendTransactions: (props: Solana.types.SendTransactionProps) => Promise<Solana.types.TransactionReturn>;
+    /** Sign transactions (optional) */
     readonly signTransactions?: (transactions: Solana.types.SignTransactionProps[]) => Promise<(SolanaTransaction | SolanaVersionedTransaction)[]>;
 }
+/**
+ * Options for working with TON blockchain
+ * @interface TonFunctionOptions
+ */
 export interface TonFunctionOptions {
+    /** Get wallet address */
     readonly getAddress: () => Promise<TonAddress>;
+    /** Get TON client */
     readonly getClient: () => Promise<TON.types.Client>;
+    /** Send transactions */
     readonly sendTransactions: (props: TON.types.SendTransactionProps) => Promise<TON.types.TransactionReturn>;
 }
+/**
+ * User token information
+ * @interface UserToken
+ * @example
+ * ```typescript
+ * const usdcToken: UserToken = {
+ *   chain: Chain.Ethereum,
+ *   name: "USD Coin",
+ *   symbol: "USDC",
+ *   address: "0xA0b86a33E6417e4681831442Ff7Bd6c25b5d9C7a",
+ *   decimals: 6
+ * };
+ * ```
+ */
 export interface UserToken {
+    /** Blockchain network of the token */
     readonly chain: Chain;
+    /** Token name */
     readonly name: string;
+    /** Token symbol */
     readonly symbol: string;
+    /** Token contract address */
     readonly address: string;
+    /** Number of decimal places */
     readonly decimals: number;
 }
+/**
+ * Complete set of function options for all supported blockchains and utilities
+ * @interface FunctionOptions
+ * @example
+ * ```typescript
+ * const options: FunctionOptions = {
+ *   evm: evmOptions,
+ *   solana: solanaOptions,
+ *   ton: tonOptions,
+ *   notify: async (message, type) => console.log(`${type}: ${message}`),
+ *   getRecipient: async (type) => "recipient_address",
+ *   getUserTokens: async () => [usdcToken],
+ *   getCcxtExchange: async (name) => new exchanges[name](),
+ *   addUserToken: async (token) => token
+ * };
+ * ```
+ */
 export interface FunctionOptions {
+    /** EVM blockchain options */
     readonly evm: EvmFunctionOptions;
+    /** Solana blockchain options */
     readonly solana: SolanaFunctionOptions;
+    /** TON blockchain options */
     readonly ton: TonFunctionOptions;
+    /** Send notification to user */
     readonly notify: (message: string, type?: 'alert' | 'regular') => Promise<void>;
+    /** Get recipient address for specific wallet type */
     readonly getRecipient: (type: WalletType) => Promise<string>;
+    /** Get user's token list */
     readonly getUserTokens: () => Promise<UserToken[]>;
+    /** Get CCXT exchange instance */
     readonly getCcxtExchange: (name: keyof typeof exchanges) => Promise<Exchange>;
-    readonly updateUserTokens: (props: {
-        evmAddresses: string[];
-        solanaAddresses: string[];
-        tonAddresses: string[];
-    }) => Promise<{
-        [key: string]: string;
-    }>;
+    /** Add token to user's token list */
+    readonly addUserToken: (token: UserToken) => Promise<UserToken>;
 }
+/**
+ * Adapter export with configuration and functions
+ * @interface AdapterExport
+ * @example
+ * ```typescript
+ * const myAdapter: AdapterExport = {
+ *   chains: [Chain.Ethereum, Chain.Polygon],
+ *   tags: [AdapterTag.DeFi, AdapterTag.DEX],
+ *   description: "Swap tokens on decentralized exchanges",
+ *   functions: {
+ *     swap: async (args, options) => ({ success: true, data: "Swap completed" })
+ *   },
+ *   executableFunctions: ["swap"],
+ *   tools: [{ type: "function", function: { name: "swap", description: "..." } }]
+ * };
+ * ```
+ */
 export interface AdapterExport {
+    /** Supported blockchain networks */
     readonly chains: Chain[];
+    /** Adapter tags for categorization */
     readonly tags: AdapterTag[];
+    /** Adapter description */
     readonly description: string;
+    /** Available adapter functions */
     readonly functions: Record<string, (args: any, options: FunctionOptions) => Promise<FunctionReturn>>;
+    /** List of executable functions */
     readonly executableFunctions: string[];
+    /** Tools for OpenAI integration */
     readonly tools: OpenAI.Chat.Completions.ChatCompletionTool[];
 }
 export {};

package/dist/blockchain/constants/chains.d.ts

@@ -1,22 +1,115 @@
+/**
+ * Supported blockchain networks in the SDK
+ * @enum Chain
+ * @example
+ * ```typescript
+ * // Using chain in token configuration
+ * const token: UserToken = {
+ *   chain: Chain.ETHEREUM,
+ *   name: "USD Coin",
+ *   symbol: "USDC",
+ *   address: "0xA0b86a33E6417e4681831442Ff7Bd6c25b5d9C7a",
+ *   decimals: 6
+ * };
+ *
+ * // Checking if chain is EVM compatible
+ * const isEvm = chain !== Chain.SOLANA && chain !== Chain.TON;
+ *
+ * // Using in adapter configuration
+ * const adapter: AdapterExport = {
+ *   chains: [Chain.ETHEREUM, Chain.POLYGON, Chain.BSC],
+ *   // ... other properties
+ * };
+ * ```
+ */
 export declare enum Chain {
+    /** Ethereum mainnet */
     ETHEREUM = "ethereum",
+    /** Optimism Layer 2 */
     OPTIMISM = "optimism",
+    /** Binance Smart Chain */
     BSC = "bsc",
+    /** Gnosis Chain (formerly xDai) */
     GNOSIS = "gnosis",
+    /** Polygon (Matic) */
     POLYGON = "polygon",
+    /** Sonic blockchain */
     SONIC = "sonic",
+    /** zkSync Era */
     ZKSYNC = "zksync",
+    /** Metis Andromeda */
     METIS = "metis",
+    /** Kava EVM */
     KAVA_EVM = "kava_evm",
+    /** Base Layer 2 */
     BASE = "base",
+    /** Avalanche C-Chain */
     AVALANCHE = "avalanche",
+    /** Arbitrum One */
     ARBITRUM = "arbitrum",
+    /** Scroll Layer 2 */
     SCROLL = "scroll",
+    /** Solana blockchain */
     SOLANA = "solana",
+    /** The Open Network (TON) */
     TON = "ton",
+    /** HyperEVM blockchain */
     HYPEREVM = "hyperevm",
+    /** Plasma blockchain */
     PLASMA = "plasma"
 }
+/**
+ * Type representing EVM-compatible chains (excludes Solana and TON)
+ * @example
+ * ```typescript
+ * function processEvmChain(chain: EvmChain) {
+ *   // This function only accepts EVM chains
+ *   console.log(`Processing EVM chain: ${chain}`);
+ * }
+ *
+ * processEvmChain(Chain.ETHEREUM); // ✅ Valid
+ * processEvmChain(Chain.POLYGON);  // ✅ Valid
+ * processEvmChain(Chain.SOLANA);   // ❌ TypeScript error
+ * ```
+ */
 export type EvmChain = Exclude<Chain, Chain.SOLANA | Chain.TON>;
+/**
+ * Array containing all supported blockchain chains
+ * @example
+ * ```typescript
+ * // Get all available chains
+ * console.log(`Supported chains: ${allChains.length}`);
+ *
+ * // Check if a chain is supported
+ * const isSupported = allChains.includes(Chain.ETHEREUM);
+ *
+ * // Iterate through all chains
+ * allChains.forEach(chain => {
+ *   console.log(`Chain: ${chain}`);
+ * });
+ * ```
+ */
 export declare const allChains: Chain[];
+/**
+ * Array containing only EVM-compatible chains (excludes Solana and TON)
+ * @example
+ * ```typescript
+ * // Get all EVM chains
+ * console.log(`EVM chains: ${allEvmChains.length}`);
+ *
+ * // Filter tokens by EVM chains
+ * const evmTokens = tokens.filter(token =>
+ *   allEvmChains.includes(token.chain as EvmChain)
+ * );
+ *
+ * // Create EVM-specific configuration
+ * const evmConfig = {
+ *   supportedChains: allEvmChains,
+ *   rpcEndpoints: allEvmChains.map(chain => ({
+ *     chain,
+ *     url: getRpcUrl(chain)
+ *   }))
+ * };
+ * ```
+ */
 export declare const allEvmChains: (Chain.ETHEREUM | Chain.OPTIMISM | Chain.BSC | Chain.GNOSIS | Chain.POLYGON | Chain.SONIC | Chain.ZKSYNC | Chain.METIS | Chain.KAVA_EVM | Chain.BASE | Chain.AVALANCHE | Chain.ARBITRUM | Chain.SCROLL | Chain.HYPEREVM | Chain.PLASMA)[];

package/dist/blockchain/constants/types.d.ts

@@ -1,5 +1,38 @@
+/**
+ * Types of supported wallet architectures
+ * @enum WalletType
+ * @example
+ * ```typescript
+ * // Getting recipient address for specific wallet type
+ * const evmRecipient = await options.getRecipient(WalletType.EVM);
+ * // Returns: "0x742d35Cc6634C0532925a3b8D4C2CA1c1DfF0bE8"
+ *
+ * const solanaRecipient = await options.getRecipient(WalletType.SOLANA);
+ * // Returns: "11111111111111111111111111111112"
+ *
+ * const tonRecipient = await options.getRecipient(WalletType.TON);
+ * // Returns: "EQD4FPq-PRDieyQKkizFTRtSDyucUIqrj0v_zXJmqaDp6_0t"
+ *
+ * // Mapping chain to wallet type
+ * function getWalletType(chain: Chain): WalletType {
+ *   if (chain === Chain.SOLANA) return WalletType.SOLANA;
+ *   if (chain === Chain.TON) return WalletType.TON;
+ *   return WalletType.EVM; // All other chains are EVM-compatible
+ * }
+ *
+ * // Using in adapter functions
+ * async function sendToUser(amount: string, chain: Chain) {
+ *   const walletType = getWalletType(chain);
+ *   const recipient = await options.getRecipient(walletType);
+ *   // ... send logic
+ * }
+ * ```
+ */
 export declare enum WalletType {
+    /** Ethereum Virtual Machine compatible wallets (MetaMask, WalletConnect, etc.) */
     EVM = "evm",
+    /** Solana wallets (Phantom, Solflare, etc.) */
     SOLANA = "solana",
+    /** The Open Network wallets (Tonkeeper, TON Wallet, etc.) */
     TON = "ton"
 }

package/dist/blockchain/evm/constants/chains.d.ts

@@ -1,17 +1,73 @@
+/**
+ * Mapping of EVM chain names to their corresponding chain IDs
+ * @constant ChainIds
+ * @example
+ * ```typescript
+ * // Get chain ID for specific network
+ * const ethereumId = ChainIds[Chain.ETHEREUM]; // 1
+ * const polygonId = ChainIds[Chain.POLYGON];   // 137
+ * const baseId = ChainIds[Chain.BASE];         // 8453
+ *
+ * // Use in RPC provider configuration
+ * const provider = new PublicClient({
+ *   chain: {
+ *     id: ChainIds[Chain.ETHEREUM],
+ *     name: 'Ethereum',
+ *     network: 'ethereum'
+ *   }
+ * });
+ *
+ * // Validate chain ID from wallet
+ * function isValidChain(chainId: number): boolean {
+ *   return Object.values(ChainIds).includes(chainId);
+ * }
+ *
+ * // Get chain name from ID
+ * function getChainFromId(chainId: number): EvmChain | undefined {
+ *   return Object.entries(ChainIds).find(
+ *     ([_, id]) => id === chainId
+ *   )?.[0] as EvmChain;
+ * }
+ *
+ * // Switch wallet to specific chain
+ * async function switchToChain(chain: EvmChain) {
+ *   const chainId = ChainIds[chain];
+ *   await window.ethereum.request({
+ *     method: 'wallet_switchEthereumChain',
+ *     params: [{ chainId: `0x${chainId.toString(16)}` }]
+ *   });
+ * }
+ * ```
+ */
 export declare const ChainIds: {
+    /** Ethereum Mainnet - Chain ID: 1 */
     ethereum: number;
+    /** Optimism - Chain ID: 10 */
     optimism: number;
+    /** Binance Smart Chain - Chain ID: 56 */
     bsc: number;
+    /** Gnosis Chain - Chain ID: 100 */
     gnosis: number;
+    /** Polygon - Chain ID: 137 */
     polygon: number;
+    /** Sonic - Chain ID: 146 */
     sonic: number;
+    /** zkSync Era - Chain ID: 324 */
     zksync: number;
+    /** Metis Andromeda - Chain ID: 1088 */
     metis: number;
+    /** Kava EVM - Chain ID: 2222 */
     kava_evm: number;
+    /** Base - Chain ID: 8453 */
     base: number;
+    /** Avalanche C-Chain - Chain ID: 43114 */
     avalanche: number;
+    /** Arbitrum One - Chain ID: 42161 */
     arbitrum: number;
+    /** Scroll - Chain ID: 534352 */
     scroll: number;
+    /** HyperEVM - Chain ID: 999 */
     hyperevm: number;
+    /** Plasma - Chain ID: 9745 */
     plasma: number;
 };

package/dist/blockchain/evm/constants/misc.d.ts

@@ -1,2 +1,71 @@
+/**
+ * Special address representing native tokens (ETH, BNB, MATIC, etc.) in EVM chains
+ * @constant NATIVE_ADDRESS
+ * @example
+ * ```typescript
+ * // Check if token is native currency
+ * function isNativeToken(tokenAddress: string): boolean {
+ *   return tokenAddress.toLowerCase() === NATIVE_ADDRESS.toLowerCase();
+ * }
+ *
+ * // Use in token swap configuration
+ * const swapConfig = {
+ *   fromToken: NATIVE_ADDRESS, // ETH on Ethereum
+ *   toToken: '0xA0b86a33E6417e4681831442Ff7Bd6c25b5d9C7a', // USDC
+ *   amount: '1000000000000000000' // 1 ETH
+ * };
+ *
+ * // Handle native vs ERC20 transfers differently
+ * async function transferToken(to: string, amount: string, tokenAddress: string) {
+ *   if (tokenAddress === NATIVE_ADDRESS) {
+ *     // Send native ETH
+ *     return await sendTransaction({ to, value: amount });
+ *   } else {
+ *     // Send ERC20 token
+ *     return await sendERC20Transfer(tokenAddress, to, amount);
+ *   }
+ * }
+ *
+ * // Filter native tokens from token list
+ * const erc20Tokens = tokens.filter(token =>
+ *   token.address !== NATIVE_ADDRESS
+ * );
+ * ```
+ */
 export declare const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+/**
+ * Dead address used for burning tokens or as a null destination
+ * @constant DEAD_ADDRESS
+ * @example
+ * ```typescript
+ * // Burn tokens by sending to dead address
+ * async function burnTokens(tokenAddress: string, amount: string) {
+ *   return await sendERC20Transfer(tokenAddress, DEAD_ADDRESS, amount);
+ * }
+ *
+ * // Check if address is a burn address
+ * function isBurnAddress(address: string): boolean {
+ *   return address.toLowerCase() === DEAD_ADDRESS.toLowerCase() ||
+ *          address === '0x0000000000000000000000000000000000000000';
+ * }
+ *
+ * // Calculate circulating supply excluding burned tokens
+ * async function getCirculatingSupply(tokenAddress: string) {
+ *   const totalSupply = await getTotalSupply(tokenAddress);
+ *   const burnedBalance = await getTokenBalance(tokenAddress, DEAD_ADDRESS);
+ *   return totalSupply - burnedBalance;
+ * }
+ *
+ * // Use in deflationary token mechanics
+ * const burnTransaction = {
+ *   to: DEAD_ADDRESS,
+ *   value: '0',
+ *   data: encodeFunctionData({
+ *     abi: erc20Abi,
+ *     functionName: 'transfer',
+ *     args: [DEAD_ADDRESS, burnAmount]
+ *   })
+ * };
+ * ```
+ */
 export declare const DEAD_ADDRESS = "0x000000000000000000000000000000000000dEaD";

package/dist/blockchain/evm/constants/weth9.d.ts

@@ -1,21 +1,96 @@
 import { Token } from '@real-wagmi/sdk';
 /**
- * Known WETH9 implementation addresses, used in our implementation of Ether#wrapped
+ * Mapping of EVM chains to their respective wrapped native token contracts (WETH9-like implementations)
+ * @constant WETH9
+ * @description Each chain has its own wrapped version of the native currency that follows the WETH9 standard
+ * @example
+ * ```typescript
+ * // Get wrapped native token for specific chain
+ * const wethOnEthereum = WETH9[Chain.ETHEREUM]; // WETH
+ * const wbnbOnBsc = WETH9[Chain.BSC];           // WBNB
+ * const wmaticOnPolygon = WETH9[Chain.POLYGON]; // WPOL
+ *
+ * // Wrap native currency to ERC20
+ * async function wrapNativeToken(chain: EvmChain, amount: string) {
+ *   const wrappedToken = WETH9[chain];
+ *   const wrapData = await getWrapData(chain, amount);
+ *
+ *   return await options.evm.sendTransactions({
+ *     transactions: [{
+ *       to: wrappedToken.address,
+ *       value: amount,
+ *       data: wrapData
+ *     }]
+ *   });
+ * }
+ *
+ * // Unwrap ERC20 back to native currency
+ * async function unwrapToken(chain: EvmChain, amount: string) {
+ *   const wrappedToken = WETH9[chain];
+ *   const unwrapData = await getUnwrapData(chain, amount);
+ *
+ *   return await options.evm.sendTransactions({
+ *     transactions: [{
+ *       to: wrappedToken.address,
+ *       value: '0',
+ *       data: unwrapData
+ *     }]
+ *   });
+ * }
+ *
+ * // Get wrapped token info for trading
+ * function getWrappedTokenInfo(chain: EvmChain) {
+ *   const token = WETH9[chain];
+ *   return {
+ *     address: token.address,
+ *     symbol: token.symbol,
+ *     decimals: token.decimals,
+ *     name: token.name
+ *   };
+ * }
+ *
+ * // Check if address is a wrapped native token
+ * function isWrappedNative(chain: EvmChain, tokenAddress: string): boolean {
+ *   return WETH9[chain].address.toLowerCase() === tokenAddress.toLowerCase();
+ * }
+ *
+ * // Use in DEX operations
+ * const swapConfig = {
+ *   fromToken: NATIVE_ADDRESS,           // Native ETH
+ *   toToken: WETH9[Chain.ETHEREUM].address, // Wrapped ETH
+ *   amount: parseEther('1')
+ * };
+ * ```
  */
 export declare const WETH9: {
+    /** Wrapped Ether (WETH) on Ethereum */
     ethereum: Token;
+    /** Wrapped Ether (WETH) on Optimism */
     optimism: Token;
+    /** Wrapped BNB (WBNB) on Binance Smart Chain */
     bsc: Token;
+    /** Wrapped POL (WPOL) on Polygon */
     polygon: Token;
+    /** Wrapped Ether (WETH) on zkSync Era */
     zksync: Token;
+    /** Wrapped KAVA (WKAVA) on Kava EVM */
     kava_evm: Token;
+    /** Wrapped AVAX (WAVAX) on Avalanche */
     avalanche: Token;
+    /** Wrapped Ether (WETH) on Arbitrum */
     arbitrum: Token;
+    /** Wrapped METIS (WMETIS) on Metis */
     metis: Token;
+    /** Wrapped Ether (WETH) on Base */
     base: Token;
+    /** Wrapped S (WS) on Sonic */
     sonic: Token;
+    /** Wrapped Ether (WETH) on Scroll */
     scroll: Token;
+    /** Wrapped xDAI (WXDAI) on Gnosis Chain */
     gnosis: Token;
+    /** Wrapped HYPE (WHYPE) on HyperEVM */
     hyperevm: Token;
+    /** Wrapped XPL (WXPL) on Plasma */
     plasma: Token;
 };