From 102f1ca11f9648bba7025b56c947e0d3ca9aea1c Mon Sep 17 00:00:00 2001 From: Manuel Wedler Date: Wed, 21 Oct 2026 12:30:57 +0200 Subject: [PATCH 1/7] fix: fall back to the raw token ID for an unknown NFT collection ERC-7730 nftName: 'fallback to a raw int token ID if not' found. Both flows rendered '#' when the collection name was unknown, and the EIP-712 flow did so also when no collection address resolved. --- crates/clear-signing/src/eip712.rs | 3 +- crates/clear-signing/src/engine.rs | 5 +- crates/clear-signing/tests/spec_compliance.rs | 77 ++++++++++++++++++- 3 files changed, 80 insertions(+), 5 deletions(-) diff --git a/crates/clear-signing/src/eip712.rs b/crates/clear-signing/src/eip712.rs index e26a6eb..fab57e4 100644 --- a/crates/clear-signing/src/eip712.rs +++ b/crates/clear-signing/src/eip712.rs @@ -2072,7 +2072,8 @@ async fn format_typed_value( return Ok(format!("{} #{}", name, token_id)); } } - Ok(format!("#{}", token_id)) + // ERC-7730 `nftName` falls back to the raw token ID. + Ok(token_id) } FieldFormat::Calldata => { // Should not reach here — calldata is intercepted in render_typed_fields diff --git a/crates/clear-signing/src/engine.rs b/crates/clear-signing/src/engine.rs index 23a3c2e..5e0e981 100644 --- a/crates/clear-signing/src/engine.rs +++ b/crates/clear-signing/src/engine.rs @@ -2394,7 +2394,8 @@ fn resolve_map(ctx: &RenderContext<'_>, map_ref: &str, val: &ArgumentValue) -> O lookup_map_entry(ctx.descriptor, map_ref, &key) } -/// Format an NFT name: "{collection_name} #{token_id}" or "#{token_id}" fallback. +/// Format an NFT name: "{collection_name} #{token_id}", or the raw token ID +/// when the collection is not found (ERC-7730 `nftName` fallback). async fn format_nft_name( ctx: &RenderContext<'_>, val: &ArgumentValue, @@ -2450,7 +2451,7 @@ async fn format_nft_name( label, collection_addr ), )); - Ok(format!("#{}", token_id)) + Ok(token_id) } } diff --git a/crates/clear-signing/tests/spec_compliance.rs b/crates/clear-signing/tests/spec_compliance.rs index 1956b28..9fd7f9f 100644 --- a/crates/clear-signing/tests/spec_compliance.rs +++ b/crates/clear-signing/tests/spec_compliance.rs @@ -491,8 +491,8 @@ async fn test_eip712_nft_name_format() { .await .unwrap(); if let DisplayEntry::Item(ref item) = result.entries[0] { - // No collection resolver → fallback to "#42" - assert_eq!(item.value, "#42"); + // No collection resolver → fallback to the raw token ID (ERC-7730 `nftName`) + assert_eq!(item.value, "42"); } else { panic!("expected Item"); } @@ -6961,3 +6961,76 @@ async fn test_eip712_bundled_group_keeps_hidden_array_elements_aligned() { _ => panic!("expected bundled group"), } } + +// ─── nftName falls back to the raw token ID ─── + +/// ERC-7730 `nftName`: "Display value as a specific NFT in a collection, if +/// found by wallet, or fallback to a raw int token ID if not". Calldata and +/// EIP-712 must agree. +#[tokio::test] +async fn test_nft_name_unknown_collection_falls_back_to_raw_token_id_calldata_eip712_parity() { + let fields = serde_json::json!([ + { "path": "tokenId", "label": "Token", "format": "nftName", "params": { "collection": "0xdef" } } + ]); + let calldata_descriptor = Descriptor::from_json( + &serde_json::json!({ + "context": { "contract": { "deployments": [{"chainId": 1, "address": "0xabc"}] } }, + "metadata": { "owner": "test", "enums": {}, "constants": {}, "maps": {} }, + "display": { + "definitions": {}, + "formats": { "transfer(uint256 tokenId)": { "intent": "Transfer NFT", "fields": fields.clone() } } + } + }) + .to_string(), + ) + .unwrap(); + let calldata = build_calldata("transfer(uint256 tokenId)", &[uint_word(42)]); + let tx = TransactionContext { + chain_id: 1, + to: "0xabc", + calldata: &calldata, + value: None, + from: None, + implementation_address: None, + }; + let calldata_model = format_calldata( + &wrap_rd(calldata_descriptor, 1, "0xabc"), + &tx, + &EmptyDataProvider, + ) + .await + .unwrap(); + + let typed_descriptor = Descriptor::from_json( + &serde_json::json!({ + "context": { "eip712": { "deployments": [{"chainId": 1, "address": "0xabc"}] } }, + "metadata": { "owner": "test", "enums": {}, "constants": {}, "maps": {} }, + "display": { + "definitions": {}, + "formats": { "Transfer(uint256 tokenId)": { "intent": "Transfer NFT", "fields": fields } } + } + }) + .to_string(), + ) + .unwrap(); + let typed_data: TypedData = serde_json::from_value(serde_json::json!({ + "types": {"EIP712Domain": [], "Transfer": [{"name": "tokenId", "type": "uint256"}]}, + "primaryType": "Transfer", + "domain": {"chainId": 1, "verifyingContract": "0xabc"}, + "message": {"tokenId": 42} + })) + .unwrap(); + let typed_model = format_typed_data( + &wrap_rd(typed_descriptor, 1, "0xabc"), + &typed_data, + &EmptyDataProvider, + ) + .await + .unwrap(); + + assert_eq!( + semantic_item_snapshot(&calldata_model.entries), + vec![("Token".to_string(), "42".to_string())] + ); + assert_semantic_parity(&calldata_model, &typed_model); +} From 30edc5ffc284042548372dd9cf248b3b14a93917 Mon Sep 17 00:00:00 2001 From: Manuel Wedler Date: Wed, 21 Oct 2026 14:18:32 +0200 Subject: [PATCH 2/7] ci: update android-actions/setup-android to v4 (#24) Google no longer serves the legacy SDK package 'tools'. setup-android v3 installs 'tools platform-tools' by default, so sdkmanager fails with "Failed to find package 'tools'" and the Android job is red on every PR. v4 installs only 'platform-tools' (fix in v4.0.2). --- .github/workflows/ci.yml | 2 +- .github/workflows/release-kotlin.yml | 2 +- .github/workflows/release-react-native.yml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index cd1d743..9bffd7e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -68,7 +68,7 @@ jobs: java-version: 17 - name: Setup Android SDK + NDK - uses: android-actions/setup-android@v3 + uses: android-actions/setup-android@v4 - name: Install Android NDK run: sdkmanager "ndk;27.0.12077973" diff --git a/.github/workflows/release-kotlin.yml b/.github/workflows/release-kotlin.yml index 0a7c4e8..c6a589a 100644 --- a/.github/workflows/release-kotlin.yml +++ b/.github/workflows/release-kotlin.yml @@ -50,7 +50,7 @@ jobs: java-version: 17 - name: Setup Android SDK + NDK - uses: android-actions/setup-android@v3 + uses: android-actions/setup-android@v4 - run: sdkmanager "ndk;27.0.12077973" - name: Install cargo-ndk diff --git a/.github/workflows/release-react-native.yml b/.github/workflows/release-react-native.yml index 89498c9..e62d734 100644 --- a/.github/workflows/release-react-native.yml +++ b/.github/workflows/release-react-native.yml @@ -75,7 +75,7 @@ jobs: java-version: 17 - name: Setup Android SDK + pinned NDK 27.0.12077973 (parity with release-kotlin.yml) - uses: android-actions/setup-android@v3 + uses: android-actions/setup-android@v4 - run: sdkmanager "ndk;$ANDROID_NDK_VERSION" - name: Wire ANDROID_NDK_HOME + install cargo-ndk From 8eae8b54a4f421b48d64f7364cd984116d9656d1 Mon Sep 17 00:00:00 2001 From: Manuel Wedler Date: Wed, 21 Oct 2026 14:28:19 +0200 Subject: [PATCH 3/7] fix: take native currency metadata from the EIP-155 chain list (#19) native_token_meta used a short hand-written table. Chain 137 rendered as MATIC (now POL), and chains not in the table, such as Celo (42220) and Gnosis (100), rendered as ETH. Generate the table from chainid.network/chains_mini.json, the source that the Sourcify runner uses. --- crates/clear-signing/src/lib.rs | 1 + crates/clear-signing/src/native_currencies.rs | 2837 +++++++++++++++++ crates/clear-signing/src/render_shared.rs | 40 +- .../tests/quickswap_integration.rs | 6 +- scripts/generate_native_currencies.py | 60 + 5 files changed, 2922 insertions(+), 22 deletions(-) create mode 100644 crates/clear-signing/src/native_currencies.rs create mode 100755 scripts/generate_native_currencies.py diff --git a/crates/clear-signing/src/lib.rs b/crates/clear-signing/src/lib.rs index 4ae970a..59ecfa1 100644 --- a/crates/clear-signing/src/lib.rs +++ b/crates/clear-signing/src/lib.rs @@ -13,6 +13,7 @@ mod encryption; pub mod engine; pub mod error; pub mod merge; +mod native_currencies; pub mod outcome; mod path; pub mod provider; diff --git a/crates/clear-signing/src/native_currencies.rs b/crates/clear-signing/src/native_currencies.rs new file mode 100644 index 0000000..0e4d4dd --- /dev/null +++ b/crates/clear-signing/src/native_currencies.rs @@ -0,0 +1,2837 @@ +// @generated by scripts/generate_native_currencies.py from +// https://chainid.network/chains_mini.json. Do not edit by hand. + +/// `(chain_id, symbol, name, decimals)`, sorted by `chain_id`. +pub(crate) static NATIVE_CURRENCIES: &[(u64, &str, &str, u8)] = &[ + (1, "ETH", "Ether", 18), + (2, "EXP", "Expanse Network Ether", 18), + (3, "ETH", "Ropsten Ether", 18), + (4, "ETH", "Rinkeby Ether", 18), + (5, "ETH", "Goerli Ether", 18), + (6, "KOT", "Kotti Ether", 18), + (7, "TCH", "ThaiChain Ether", 18), + (8, "CTM", "c8ntinuum", 18), + (9, "QUAI", "Quai", 18), + (10, "ETH", "Ether", 18), + (11, "META", "Metadium Mainnet Ether", 18), + (12, "KAL", "Metadium Testnet Ether", 18), + (13, "sDIODE", "Staging Diodes", 18), + (14, "FLR", "Flare", 18), + (15, "DIODE", "Diodes", 18), + (16, "CFLR", "Coston Flare", 18), + (17, "TFI", "Thaifi Ether", 18), + (18, "TST", "ThunderCore Testnet Token", 18), + (19, "SGB", "Songbird", 18), + (20, "ELA", "Elastos", 18), + (21, "tELA", "Elastos", 18), + (22, "ELA", "Elastos", 18), + (23, "tELA", "Elastos", 18), + (24, "KAI", "KardiaChain", 18), + (25, "CRO", "Cronos", 18), + (26, "L1test", "L1 testcoin", 18), + (27, "SHIB", "SHIBA INU COIN", 18), + (28, "ETH", "Ether", 18), + (29, "L1", "L1 coin", 18), + (30, "RBTC", "Smart Bitcoin", 18), + (31, "tRBTC", "Testnet Smart Bitcoin", 18), + (32, "GooD", "GoodData Testnet Ether", 18), + (33, "GooD", "GoodData Mainnet Ether", 18), + (34, "SCAI", "SecureChain", 18), + (35, "TBG", "TBWG Ether", 18), + (36, "DX", "Dxchain", 18), + (37, "XPLA", "XPLA", 18), + (38, "VAL", "Valorbit", 18), + (39, "U2U", "U2U Network", 18), + (40, "TLOS", "Telos", 18), + (41, "TLOS", "Telos", 18), + (42, "LYX", "LUKSO", 18), + (43, "PRING", "Pangolin Network Native Token", 18), + (44, "CRAB", "Crab Network Native Token", 18), + (45, "ORING", "Pangoro Network Native Token", 18), + (46, "RING", "Darwinia Network Native Token", 18), + (47, "ACRIA", "ACRIA", 18), + (48, "ETMP", "Ennothem", 18), + (49, "ETMP", "Ennothem", 18), + (50, "XDC", "XinFin", 18), + (51, "TXDC", "XinFin", 18), + (52, "cet", "CoinEx Chain Native Token", 18), + (53, "cett", "CoinEx Chain Test Native Token", 18), + (54, "BELLY", "Belly", 18), + (55, "ZYX", "Zyx", 18), + (56, "BNB", "BNB Chain Native Token", 18), + (57, "SYS", "Syscoin", 18), + (58, "ONG", "ONG", 18), + (59, "EOS", "EOS", 18), + (60, "GO", "GoChain Ether", 18), + (61, "ETC", "Ether", 18), + (62, "TETC", "Morden Ether", 18), + (63, "METC", "Mordor Ether", 18), + (64, "ELLA", "Ellaism Ether", 18), + (65, "OKT", "OKExChain Global Utility Token in testnet", 18), + (66, "OKT", "OKXChain Global Utility Token", 18), + (67, "DBM", "DBChain Testnet", 18), + (68, "SOTER", "SoterOne Mainnet Ether", 18), + (69, "ETH", "Kovan Ether", 18), + (70, "HOO", "Hoo Smart Chain Native Token", 18), + (71, "CFX", "CFX", 18), + (72, "DX", "DxChain Testnet", 18), + (73, "FNCY", "FNCY", 18), + (74, "EIDI", "EIDI", 18), + (75, "DEL", "Decimal", 18), + (76, "MIX", "Mix Ether", 18), + (77, "SPOA", "POA Sokol Ether", 18), + (78, "PETH", "Primus Ether", 18), + (79, "ZENITH", "ZENITH", 18), + (80, "RNA", "RNA", 18), + (81, "JOC", "Japan Open Chain Token", 18), + (82, "MTR", "Meter", 18), + (83, "MTR", "Meter", 18), + (84, "XRP", "XRP", 18), + (85, "GT", "GateToken", 18), + (86, "GT", "GateToken", 18), + (87, "SNT", "Supernova", 18), + (88, "VIC", "Viction", 18), + (89, "VIC", "Viction", 18), + (90, "GAR", "Garizon", 18), + (91, "GAR", "Garizon", 18), + (92, "GAR", "Garizon", 18), + (93, "GAR", "Garizon", 18), + (94, "BCTS", "BCTS", 18), + (95, "CADL", "CADL", 18), + (96, "KUB", "KUB Coin", 18), + (97, "tBNB", "BNB Chain Native Token", 18), + (98, "SIX", "SIX evm token", 18), + (99, "POA", "POA Network Core Ether", 18), + (100, "XDAI", "xDAI", 18), + (101, "ETI", "EtherInc Ether", 18), + (102, "W3G", "Web3Games", 18), + (103, "WLC", "Worldland", 18), + (104, "tKAIBA", "Kaiba Testnet Token", 18), + (105, "W3G", "Web3Games", 18), + (106, "VLX", "Velas", 18), + (107, "NBX", "Nebula X", 18), + (108, "TT", "ThunderCore Token", 18), + (109, "BONE", "BONE Shibarium", 18), + (110, "XPR", "Proton", 4), + (111, "ETL", "EtherLite", 18), + (112, "GIDR", "Gas IDR", 18), + (113, "Deh", "Dehvo", 18), + (114, "C2FLR", "Coston2 Flare", 18), + (115, "ETH", "Ether", 18), + (116, "ETH", "Ether", 18), + (117, "UPTICK", "Uptick", 18), + (118, "Acol", "Arcology Coin", 18), + (119, "NULS", "NULS", 18), + (120, "NULS", "NULS", 18), + (121, "REAL", "Realchain", 18), + (122, "FUSE", "Fuse", 18), + (123, "SPARK", "Spark", 18), + (124, "DWU", "Decentralized Web Utility", 18), + (125, "OY", "OYchain Token", 18), + (126, "OY", "OYchain Token", 18), + (127, "FETH", "Factory 127 Token", 18), + (128, "HT", "Huobi ECO Chain Native Token", 18), + (129, "INOV8", "INOV8", 18), + (130, "ETH", "Ether", 18), + (131, "tGRAM", "Engram Tokio Testnet", 18), + (132, "NFIC", "Namefi Coin", 18), + (133, "HSK", "HashKey EcoPoints", 18), + (134, "xRLC", "xRLC", 18), + (135, "ALYX", "Alyx Testnet Native Token", 18), + (136, "DEAM", "Deamchain Native Token", 18), + (137, "POL", "POL", 18), + (138, "ETH", "Ether", 18), + (139, "WOOC", "WoopCoin", 18), + (140, "ERA", "Eteria", 18), + (141, "BELLY", "Belly", 18), + (142, "DAX", "Prodax", 18), + (143, "MON", "Monad", 18), + (144, "Φ", "PHI", 18), + (145, "SETH", "SoraETH", 18), + (146, "S", "Sonic", 18), + (147, "FLAG", "Flag", 18), + (148, "SMR", "SMR", 18), + (150, "tSIX", "SIX testnet evm token", 18), + (151, "RBNT", "Redbelly Network Coin", 18), + (152, "RBNT", "Redbelly Network Coin", 18), + (153, "RBNT", "Redbelly Network Coin", 18), + (154, "RBNT", "Redbelly Network Coin", 18), + (155, "TENET", "TENET", 18), + (156, "OEB", "OEBlock", 18), + (157, "BONE", "BONE", 18), + (158, "RBA", "Roburna", 18), + (159, "RBAT", "Roburna", 18), + (160, "AMAX", "Armonia Multichain Native Token", 18), + (161, "AMAX", "Armonia Multichain Native Token", 18), + (162, "PHT", "Lightstreams PHT", 18), + (163, "PHT", "Lightstreams PHT", 18), + (164, "OMNI", "Omni", 18), + (165, "FMC", "Farm Coin", 18), + (166, "NOM", "Nomina", 18), + (167, "ATOS", "ATOSHI", 18), + (168, "AIOZ", "AIOZ", 18), + (169, "ETH", "Ether", 18), + (170, "HOO", "HOO", 18), + (171, "CO2E", "CO2e Token", 18), + (172, "usd", "Latam-Blockchain Resil Test Native Token", 18), + (173, "EGAS", "EGAS", 18), + (174, "EGAS", "EGAS", 18), + (175, "OTC", "OTC", 18), + (176, "DCT", "DC Native Token", 18), + (177, "HSK", "HashKey EcoPoints", 18), + (178, "tABEY", "ABEY", 18), + (179, "ABEY", "ABEY", 18), + (180, "AME", "AME", 18), + (181, "WATER", "WATER", 18), + (182, "BNB", "BNB Chain Native Token", 18), + (183, "ETH", "Ether", 18), + (184, "DOJ", "Dojima", 18), + (185, "ETH", "Ether", 18), + (186, "Seele", "Seele", 18), + (187, "DOJ", "Dojima", 18), + (188, "BTM", "BTM", 18), + (189, "BTM", "BTM", 18), + (190, "CMD", "CommuDAO", 18), + (191, "FFG", "FFG", 18), + (192, "RMC", "Redmansion Coin", 18), + (193, "CEM", "Crypto Emergency", 18), + (194, "FIR", "firachain", 18), + ( + 195, + "OKBDep", + "X Layer Global Utility Token in testnet(Deprecated)", + 18, + ), + (196, "OKB", "X Layer Global Utility Token", 18), + (197, "NEUTR", "Neutrinos", 18), + (198, "BTC", "Bitcoin", 18), + (199, "BTT", "BitTorrent", 18), + (200, "xDAI", "xDAI", 18), + (201, "mc", "MOAC", 18), + (202, "EwEth", "Edgeless Wrapped Eth", 18), + (203, "DOGE", "Dogecoin", 18), + (204, "BNB", "BNB Chain Native Token", 18), + (205, "$EKH", "Global Mobile Money Gateway", 18), + (206, "VC", "VinuChain", 18), + (207, "VC", "VinuChain", 18), + (208, "utx", "Notes", 18), + (209, "RIN", "RIN", 18), + (210, "BTN", "Bitnet", 18), + (211, "0xF", "Freight Trust Native", 18), + (212, "MAPO", "Makalu MAPO", 18), + (213, "B2", "BSquared Token", 18), + (214, "SHI", "Shina Inu", 18), + (215, "IDN", "IDN", 18), + (216, "HAPPY", "Happy", 18), + (217, "MCD", "MCD", 18), + (218, "SOTER", "SoterOne Mainnet Ether", 18), + (219, "RIN", "RIN", 18), + (220, "ETH", "Sepolia Ether", 18), + (221, "XBE", "BlockEx", 18), + (222, "ASK", "ASK", 18), + (223, "BTC", "Bitcoin", 18), + (224, "VRD", "Viridis Token", 18), + (225, "LA", "LA", 18), + (226, "TLA", "TLA", 18), + (227, "PROM", "Prom", 18), + (228, "ETH", "Ether", 18), + (230, "SDX", "SwapDEX", 18), + (232, "GHO", "GHO", 18), + (233, "ETH", "Ether", 18), + (234, "JNFTC", "JNFTC", 18), + (236, "DEAM", "Deamchain Native Token", 18), + (237, "AERX", "AERX", 18), + (238, "OWCT", "One World Chain", 18), + (239, "TAC", "TAC", 18), + (240, "zkTCRO", "Cronos zkEVM Test Coin", 18), + (242, "PLINGA", "Plinga", 18), + (246, "EWT", "Energy Web Token", 18), + (247, "CHOO", "ChooChain Token", 18), + (248, "OAS", "OAS", 18), + (250, "FTM", "Fantom", 18), + (251, "GLXP", "Glide XP", 18), + (252, "FRAX", "Frax", 18), + (253, "GLXP", "Glide XP", 18), + (254, "ETH", "Ether", 18), + (255, "ETH", "Ether", 18), + (256, "htt", "Huobi ECO Chain Test Native Token", 18), + (258, "SETM", "Setheum", 18), + (259, "NEON", "Neonlink Native Token", 18), + (260, "GURU", "Guru", 18), + (261, "tGURU", "testGURU", 18), + (262, "SRN", "Suren", 18), + (263, "ENI", "ENI", 18), + (266, "ANKR", "Ankr", 18), + (267, "ANKR", "Testnet Ankr", 18), + (268, "ANKR", "Devnet Ankr", 18), + (269, "HPB", "High Performance Blockchain Ether", 18), + (270, "ORB", "ORB", 18), + (271, "EGON", "EgonCoin", 18), + (273, "XR1", "XR1", 18), + (274, "LAC", "LaCoin", 18), + (278, "FAI", "FAI", 18), + (279, "BPX", "BPX", 18), + (280, "ETH", "Ether", 18), + (282, "zkTCRO", "Cronos zkEVM Test Coin", 18), + (287, "NETX", "NetX Token", 18), + (288, "ETH", "Ether", 18), + (291, "ETH", "Ether", 18), + (293, "DCOIN", "DaVinci", 18), + (295, "HBAR", "hbar", 18), + (296, "HBAR", "hbar", 18), + (297, "HBAR", "hbar", 18), + (298, "HBAR", "hbar", 18), + (300, "ETH", "Ether", 18), + (301, "BOBA", "Boba Token", 18), + (302, "ETH", "Ether", 18), + (303, "tNCN", "Neurochain", 18), + (305, "BTC", "BTC", 18), + (307, "LOVELY", "Lovely", 18), + (308, "FTH", "Furtheon", 18), + (309, "WYZ", "Wyzth", 18), + (311, "OMAX", "OMAX COIN", 18), + (313, "NCN", "Neurochain", 18), + (314, "FIL", "filecoin", 18), + (315, "WEM", "WEM Coin", 18), + (320, "ETH", "Ether", 18), + (321, "KCS", "KuCoin Token", 18), + (322, "tKCS", "KuCoin Testnet Token", 18), + (323, "BCX", "Buycex", 18), + (324, "ETH", "Ether", 18), + (325, "ETH", "ETH", 18), + (326, "ETH", "ETH", 18), + (329, "VBC", "VBC", 18), + (331, "ETH", "Sepolia ETH", 18), + (332, "OMAX", "OMAX TESTCOIN", 18), + (333, "ETH", "Ether", 18), + (335, "JEWEL", "Jewel", 18), + (336, "SDN", "Shiden", 18), + (337, "R5", "R5", 18), + (338, "TCRO", "Cronos Test Coin", 18), + (339, "DAPP", "Pencils Protocol Token", 18), + (343, "BOURSE", "Bourse", 18), + (345, "TAS", "TAS", 18), + (355, "ETH", "Ether", 18), + (360, "ETH", "Ether", 18), + (361, "TFUEL", "Theta Fuel", 18), + (362, "DNC", "Dancore", 18), + (363, "TFUEL", "Theta Fuel", 18), + (364, "TFUEL", "Theta Fuel", 18), + (365, "TFUEL", "Theta Fuel", 18), + (369, "PLS", "Pulse", 18), + (371, "tCNT", "tCNT", 18), + (373, "ETH", "Ether", 18), + (374, "ETH", "Ether", 18), + (375, "ETH", "Ether", 18), + (380, "FIL", "filecoin", 18), + (381, "FIL", "filecoin", 18), + (385, "LISINS", "Lisinski Ether", 18), + (388, "zkCRO", "Cronos zkEVM CRO", 18), + (389, "LNR", "Lunaro", 18), + (395, "CADL", "CADL", 18), + (397, "NEAR", "NEAR", 18), + (398, "NEAR", "NEAR", 18), + (399, "USNT", "USNT", 18), + (400, "HPN", "HyperonChain", 18), + (401, "OZO", "OZONE", 18), + (404, "ETH", "Ether", 18), + (411, "PEPE", "Pepe", 18), + (416, "SX", "SX Network", 18), + (418, "TLA", "Test LaCoin", 18), + (420, "ETH", "Goerli Ether", 18), + (422, "VRD", "Viridis Token", 18), + (424, "ETH", "Ether", 18), + (425, "STEN", "Stenix", 18), + (426, "MITE", "The Widows Mite", 8), + (427, "ZTH", "Zeeth Token", 18), + (428, "OAS", "OAS", 18), + (432, "GRAMZ", "GRAMZ", 18), + (434, "BYC", "Boyaa native coin", 18), + (443, "ETH", "Sepolia Ether", 18), + (444, "ETH", "Sepolia ETH", 18), + (456, "AZO", "ARZIO", 18), + (462, "TAREA", "Areon", 18), + (463, "AREA", "Areum", 18), + (466, "ETH", "Ether", 18), + (475, "ETH", "Ether", 18), + (478, "ETH", "Ether", 18), + (480, "ETH", "Ether", 18), + (481, "SCI", "SCI", 18), + (484, "CAMP", "Camp", 18), + (486, "STND", "Standard", 18), + (488, "BXN", "BlackFort Token", 18), + (495, "LDS", "Landstars", 18), + (499, "RUPX", "Rupaya", 18), + (500, "CAM", "Camino", 18), + (501, "CAM", "Camino", 18), + (505, "DOTO", "Doto", 18), + (510, "SYND", "Syndicate", 18), + (512, "AAC", "Acuteangle Native Token", 18), + (513, "AAC", "Acuteangle Native Token", 18), + (516, "GZN", "Gear Zero Network Native Token", 18), + (520, "XT", "XT Smart Chain Native Token", 18), + (529, "FIRE", "Firechain", 18), + (530, "PUNDAI", "Pundi AIFX", 18), + (534, "CNDL", "CANDLE", 18), + (537, "BNB", "BSC", 18), + (540, "ATK", "AppiaToken", 18), + (542, "PAW", "PAW", 18), + (545, "FLOW", "FLOW", 18), + (550, "ETH", "Ether", 18), + (555, "CLASS", "CLASS COIN", 18), + (558, "TAO", "Tao", 18), + (565, "PYRE", "Pyre", 18), + (567, "VLDM", "Validium", 18), + (568, "DOGE", "Dogecoin", 18), + (570, "SYS", "Syscoin", 18), + (571, "MTC", "Metatime Coin", 18), + (579, "FIL", "Filecoin", 18), + (587, "NETX", "NetX Token", 18), + (588, "METIS", "tMetis", 18), + (589, "LADY", "Lady", 18), + (592, "ASTR", "Astar", 18), + (595, "mACA", "Acala Mandala Token", 18), + (596, "KAR", "Karura Token", 18), + (597, "ACA", "Acala Token", 18), + (599, "METIS", "Goerli Metis", 18), + (600, "MESHT", "Meshnyan Testnet Native Token", 18), + (601, "VNE", "VINE", 18), + (610, "DNA", "Darwin Devnet token", 18), + (612, "EIOB", "EIOB", 18), + (614, "GLQ", "GLQ", 18), + (619, "sUSD", "SkyUSD", 18), + (624, "BNRY", "Binary Token", 18), + (625, "BNRY", "Test BNRY", 18), + (626, "ETH", "Ether", 18), + (627, "ETH", "Ether", 18), + (632, "NFBC", "NFBCoin", 18), + (634, "USDC", "USDC", 18), + (646, "FLOW", "FLOW", 18), + (647, "SX", "SX Network", 18), + (648, "ACE", "Endurance Chain Native Token", 18), + (653, "KALIS", "kalis", 18), + (654, "KALIS", "kalis", 18), + (662, "AMAX", "amax", 18), + (666, "PCTT", "Pixie Chain Testnet Native Token", 18), + (667, "LAOS", "LAOS", 18), + (668, "JGC", "JuncaChain Native Token", 18), + (669, "JGCT", "JuncaChain Testnet Native Token", 18), + (678, "JCT", "Janction", 18), + (679, "JCT", "Janction", 18), + (680, "JASMY", "JasmyCoin", 18), + (681, "JASMY", "JasmyCoin", 18), + (686, "KAR", "Karura Token", 18), + (689, "NERO", "NERO", 18), + (690, "ETH", "Ether", 18), + (698, "BNB", "BNB", 18), + (699, "BNB", "BNB", 18), + (700, "SNS", "Social", 18), + (701, "KRING", "Koi Network Native Token", 18), + (707, "BCS", "BCS Token", 18), + (708, "tBCS", "BCS Testnet Token", 18), + (710, "FURY", "Fury", 18), + (711, "TUC", "Tucana", 18), + (712, "TUC", "Tucana", 18), + (713, "VRC", "VRC Chain", 18), + (714, "TIA", "TIA", 18), + (717, "L7C", "L7C", 18), + (718, "UXLINK", "UXLINK", 18), + (719, "BONE", "BONE", 18), + (721, "LYC", "Lycan", 18), + (723, "BAC", "Bitasset Chain Native Token", 18), + (727, "BLU", "Blucrates", 18), + (730, "LOVELY", "Lovely", 18), + (739, "POB", "Pione BOS Chain", 18), + (740, "CANTO", "Canto", 18), + (741, "VNT", "VNT", 18), + (742, "SPAY", "Script", 18), + (743, "ETH", "Ether", 18), + (747, "FLOW", "FLOW", 18), + (753, "ETH", "Ether", 18), + (766, "QOM", "Shiba Predator", 18), + (776, "TOPC", "Openchain Testnet", 18), + (777, "cTH", "cTH", 18), + (784, "PXA", "PXA", 18), + (785, "THEO", "THEO", 18), + (786, "MAAL", "MAAL", 18), + (787, "ACA", "Acala Token", 18), + (788, "TAero", "Aerochain Testnet", 18), + (789, "ETH", "Ether", 18), + (799, "TRUPX", "Test Rupaya", 18), + (800, "LUCID", "LUCID", 18), + (803, "HAIC", "Haicoin", 18), + (805, "EVOZ", "Evoz Mainnet", 18), + (808, "PFT", "Portal Fantasy Token", 18), + (810, "H1", "Haven1", 18), + (813, "MEER", "Qitmeer", 18), + (814, "ETH", "Ether", 18), + (818, "BOC", "BeOne Chain Mainnet", 18), + (820, "CLO", "Callisto", 18), + (821, "TCLO", "Callisto Testnet Ether", 18), + (822, "rBTC", "Bitcoin", 18), + (824, "DLY", "Daily", 18), + (825, "DLY", "Daily", 18), + (831, "CDT", "CDT", 18), + (841, "TARA", "Tara", 18), + (842, "TARA", "Tara", 18), + (852, "HK", "HongKong", 18), + (859, "ZTH", "Zeeth Token", 18), + (861, "ELC", "Electra", 18), + (863, "USLS", "Useless", 18), + (868, "FST", "FST", 18), + (869, "WMTX", "World Mobile Token", 18), + (871, "TELC", "Test Electra", 18), + (876, "OAS", "OAS", 18), + (877, "DXT", "Dexit network", 18), + (880, "AMBROS", "AMBROS", 18), + (881, "PTT", "PALLET", 18), + (888, "WAN", "Wancoin", 18), + (890, "MARS", "MARS", 18), + (898, "MGAS", "MAXI GAS", 18), + (899, "MGAS", "MAXI GAS", 18), + (900, "GAR", "Garizon", 18), + (901, "GAR", "Garizon", 18), + (902, "GAR", "Garizon", 18), + (903, "GAR", "Garizon", 18), + (904, "AULT", "AULT Token", 18), + (909, "PFT", "Portal Fantasy Token", 18), + (910, "DBONE", "DecentraBone", 18), + (911, "TBTC", "TBTC", 18), + (917, "FIRE", "Firechain", 18), + (918, "WSLERF", "WSLERF", 18), + (919, "ETH", "Sepolia Ether", 18), + (920, "FEN", "Fenine", 18), + (927, "YDK", "Yidark", 18), + (938, "HAUST", "HAUST", 18), + (940, "tPLS", "Test Pulse", 18), + (941, "tPLS", "Test Pulse", 18), + (942, "tPLS", "Test Pulse", 18), + (943, "tPLS", "Test Pulse", 18), + (944, "ZIG", "ZIG", 18), + (945, "TAO", "testTAO", 18), + (956, "ETH", "Ether", 18), + (957, "ETH", "Ether", 18), + (963, "BTCC", "BTCC", 18), + (964, "TAO", "TAO", 18), + (968, "DGRAM", "DGRAM", 18), + (969, "SEXY", "Settled EthXY Token", 18), + (970, "OORT", "Oort", 18), + (971, "CCN", "Oort", 18), + (972, "CCNA", "Oort", 18), + (973, "PALM", "PALM", 18), + (977, "YETI", "Nepal Blockchain Network Ether", 18), + (979, "SEXY", "Settled EthXY Token", 18), + (980, "ETH", "Ether", 18), + (984, "OPN", "OPN", 18), + (985, "CMEMO", "Memo", 18), + (986, "LAGO", "LAGO", 18), + (987, "BNRY", "BINARY", 18), + (988, "USDT0", "USDT0", 18), + (989, "TOP", "TOP", 6), + (990, "$EL", "eLiberty", 18), + (993, "tBTG", "Banteng Coin", 18), + (995, "5ire", "5ire Token", 18), + (996, "WETH", "Wrapped ETH", 18), + (997, "T5IRE", "5ire Testnet Token", 18), + (998, "HYPE", "HYPE", 18), + (999, "WAN", "Wancoin", 18), + (1000, "GCD", "GCD", 18), + (1001, "KAIA", "KAIA", 18), + (1003, "TET", "Tectum", 8), + (1004, "T-EKTA", "T-EKTA", 18), + (1005, "tLEMX", "testnet LEMX", 18), + (1006, "LEMX", "LEMX", 18), + (1007, "NEW", "Newton", 18), + (1008, "EUN", "Eurus", 18), + (1009, "JNFTC", "JNFTC", 18), + (1010, "EVC", "Evrice", 18), + (1011, "REBUS", "Rebus Classic", 18), + (1012, "NEW", "Newton", 18), + (1019, "MAI", "MAI Chain Native Token", 18), + (1020, "NURA", "Nura Coin", 18), + (1022, "SKU", "Sakura", 18), + (1023, "CLV", "Clover", 18), + (1024, "CLV", "CLV", 18), + (1028, "BTT", "BitTorrent", 18), + (1029, "BTT", "BitTorrent", 18), + (1030, "CFX", "CFX", 18), + (1031, "PRX", "PRX", 18), + (1038, "tBRO", "tBRO", 18), + (1039, "BRO", "BRO", 18), + (1050, "DIA", "DIA Token", 18), + (1062, "BEETS", "Beets", 18), + (1071, "OGPU", "OGPU", 18), + (1072, "SMR", "SMR", 6), + (1073, "SMR", "SMR", 18), + (1075, "IOTA", "IOTA", 18), + (1079, "MNTR", "MINTARA", 18), + (1080, "MNTR", "MINTARA", 18), + (1088, "METIS", "Metis", 18), + (1089, "HEART", "HEART", 18), + (1096, "TXENE", "Xenea Ubusuna Testnet Token", 18), + (1099, "mc", "MOAC", 18), + (1100, "DYM", "DYM", 18), + (1101, "ETH", "Ether", 18), + (1107, "BLXQ", "BLXQ", 18), + (1108, "BLXQ", "BLXQ", 18), + (1110, "VORD", "Vordium", 18), + (1111, "WEMIX", "WEMIX", 18), + (1112, "tWEMIX", "TestnetWEMIX", 18), + (1113, "B2", "BSquared Token", 18), + (1114, "tCORE2", "Core Blockchain Testnet2 Native Token", 18), + (1115, "tCORE", "Core Blockchain Testnet Native Token", 18), + (1116, "CORE", "Core Blockchain Native Token", 18), + (1117, "DOGS", "Dogcoin", 18), + (1122, "LXP", "LuxePorts", 18), + (1123, "BTC", "Bitcoin", 18), + (1125, "TAKER", "Taker", 18), + (1129, "QRY", "Quarry", 18), + (1130, "DFI", "DeFiChain", 18), + (1131, "DFI", "DeFiChain", 18), + (1133, "DFI", "DeFiChain Token", 18), + (1134, "MESH", "StateMesh", 18), + (1135, "ETH", "Ether", 18), + (1138, "SINSO", "SINSO", 18), + (1139, "MATH", "MathChain", 18), + (1140, "MATH", "MathChain", 18), + (1147, "FLAG", "Flag Testnet", 18), + (1148, "POC", "POC Native Token", 18), + (1149, "PLEX", "Plex Native Token", 18), + (1155, "TRUST", "TRUST", 18), + (1166, "tCMX", "ClubMOS", 18), + (1170, "UOC", "Origin", 18), + (1174, "LTH", "Lith", 18), + (1177, "tSHT", "Smart Host Teknoloji TESTNET", 18), + (1188, "MOS", "ClubMos", 18), + (1197, "IORA", "Iora", 18), + (1200, "CAI", "CuckooAI", 18), + (1201, "AVIS", "AVIS", 18), + (1202, "WTT", "World Trade Token", 18), + (1209, "STC", "SaitaBlockChain(SBC)", 18), + (1210, "CAI", "CuckooAI", 18), + (1212, "tADF", "ADDFILL Testnet", 18), + (1213, "POP", "Popcat", 18), + (1214, "ENTER", "EnterCoin", 18), + (1215, "ADF", "ADDFILL", 18), + (1221, "ETH", "Ether", 18), + (1223, "ETH", "Ether", 18), + (1224, "HYB", "Hybrid", 18), + (1225, "HYB", "Hybrid", 18), + (1227, "BTCP", "BTC Protocol", 18), + (1228, "ETH", "Ether", 18), + (1229, "XZO", "Exzo", 18), + (1230, "ULX", "Ultron", 18), + (1231, "ULX", "Ultron", 18), + (1234, "FITFI", "FITFI", 18), + (1235, "ITX", "ITX", 18), + (1236, "BAK", "BrainArk", 18), + (1237, "tAER", "Testnet AER", 18), + (1243, "ARC", "ARC", 18), + (1244, "ARC", "ARC", 18), + (1246, "OM", "OMCOIN", 18), + (1247, "PNIC", "PNIC", 18), + (1248, "dogeth", "Dogether", 18), + (1252, "CICT", "Crazy Internet Coin", 18), + (1260, "ACCES", "Metacces", 18), + (1270, "IRYS", "Irys", 18), + (1280, "HO", "HALO", 18), + (1284, "GLMR", "Glimmer", 18), + (1285, "MOVR", "Moonriver", 18), + (1286, "ROC", "Rocs", 18), + (1287, "DEV", "Dev", 18), + (1288, "ROC", "Rocs", 18), + (1291, "SWTR", "Swisstronik", 18), + (1294, "BOBA", "Boba Token", 18), + (1297, "BOBA", "Boba Token", 18), + (1298, "AGC", "Argocoin", 18), + (1299, "AGC", "Argocoin", 18), + (1300, "GLUE", "Glue", 18), + (1301, "ETH", "Sepolia Ether", 18), + (1306, "STOC", "STOC", 18), + (1310, "ZAX", "COINZAX", 18), + (1311, "DOS", "Dos Native Token", 18), + (1313, "JaiHo", "JaiHo", 18), + (1314, "ALYX", "Alyx Chain Native Token", 18), + (1315, "DATA", "DATA", 18), + (1319, "AIA", "AIA Mainnet", 18), + (1320, "AIA", "AIA Testnet", 18), + (1328, "SEI", "Sei", 18), + (1329, "SEI", "Sei", 18), + (1336, "KII", "Kii", 18), + (1337, "ETH", "Geth Testnet Ether", 18), + (1338, "PYR", "PYR", 18), + (1339, "PYR", "PYR", 18), + (1342, "BIE", "BIE", 18), + (1343, "BGAS", "BLITZ GAS", 18), + (1353, "CIC", "Crazy Internet Coin", 18), + (1369, "ZAFIC", "Zakumi Chain Native Token", 18), + (1370, "RAMA", "Rama", 18), + (1377, "tRAMA", "Rama", 18), + (1379, "KLC", "Kalar", 18), + (1388, "SINSO", "SINSO", 18), + (1392, "JSM", "Joseon Mun", 18), + (1394, "MIDX", "Midpoint Cross", 18), + (1402, "ETH", "Ether", 18), + (1404, "BDAG", "BlockDAG", 18), + (1414, "ETH", "Sepolia Ether", 18), + (1422, "ETH", "Ether", 18), + (1424, "ETH", "Ether", 18), + (1425, "ONI", "ONI", 18), + (1433, "RIK", "Rikeza", 18), + (1439, "INJ", "Injective", 18), + (1440, "LAS", "LAS", 18), + (1442, "ETH", "Ether", 18), + (1452, "GANG", "GANG", 18), + (1453, "MTC", "Metatime Coin", 18), + (1455, "CTEX", "CTEX", 18), + (1456, "ETH", "Ether", 18), + (1475, "CMX-R", "CryMadX", 18), + (1480, "VANA", "Vana", 18), + (1490, "VTRU", "Vitruveo Coin", 18), + (1499, "IGC", "iDos Games Coin", 18), + (1501, "BTC", "BTC", 18), + (1506, "KSX", "KSX", 18), + (1507, "KSX", "KSX", 18), + (1513, "IP", "IP", 18), + (1514, "DATA", "DATA", 18), + (1515, "BG", "Beagle", 18), + (1516, "IP", "IP", 18), + (1555, "DSC", "Datacore Smart Chain", 18), + (1559, "TENET", "TENET", 18), + (1570, "STARX", "STARX", 18), + (1578, "STARX", "STARX", 18), + (1597, "REACT", "React", 18), + (1605, "BETH", "Betherance", 18), + (1611, "mUSD", "mantraUSD", 18), + (1612, "OPEN", "Open", 18), + (1617, "ETINS", "Ethereum Inscription", 18), + (1618, "CATE", "Catecoin", 18), + (1620, "ATH", "Atheios Ether", 18), + (1625, "G", "Gravity", 18), + (1643, "XGR", "XGR", 18), + (1648, "ETH", "Pivotal ETH", 18), + (1650, "SAYA", "Saya Coin", 18), + (1657, "BTA", "Bitcoin Asset", 18), + (1662, "LCN", "Licoin", 18), + (1663, "tZEN", "Testnet Zen", 18), + (1672, "PROS", "PharosCoin", 18), + (1686, "ETH", "Sepolia Ether", 18), + (1687, "ETH", "Sepolia Ether", 18), + (1688, "LUDAN", "LUDAN", 18), + (1689, "NERO", "NERO", 18), + (1701, "ANY", "ANY", 18), + (1707, "JINDA", "Jinda", 18), + (1708, "JINDA", "Jinda", 18), + (1714, "ETH", "Ether", 18), + (1717, "DRC", "Doric Native Token", 18), + (1718, "PLT", "Palette Token", 18), + (1727, "ETP", "Ethpar", 18), + (1729, "ETH", "Ether", 18), + (1732, "FUGA", "FUGA", 18), + (1733, "FUGA", "FUGA", 18), + (1734, "FUGA", "FUGA", 18), + (1740, "ETH", "ETH", 18), + (1750, "ETH", "ETH", 18), + (1773, "GRAMS", "Grams", 18), + (1776, "INJ", "Injective", 18), + (1777, "GANG", "GANG", 18), + (1783, "KII", "Kii", 18), + (1789, "ETH", "Ether", 18), + (1804, "CRC", "Climate awaReness Coin", 18), + (1807, "rAna", "Rabbit Analog Test Chain Native Token ", 18), + (1810, "RUBY", "Ruby", 18), + (1811, "LIF3", "LIF3", 18), + (1818, "CUBE", "Cube Chain Native Token", 18), + (1819, "CUBET", "Cube Chain Test Native Token", 18), + (1821, "RUBY", "RUBY Smart Chain Native Token", 18), + (1829, "PBG", "PlayBlock", 18), + (1833, "MATIC", "Matic", 18), + (1848, "SWTR", "Swisstronik", 18), + (1853, "HO", "HighOctane", 18), + (1856, "TSF", "Teslafunds Ether", 18), + (1868, "ETH", "Ether", 18), + (1874, "WBT", "WBT", 18), + (1875, "WBT", "WhiteBIT Coin", 18), + (1879, "XGR", "XGR", 18), + (1881, "tGTFX", "Gitshock Cartenz", 18), + (1890, "ETH", "Ethereum", 18), + (1891, "ETH", "Ethereum", 18), + (1898, "BOY", "BOYACoin", 18), + (1899, "RED", "RED", 18), + (1904, "SCN", "SCN", 18), + (1905, "KWALA", "KWALA", 18), + (1906, "KWALA", "KWALA", 18), + (1907, "BITCI", "Bitci", 18), + (1908, "TBITCI", "Test Bitci", 18), + (1909, "MRK", "Merkle", 18), + (1910, "KWALA", "KWALA", 18), + (1911, "ETH", "Ether", 18), + (1912, "tRUBY", "RUBY Smart Chain Native Token", 18), + (1918, "UPBEth", "UPBEth", 18), + (1919, "TURK", "TC", 18), + (1923, "ETH", "Ether", 18), + (1924, "ETH", "Ether", 18), + (1927, "tARV", "Arvix Testnet Native Token", 18), + (1943, "VNRG", "VNRG", 18), + (1945, "ONUS", "ONUS", 18), + (1946, "ETH", "Ether", 18), + (1948, "QMS", "QMS", 18), + (1949, "tBIO", "Bionix", 18), + (1951, "DOINX", "DOINX", 18), + (1952, "OKB", "X Layer Global Utility Token in testnet", 18), + (1953, "tSEL", "Selendra", 18), + (1954, "DXZ", "Dexilla Native Token", 18), + (1956, "BTC", "BTC", 18), + (1961, "SEL", "Selendra", 18), + (1962, "ETH", "Ether", 18), + (1967, "MTC", "Eleanor Metacoin", 18), + (1969, "TSCS", "Super Chain Native Token", 18), + (1970, "SCS", "Super Chain Native Token", 18), + (1971, "ATLR", "ATLR", 18), + (1972, "REDEV2", "RedeCoin", 18), + (1975, "ONUS", "ONUS", 18), + (1979, "CRAT", "CRATD2C", 18), + (1982, "INNBC", "InnovativeBioresearchCoin", 18), + (1983, "KROWN", "KROWN", 18), + (1984, "EUN", "Eurus", 18), + (1985, "TUSHY", "Tushy Token", 18), + (1986, "TUSHY", "Tushy Token", 18), + (1987, "EGEM", "EtherGem Ether", 18), + (1989, "BSW", "Lydia Coin", 18), + (1992, "USDC", "USD Coin", 18), + (1993, "ETH", "ETH", 18), + (1994, "EKTA", "EKTA", 18), + (1995, "tEDX", "edeXa", 18), + (1996, "DMT", "DMT", 18), + (1997, "KYOTO", "Kyoto", 18), + (1998, "KYOTO", "Kyoto", 18), + (1999, "TSTOC", "TSTOC", 18), + (2000, "DOGE", "Dogecoin", 18), + (2001, "mADA", "milkAda", 18), + (2002, "mALGO", "milkALGO", 18), + (2004, "MTL", "MetaLink", 18), + (2008, "CWN", "CloudWalk Native Token", 18), + (2009, "CWN", "CloudWalk Native Token", 18), + (2013, "GAS", "GAS", 18), + (2014, "NOW", "NOW Coin", 18), + (2016, "NetZ", "MainnetZ", 18), + (2017, "TEL", "Telcoin", 18), + (2018, "USD", "USD", 18), + (2019, "USD", "USD", 18), + (2020, "RON", "RON", 18), + (2021, "EDG", "Edgeware", 18), + (2022, "tEDG", "Testnet EDG", 18), + (2023, "tSFL", "test-Shuffle", 18), + (2024, "sETH", "SWANETH", 18), + (2025, "RPG", "Rangers Protocol Gas", 18), + (2026, "EwEth", "Edgeless Wrapped Eth", 18), + (2027, "GMB", "GMB", 18), + (2028, "tARMA", "tARMA", 18), + (2031, "CFG", "Centrifuge", 18), + (2032, "NCFG", "Catalyst CFG", 18), + (2035, "ETH", "Ether", 18), + (2037, "SHRAP", "Shrapgas", 18), + (2038, "SHRAPG", "SHRAPG", 18), + (2039, "TZERO", "TZERO", 18), + (2040, "VANRY", "VANRY", 18), + (2043, "NEURO", "NeuroWeb Token", 12), + (2044, "SHRAPG", "Shrapnel Gas Token", 18), + (2045, "BTC", "BTC", 18), + (2047, "STOS", "STOS", 18), + (2048, "STOS", "STOS", 18), + (2049, "MOVO", "Movo Smart Chain", 18), + (2061, "ZIG", "ZIG", 18), + (2064, "MFX", "MFX", 18), + (2071, "ACCES", "Metacces", 18), + (2077, "QKA", "Qkacoin", 18), + (2088, "AIR", "Altair", 18), + (2089, "ALGL", "Algol", 18), + (2099, "PIKO", "PIKO", 18), + (2100, "ECO", "Ecoball Coin", 18), + (2101, "ECO", "Espuma Coin", 18), + (2109, "SAMA", "Sama Token", 18), + (2110, "LAX", "Parallax", 18), + (2112, "UCASH", "UCASH", 18), + (2121, "CMCX", "Catena", 18), + (2122, "METAD", "METAD", 18), + (2124, "MEU", "Metaunit", 18), + (2129, "ETH", "Ether", 18), + (2136, "Dolarz", "Dolarz", 18), + (2137, "USDC", "USD Coin", 18), + (2138, "tETH", "testEther", 18), + (2140, "BTC", "BTC", 18), + (2141, "BTC", "BTC", 18), + (2151, "BOA", "BOSAGORA", 18), + (2152, "FRA", "FRA", 18), + (2153, "FRA", "FRA", 18), + (2154, "FRA", "FRA", 18), + (2162, "COIN", "Coin", 18), + (2184, "BGB", "BGB", 18), + (2187, "G7", "G7", 18), + (2192, "ETH", "Ether", 18), + (2199, "SAMA", "Sama Token", 18), + (2201, "USDT0", "USDT0", 18), + (2202, "ABN", "Antofy", 18), + (2203, "BTC", "Bitcoin", 18), + (2213, "EVA", "EVA", 18), + (2221, "TKAVA", "TKava", 18), + (2222, "KAVA", "Kava", 18), + (2223, "VNDT", "VNDT", 18), + (2237, "SEAR", "SEAR", 18), + (2241, "KRST", "Krest", 18), + (2255, "CMX", "ClubMOS", 18), + (2288, "MOCA", "MOCA", 18), + (2300, "BOMB", "BOMB Token", 18), + (2306, "ebro", "Ebro", 18), + (2309, "ARÉV", "Arev", 18), + (2310, "CRAT", "CRATD2C", 18), + (2311, "tstLPX", "Test LPX", 18), + (2323, "tSMA", "SMA", 18), + (2330, "ALT", "Altcoin", 18), + (2331, "RSS3", "RSS3", 18), + (2332, "SMA", "Soma Native Token", 18), + (2340, "ATLA", "Atla Olympia", 18), + (2342, "OMNIA", "Omnia", 18), + (2345, "BTC", "Bitcoin", 18), + (2355, "ETH", "Ether", 18), + (2357, "ETH", "Sepolia Ether", 18), + (2358, "ETH", "Sepolia Ether", 18), + (2366, "KITE", "Kite", 18), + (2368, "KITE", "Kite", 18), + (2370, "NZT", "Nexis", 18), + (2382, "AEVA", "AEVA", 18), + (2383, "AEVA", "AEVA", 18), + (2390, "TAC", "TAC", 18), + (2391, "TAC", "TAC", 18), + (2399, "tBOMB", "BOMB Token", 18), + (2400, "OAS", "OAS", 18), + (2410, "ETH", "Ether", 18), + (2415, "XODEX", "XODEX Native Token", 18), + (2420, "ELON", "Dogelon", 18), + (2424, "INJ", "Injective", 18), + (2425, "KCC", "King Of Legends", 18), + (2426, "STND", "Standard", 18), + (2440, "ATLA", "Atla", 18), + (2442, "ETH", "Ether", 18), + (2443, "HAUS", "Haus", 18), + (2458, "tHRC", "Hybrid Chain Native Token", 18), + (2468, "HRC", "Hybrid Chain Native Token", 18), + (2477, "6DO", "6Degree Coin", 18), + (2484, "U2U", "Unicorn Ultra Nebulas Testnet", 18), + (2488, "NOW", "NOW Coin", 18), + (2511, "KRK", "Karak", 18), + (2512, "ETH", "Ether", 18), + (2517, "SVP", "SVP Token", 18), + (2522, "FRAX", "Frax", 18), + (2523, "FRAX", "Frax", 18), + (2525, "INJ", "Injective", 18), + (2552, "FTN", "FTN", 18), + (2559, "KTO", "KorthoChain", 11), + (2569, "TPC", "TechPay", 18), + (2582, "H2", "H2 Chain Native Token", 18), + (2605, "PHO", "Pho", 18), + (2606, "CRC", "Climate awaReness Coin", 18), + (2611, "REDLC", "Redlight Coin", 18), + (2612, "EZC", "EZChain", 18), + (2613, "EZC", "EZChain", 18), + (2625, "WBT", "WhiteBIT Coin", 18), + (2648, "BTC", "BTC", 18), + (2649, "BTC", "BTC", 18), + (2662, "ETH", "Ether", 18), + (2691, "SPLD", "Splendor Token", 18), + (2692, "SPLDT", "Splendor Test Token", 18), + (2700, "ORB", "ORB", 18), + (2710, "ETH", "Ether", 18), + (2718, "KLAOS", "KLAOS", 18), + (2730, "tXR", "tXR", 18), + (2731, "TIME", "TIME", 18), + (2741, "ETH", "Ether", 18), + (2748, "ETH", "Ether", 18), + (2777, "ETH", "Ether", 18), + (2786, "APTM", "Apertum", 18), + (2800, "AERE", "AERE", 18), + (2810, "ETH", "Ether", 18), + (2818, "ETH", "Ether", 18), + (2828, "CANDY", "CANDY", 18), + (2868, "HYPT", "Hyperdust", 18), + (2882, "IOTA", "IOTA", 18), + (2888, "ETH", "Goerli Ether", 18), + (2889, "ARMA", "Aarma", 18), + (2907, "ELUX", "Elux Chain", 18), + (2911, "TOPIA", "TOPIA", 18), + (2941, "tXEN", "Xenon Testnet", 18), + (2966, "AXON", "AXON", 18), + (2967, "AXON", "AXON", 18), + (2999, "BTY", "BTY", 18), + (3000, "CPAY", "CPAY", 18), + (3001, "CPAY", "CPAY", 18), + (3003, "CAU", "Canxium", 18), + (3011, "3ULL", "3ULL", 18), + (3030, "VTCN", "VERSATIZE COIN", 18), + (3031, "ORL", "Orlando", 18), + (3033, "REBUS", "Rebus", 18), + (3068, "BFC", "Bifrost", 18), + (3073, "MOVE", "Move", 18), + (3084, "XLN", "XLNetwork", 18), + (3100, "IMMU", "IMMU", 18), + (3102, "VFI", "VFI", 18), + (3109, "BTC", "BTC", 18), + (3110, "BTC", "BTC", 18), + (3111, "ETH", "Ether", 18), + (3141, "tFIL", "testnet filecoin", 18), + (3210, "AVI", "AVI", 18), + (3223, "XO", "XO", 18), + (3230, "CXC", "CXC", 18), + (3269, "DUBX", "Dubxcoin mainnet", 18), + (3270, "TDUBX", "Dubxcoin testnet", 18), + (3282, "IRYS", "Irys", 18), + (3300, "RIO", "Rio", 18), + (3301, "RIO", "Rio", 18), + (3306, "DB", "Debounce Network", 18), + (3331, "ZCR", "ZCore", 18), + (3332, "ETH", "Ether", 18), + (3333, "ETH", "Ether", 18), + (3334, "W3Q", "Web3Q", 18), + (3335, "QKC", "QKC", 18), + (3336, "ETH", "Ether", 18), + (3337, "ETH", "Ether", 18), + (3338, "PEAQ", "peaq", 18), + (3339, "ETH", "Ether", 18), + (3343, "ETH", "Ether", 18), + (3344, "PC", "Pentagon Chain", 18), + (3366, "MERON", "MERON", 18), + (3369, "MERON", "MERON", 18), + (3377, "TJR", "Tajir", 18), + (3400, "PRB", "PRB", 18), + (3409, "PEPU", "PEPU", 18), + (3424, "EVO", "Evolve", 18), + (3434, "SCAI", "SCAI", 18), + (3456, "BTC", "Bitcoin", 18), + (3490, "GTC", "GTC", 18), + (3500, "PRB", "PRB", 18), + (3501, "JFIN", "JFIN Coin", 18), + (3502, "JPOS", "JFINPOS", 18), + (3535, "AMX", "Amero X", 18), + (3601, "PTX", "pando-token", 18), + (3602, "PTX", "pando-token", 18), + (3630, "TYCO", "Tycooncoin", 18), + (3636, "BTC", "Botanix", 18), + (3637, "BTC", "Botanix", 18), + (3639, "ISLAMI", "ISLAMICOIN", 18), + (3645, "ISLAMI", "ISLAMICOIN", 18), + (3666, "J", "J", 18), + (3690, "BTX", "Bittex", 18), + (3693, "EMPIRE", "Empire", 18), + (3698, "SPC", "SenjePowers", 18), + (3699, "SPC", "SenjePowers", 18), + (3701, "XPLA", "XPLA", 18), + (3721, "XOC", "Xone Coin", 18), + (3737, "CSB", "Crossbell Token", 18), + (3776, "ETH", "Ether", 18), + (3797, "ALV", "AlveyCoin", 18), + (3799, "tTNT", "Testnet Tangle Network Token", 18), + (3838, "FAVO", "FAVO", 18), + (3885, "ETH", "Ether", 18), + (3888, "KLC", "KalyCoin", 18), + (3889, "KLC", "KalyCoin", 18), + (3912, "DRAC", "DRAC", 18), + (3939, "DOS", "DOS", 18), + (3966, "DYNO", "DYNO Token", 18), + (3967, "tDYNO", "DYNO Token", 18), + (3969, "Pay", "PayNetwork", 18), + (3989, "PTC", "Pione Trace", 18), + (3993, "ETH", "Sepolia Ether", 18), + (3999, "YCC", "YCC", 18), + (4000, "OZO", "OZONE", 18), + (4001, "PERIUM", "Peperium Chain Testnet", 18), + (4002, "FTM", "Fantom", 18), + (4003, "XN", "XN", 18), + (4040, "tCBR", "Carbonium", 18), + (4048, "GPU", "GPUnet", 18), + (4051, "BOBA", "Boba Token", 18), + (4058, "FTN", "FTN", 18), + (4061, "ETH", "Ether", 18), + (4062, "ETH", "Sepolia Ether", 18), + (4078, "ETH", "Ether", 18), + (4080, "TOBE", "Tobe Coin", 18), + (4088, "ZRH", "ZRH", 18), + (4090, "FTN", "FTN", 18), + (4096, "$BNI", "BNI", 18), + (4099, "$BNI", "BNI", 18), + (4102, "AIOZ", "testAIOZ", 18), + (4111, "ECNA", "E Canna", 18), + (4112, "tECNA", "E Canna Testnet", 18), + (4114, "cBTC", "Citrea BTC", 18), + (4139, "HEART", "HEART", 18), + (4141, "TPBX", "Tipboxcoin", 18), + (4153, "ETH", "Ether", 18), + (4157, "XFI", "XFI", 18), + (4158, "XFI", "CrossFi Token", 18), + (4160, "ALGO", "Algo", 6), + (4162, "SX", "SX Network", 18), + (4181, "Φ", "PHI", 18), + (4200, "BTC", "BTC", 18), + (4201, "LYXt", "TestLYX", 18), + (4202, "ETH", "Sepolia Ether", 18), + (4203, "BTC", "BTC", 18), + (4207, "EDGEN", "Layer Edge", 18), + (4217, "USD", "No native currency", 18), + (4221, "GEN", "GEN Token", 18), + (4242, "NEXI", "Nexi", 18), + (4243, "NEXI", "NexiV2", 18), + (4269, "DOGE", "Dogecoin", 18), + (4270, "IKTokn", "IKToken", 18), + (4289, "TPIX", "Thaiprompt Index", 18), + (4290, "tTPIX", "Thaiprompt Index", 18), + (4321, "USDC", "USD Coin", 18), + (4326, "ETH", "Ether", 18), + (4328, "BOBA", "Boba Token", 18), + (4337, "BEAM", "Beam", 18), + (4352, "M", "M", 18), + (4370, "ILY", "ILITY", 18), + (4400, "CREDIT", "Credit", 18), + (4422, "tPKA", "Testnet Pika", 18), + (4442, "WATT", "WATT", 18), + (4444, "HTML", "Htmlcoin", 8), + (4457, "OXIN", "Oxin", 18), + (4460, "ETH", "Sepolia Ether", 18), + (4488, "HYDRA", "Hydra", 18), + (4544, "EMYC", "Emoney Network", 18), + (4545, "EMYC", "Emoney Coin", 18), + (4547, "TRUMP", "Official Trump", 18), + (4613, "VERY", "VERY", 18), + (4646, "MSTC", "MST Native Coin", 18), + (4653, "ETH", "Ether", 18), + (4661, "ETH", "Ether", 18), + (4663, "ETH", "Ether", 18), + (4683, "WSK", "WorldStreet Kash", 18), + (4689, "IOTX", "IoTeX", 18), + (4690, "IOTX", "IoTeX", 18), + (4759, "MEV", "MEVerse", 18), + (4777, "TBXN", "BlackFort Testnet Token", 18), + (4786, "tEVO", "Evnode Testnet Native Token", 18), + (4801, "ETH", "Sepolia Ether", 18), + (4888, "BXNT", "BlackFort Testnet Token", 18), + (4893, "GC", "Globel Chain", 18), + (4913, "ETH", "Ether", 18), + (4918, "XVM", "Venidium", 18), + (4919, "XVM", "Venidium", 18), + (4999, "BXNdpr", "BlackFort Token", 18), + (5000, "MNT", "Mantle", 18), + (5001, "MNT", "Testnet Mantle", 18), + (5002, "UNIT", "UNIT", 18), + (5003, "MNT", "Sepolia Mantle", 18), + (5005, "UNIT", "UNIT", 18), + (5031, "SOMI", "Somnia Mainnet", 18), + (5039, "ONGR", "ONIGIRI", 18), + (5040, "ONGR", "ONIGIRI", 18), + (5042, "USDC", "USDC", 18), + (5050, "ETH", "Ether", 18), + (5051, "ETH", "Ether", 18), + (5069, "DAN", "Danny", 18), + (5080, "PZO", "Pione Zero", 18), + (5090, "PIO", "Pione", 18), + (5100, "ETH", "S-Ether", 18), + (5101, "ETH", "Ether", 18), + (5102, "ETH", "ETH", 18), + (5103, "ETH", "ETH", 18), + (5104, "ETH", "ETH", 18), + (5105, "ETH", "ETH", 18), + (5106, "ETH", "ETH", 18), + (5112, "ETH", "Ether", 18), + (5115, "cBTC", "Citrea BTC", 18), + (5124, "ETH", "Seismic Ether", 18), + (5151, "MOCA", "MOCA", 18), + (5165, "FTN", "FTN", 18), + (5169, "SU", "Service Unit Token", 18), + (5177, "TLC", "TLChain Network", 18), + (5197, "ES", "EraSwap", 18), + (5232, "LMK", "LiterMark", 18), + (5234, "eHMND", "eHMND", 18), + (5290, "FIRE", "Firechain", 18), + (5315, "UZMI", "UZMI", 18), + (5317, "tBNB", "TestBSC", 18), + (5321, "ITX", "ITX", 18), + (5330, "ETH", "Ether", 18), + (5333, "NETS", "Netsbo", 18), + (5353, "tTRN", "Tritanium Native Token", 18), + (5371, "ETH", "Ether", 18), + (5372, "SETL", "Setl", 18), + (5373, "ETH", "Sepolia Ether", 18), + (5424, "EDX", "edeXa", 18), + (5433, "IRTA", "Inertia", 18), + (5439, "EGAX", "EGAX", 18), + (5464, "GAS", "gas", 18), + (5511, "PXP", "PointPay", 18), + (5522, "VEX", "VEX EVM TESTNET", 18), + (5545, "TON", "TON", 18), + (5550, "ORIGEN", "Origen", 18), + (5551, "ETH", "Ether", 18), + (5553, "ETH", "Ether", 18), + (5555, "OAS", "Oasys", 18), + (5589, "DOTON", "DOTON", 18), + (5611, "tBNB", "BNB Chain Native Token", 18), + (5615, "tARC", "tARC", 18), + (5616, "tARCT", "Test Arct", 18), + (5656, "QIE", "QIE Blockchain", 18), + (5667, "KASH", "KASH", 18), + (5675, "tFIL", "Test Filecoin", 18), + (5678, "TANGO", "TANGO", 18), + (5680, "SCDO", "SCDO", 18), + (5700, "tSYS", "Testnet Syscoin", 18), + (5729, "HIK", "Hik Token", 18), + (5758, "SATS", "SatoshiChain Coin", 18), + (5777, "ETH", "Ganache Test Ether", 18), + (5845, "TNT", "Tangle", 18), + (5851, "ONG", "ONG", 18), + (5858, "CTH", "Chang Coin Thailand", 18), + (5869, "RBD", "Rubid", 18), + (5887, "MANTRA", "MANTRA", 18), + (5888, "MANTRA", "MANTRA", 18), + (6000, "BB", "BounceBit", 18), + (6001, "BB", "BounceBit", 18), + (6060, "TVTCN", "TEST VERSATIZE COIN", 18), + (6065, "TRES", "TRES", 18), + (6066, "TRES", "TRES", 18), + (6102, "tCC", "CC", 18), + (6118, "UPTN", "UPTN", 18), + (6119, "UPTN", "UPTN", 18), + (6122, "TEA", "Tea", 18), + (6278, "STEAMX", "SteamX", 18), + (6283, "LAOS", "LAOS", 18), + (6320, "NFBCT", "NFBCoinTest", 18), + (6321, "eAura", "test-EAura", 18), + (6322, "AURA", "Aura", 18), + (6342, "ETH", "MegaETH Testnet Ether", 18), + (6343, "ETH", "Ether", 18), + (6363, "DGC", "Digit Coin", 18), + (6398, "ETH", "ETH", 18), + (6423, "YNXT", "YNXT", 18), + (6497, "MIZU", "MIZU", 18), + (6498, "MIZU", "MIZU", 18), + (6502, "P2P", "Peerpay", 18), + (6550, "FLA", "Flamma", 18), + (6552, "SCOL", "Scolcoin", 18), + (6565, "tFOX", "FOX Native Token", 18), + (6626, "PIX", "Pixie Chain Native Token", 18), + (6660, "LATEST", "Latest", 18), + (6661, "CYBA", "Cybria", 18), + (6666, "CYBA", "Cybria", 18), + (6667, "STR", "Storchain", 18), + (6678, "EMC", "Edge Matrix Chain Token", 18), + (6688, "ERIS", "Eris", 18), + (6699, "OX", "OX", 18), + (6701, "PAXB", "PAXB", 18), + (6736, "VEX", "VEX", 18), + (6779, "CPV", "compverse", 18), + (6789, "STAND", "Standard in Gold", 18), + (6800, "BMX", "BMX", 18), + (6801, "BMX", "BMX", 18), + (6805, "ETH", "Ether", 18), + (6806, "ETH", "Sepolia Ether", 18), + (6868, "POOLS", "POOLS Native Token", 18), + (6880, "MTT", "MTT Network native coin", 18), + (6900, "NIBI", "NIBI", 18), + (6911, "NIBI", "NIBI", 18), + (6913, "ETH", "Ether", 18), + (6934, "XYL", "Xylume", 18), + (6940, "LYTH", "Lythium", 18), + (6941, "LYTH", "Lythium", 18), + (6942, "DOGE", "Dogecoin", 18), + (6969, "TOMB", "Tomb", 18), + (6999, "PSC", "PSC", 18), + (7000, "ZETA", "Zeta", 18), + (7001, "ZETA", "Zeta", 18), + (7007, "BSTC", "BST Chain", 18), + (7027, "ELLA", "Ella", 18), + (7070, "PLQ", "Planq", 18), + (7077, "tPLQ", "Planq", 18), + (7099, "BBN", "BBNT", 18), + (7100, "DAI", "Dai Stablecoin", 18), + (7117, "XL3", "XL3", 18), + (7118, "HTH", "Help The Homeless Coin", 18), + (7119, "SRX", "Sentrix", 18), + (7120, "SRX", "Sentrix", 18), + (7171, "BROCK", "BITROCK", 18), + (7181, "UXLINK", "UXLINK", 18), + (7200, "BTC", "Bitcoin", 18), + (7208, "NXRA", "NXRA", 18), + (7210, "NIBI", "NIBI", 18), + (7222, "NIBI", "NIBI", 18), + (7233, "INI", "InitVerse", 18), + (7234, "INI", "InitVerse", 18), + (7244, "ZEUSX", "The ZEUS Token", 18), + (7258, "PCKT", "PCKT", 18), + (7259, "PCKT", "PCKT", 18), + (7300, "OAS", "OAS", 18), + (7331, "KLY", "KLYNTAR", 18), + (7332, "ZEN", "Zencash", 18), + (7336, "PRUV", "Pruv", 18), + (7337, "PRUV", "Pruv", 18), + (7341, "SHYFT", "Shyft", 18), + (7368, "ETH", "Rarimo Ether", 18), + (7373, "CMX-R", "CryMadX", 18), + (7447, "FEE", "FEE", 6), + (7484, "RABA", "Raba", 18), + (7518, "MEV", "MEVerse", 18), + (7531, "USDC", "USDC", 18), + (7532, "USDC", "USDC", 18), + (7560, "ETH", "Ether", 18), + (7575, "ADIL", "Testnet ADIL", 18), + (7576, "ADIL", "ADIL", 18), + (7667, "CARR", "CarrChain Coin", 18), + (7668, "XRP", "XRP", 6), + (7672, "XRP", "XRP", 6), + (7676, "RNR", "Racaille", 18), + (7700, "CANTO", "Canto", 18), + (7701, "CANTO", "Testnet Canto", 18), + (7741, "ETH", "Ether", 18), + (7744, "TPHR", "Phron", 18), + (7770, "PANDA", "PandaSea Coin", 18), + (7771, "BROCK", "BITROCK", 18), + (7774, "GDCC", "GDCC", 18), + (7775, "GDCC", "GDCC", 18), + (7776, "PANDA", "PandaSea Coin", 18), + (7777, "TTL", "TTL Coin", 18), + (7778, "ORE", "ORENIUM", 18), + (7788, "DRW", "DRW", 18), + (7789, "WCAHT", "WCAHT", 18), + (7791, "SDM", "Diamondz Shadow Game and Movies", 18), + (7798, "USDT", "USDT Testnet", 18), + (7847, "HYVE", "HYVE", 18), + (7860, "MAAL", "MAAL", 18), + (7862, "MAAL", "MAAL", 18), + (7863, "MAAL", "MAAL", 18), + (7865, "POWER", "Powerloom Token", 18), + (7869, "POWER", "Powerloom Token", 18), + (7878, "TSCAS", "Hazlor Test Coin", 18), + (7879, "tVEX", "Vexon Testnet Native Token", 18), + (7887, "ETH", "Ethereum", 18), + (7895, "tARD", "ARD", 18), + (7897, "ETH", "Ether", 18), + (7923, "DTBX", "Dot Blox", 18), + (7924, "MO", "MO", 18), + (7957, "tEXOR", "EXOR", 18), + (7979, "DOS", "DOS", 18), + (7991, "PYN", "Peeryn", 18), + (8000, "TELE", "Tele", 18), + (8001, "TELE", "Tele", 18), + (8004, "PROBE", "Probe", 18), + (8008, "ETH", "Ether", 18), + (8017, "ISC", "ISC", 18), + (8029, "MDGLT", "MDGL Token", 18), + (8047, "BOAT", "Best Of All Time Token", 18), + (8054, "ETH", "Ether", 18), + (8080, "SHM", "Shardeum SHM", 18), + (8081, "SHM", "Shardeum SHM", 18), + (8082, "SHM", "Shardeum SHM", 18), + (8083, "SHM", "Shardeum Test SHM", 18), + (8086, "BTC", "Bitcoin", 18), + (8087, "USD", "E-Dollar", 18), + (8088, "HLX", "Helix", 18), + (8098, "SmuX", "StreamuX", 18), + (8099, "BBN", "BBN", 18), + (8108, "ZTC", "ZTC", 18), + (8118, "SHM", "Shardeum", 18), + (8131, "MEER-T", "Qitmeer Testnet", 18), + (8132, "MEER-M", "Qitmeer Mixnet", 18), + (8133, "MEER-P", "Qitmeer Privnet", 18), + (8134, "MEER", "Amana Mainnet", 18), + (8135, "MEER", "Flana Mainnet", 18), + (8136, "MEER", "Mizana Mainnet", 18), + (8150, "sBTC", "Signet BTC", 18), + (8181, "tBOC", "Testnet BeOne Chain", 18), + (8191, "MRSN", "Mersennet", 18), + (8192, "TQF", "TQF", 18), + (8194, "TTQF", "tTQF", 18), + (8217, "KAIA", "KAIA", 18), + (8224, "ETH", "Ether", 18), + (8227, "FUEL", "FUEL", 18), + (8272, "BTON", "BLOCKTON", 18), + (8282, "WKRC", "WKRC", 18), + (8283, "WKRC", "WKRC", 18), + (8285, "KTO", "Kortho Test", 11), + (8329, "stBTC", "Lorenzo stBTC", 18), + (8333, "ETH", "ETH", 18), + (8386, "KICK", "Kick", 18), + (8387, "FUCK", "Functionally Universal Coin Kind", 18), + (8408, "ZTC", "ZTC", 18), + (8428, "THAT", "THAT", 18), + (8453, "ETH", "Ether", 18), + (8472, "MRT", "MyRx Token", 18), + (8545, "CKR", "Chakra", 18), + (8569, "NEWRL", "NewReal", 18), + (8654, "TOKI", "Toki", 18), + (8655, "TOKI", "Toki", 18), + (8668, "HLUSD", "Hela HLUSD", 18), + (8700, "AI3", "AI3", 18), + (8721, "EBC", "EBC", 18), + (8723, "OLO", "TOOL Global", 18), + (8724, "OLO", "TOOL Global", 18), + (8726, "STOR", "Storagechain", 18), + (8727, "STOR", "Storagechain", 18), + (8732, "BLN", "Bullions", 18), + (8738, "ALPH", "Alph Network", 18), + (8768, "TMY", "TMY", 18), + (8801, "OKTO", "Okto", 18), + (8811, "H1", "Haven1", 18), + (8822, "IOTA", "IOTA", 18), + (8844, "tHYDRA", "tHydra", 18), + (8846, "GDC", "Garuda Digital Coin", 18), + (8848, "MARO", "MARO", 18), + (8866, "ETH", "Ether", 18), + (8869, "LIF3", "LIF3", 18), + (8880, "UNQ", "Unique", 18), + (8881, "QTZ", "Quartz", 18), + (8882, "UNQ", "Opal", 18), + (8883, "QTZ", "Quartz", 18), + (8886, "tAVE", "Ave Native Token", 18), + (8888, "CTM", "c8ntinuum", 18), + (8889, "VSC", "VSC", 18), + (8890, "tORE", "ORENIUM", 18), + (8898, "MMT", "Mammoth Token", 18), + (8899, "JBC", "JIBCOIN", 18), + (8911, "ALG", "ALG", 18), + (8912, "ALG", "ALG", 18), + (8921, "ALG", "ALG", 18), + (8922, "ALG", "ALG", 18), + (8989, "GMMT", "Giant Mammoth Coin", 18), + (8995, "U+25B3", "BERG", 18), + (9000, "tEVMOS", "test-Evmos", 18), + (9001, "EVMOS", "Evmos", 18), + (9002, "DNR", "Dinar", 18), + (9003, "TICS", "Qubetics Testnet Token", 18), + (9005, "LITHO", "LITHO", 18), + (9007, "SHIDO", "Shido Testnet Token", 18), + (9008, "SHIDO", "Shido", 18), + (9012, "BRB", "BerylBit Chain Native Token", 18), + (9024, "NEXB", "Nexa Testnet Token", 18), + (9025, "NEXB", "Nexa Mainnet Token", 18), + (9029, "TICS", "Qubetics Testnet Token", 18), + (9030, "TICS", "Qubetics", 18), + (9069, "AP3X", "Apex Fusion Token", 18), + (9070, "tAP3X", "Apex Fusion Token", 18), + (9090, "INCO", "INCO", 18), + (9091, "tKPA", "KPA Smart Chain Testnet", 18), + (9100, "GNC", "GN Coin", 18), + (9108, "SYNC", "Sync", 18), + (9134, "ETH", "Ether", 18), + (9170, "FIRE", "Firechain", 18), + (9223, "COF", "Codefin", 18), + (9280, "tRAB", "Test RAB", 18), + (9302, "GNET", "Galactica Reticulum", 18), + (9339, "DOGS", "Dogcoin", 18), + (9369, "Z", "Z", 18), + (9372, "OAS", "OAS", 18), + (9393, "ETH", "Sepolia Ether", 18), + (9395, "MTHN", "MTHN", 18), + (9496, "tLOAD", "Testnet Load Token", 18), + (9511, "ETH", "Sepolia Ether", 18), + (9527, "tRPG", "Rangers Protocol Gas", 18), + (9528, "QET", "QET", 18), + (9559, "tNEON", "Neonlink Native Token", 18), + (9696, "ETH", "Ether", 18), + (9700, "OORT", "Oort", 18), + (9728, "BOBA", "Boba Token", 18), + (9745, "XPL", "Plasma", 18), + (9746, "XPL", "Testnet Plasma", 18), + (9747, "XPL", "Devnet Plasma", 18), + (9768, "NetZ", "MainnetZ", 18), + (9770, "NPC", "Nepacoin", 18), + (9779, "WPEPE", "Pepe", 18), + (9788, "TABI", "Tabi", 18), + (9789, "TABI", "Tabi", 18), + (9790, "SWTH", "swth", 18), + (9792, "SWTH", "swth", 18), + (9797, "OZ7", "OptimusZ7", 18), + (9818, "tIMP", "tIMP", 18), + (9819, "IMP", "IMP", 18), + (9876, "BNRY", "BINARY", 18), + (9888, "DOGE", "Dogecoin", 18), + (9889, "PLG", "PLG", 18), + (9897, "ETH", "Ether", 18), + (9898, "LRS", "Larissa", 18), + (9899, "ETH", "Ether", 18), + (9901, "ETH", "ETH", 18), + (9911, "SPENT", "ESPENTO", 18), + (9922, "JNX", "JingleX", 18), + (9966, "tUXER", "UXER", 18), + (9977, "tMIND", "MIND Coin", 18), + (9980, "BNB", "BNB Chain Native Token", 18), + (9981, "V2X", "V2X", 18), + (9982, "MFEV", "MFEV", 18), + (9988, "EGG", "EGG", 18), + (9989, "tEGG", "Test EGG", 18), + (9990, "AGNG", "Agung", 18), + (9996, "MIND", "MIND Coin", 18), + (9997, "ETH", "Ether", 18), + (9998, "ZTC", "Ztcer", 5), + (9999, "MYN", "MYN", 18), + (10000, "BCH", "Bitcoin Cash", 18), + (10001, "BCHT", "Bitcoin Cash Test Token", 18), + (10010, "WARD", "WARD", 18), + (10011, "DEF", "DeepSafe Native Token", 18), + (10024, "GT", "Gon Token", 18), + (10025, "AEON", "AEON Token", 18), + (10066, "CO", "coai", 18), + (10081, "JOCT", "Japan Open Chain Testnet Token", 18), + (10085, "VC", "Volcano Coin", 18), + (10086, "ETH", "Ether", 18), + (10088, "GT", "GateToken", 18), + (10096, "MNV", "MNV", 18), + (10101, "GEN", "GEN", 18), + (10143, "MON", "Testnet MON Token", 18), + (10200, "XDAI", "Chiado xDAI", 18), + (10201, "PWR", "Power", 18), + (10218, "TEA", "Sepolia Tea", 18), + (10222, "GLC", "GLC", 18), + (10242, "AA", "Arthera", 18), + (10243, "AA", "Arthera", 18), + (10248, "0XT", "0XT", 18), + (10321, "TAO", "TAO", 18), + (10324, "TAO", "TAO", 18), + (10395, "WLC", "Worldland", 18), + (10507, "NUM", "NUM Token", 18), + (10508, "NUM", "NUM Token", 18), + (10777, "LIMO", "Limonata", 18), + (10791, "TBC", "TrustBitcoin", 18), + (10823, "CCP", "CryptoCoinPay", 18), + (10849, "L1", "L1", 18), + (10850, "L1ID", "L1 ID", 18), + (10888, "tGS", "TGameSwift", 18), + (10904, "AULT", "Testnet AULT Token", 18), + (10920, "FUSE", "Fuse", 18), + (10946, "QDC", "Quadrans Coin", 18), + (10947, "tQDC", "Quadrans Testnet Coin", 18), + (11000, "KBC", "KBC", 18), + (11011, "ETH", "Sepolia Ether", 18), + (11100, "BOL", "BOL", 18), + (11110, "ASA", "Astra", 18), + (11111, "WGM", "WAGMI", 18), + (11115, "tASA", "test-Astra", 18), + (11119, "HBIT", "HashBit Native Token", 18), + (11124, "ETH", "ETH", 18), + (11221, "SC20", "Shine", 18), + (11227, "TZW", "JIRI", 18), + (11235, "ISLM", "Islamic Coin", 18), + (11343, "MESH", "StateMesh", 18), + (11437, "SHYFTT", "Shyft Test Token", 18), + (11451, "XAU", "Aurum", 18), + (11501, "BTC", "BTC", 18), + (11503, "BTC", "BTC", 18), + (11504, "BTC", "BTC", 18), + (11521, "SATS", "SATS", 18), + (11612, "SRDX", "Sardis", 18), + (11811, "ARK", "ARK Token", 18), + (11812, "DARK", "DARK Token", 18), + (11820, "ART", "ART", 18), + (11822, "ART", "ART", 18), + (11888, "SANold", "SANold", 18), + (11891, "ARIA20", "Arianee", 18), + (12001, "ETH", "Ether", 18), + (12009, "SATS", "SatoshiChain Coin", 18), + (12020, "ATR", "Aternos", 18), + (12051, "tZERO", "ZERO", 18), + (12052, "ZERO", "ZERO", 18), + (12123, "BRC", "BRC Chain mainnet native token", 18), + (12216, "L2P", "L2P", 18), + (12306, "FIBO", "FIBONACCI UTILITY TOKEN", 18), + (12321, "BLG", "Blg", 18), + (12323, "ETH", "Ether", 18), + (12324, "ETH", "Ether", 18), + (12325, "ETH", "Ether", 18), + (12345, "FITFI", "FITFI", 18), + (12358, "GDPR", "GDPR", 18), + (12553, "RSS3", "RSS3", 18), + (12715, "RIK", "Rikeza", 18), + (12781, "PDA", "Playdapp", 18), + (12890, "tQNET", "Quantum Chain", 18), + (12898, "BTLT", "BTLT Token", 18), + (13000, "ECG", "ECG", 18), + (13113, "RNTX", "RANNTA Core X", 18), + (13308, "CREDIT", "Credit", 18), + (13337, "BEAM", "Beam", 18), + (13370, "ETH", "Cannon Testnet Ether", 18), + (13371, "IMX", "IMX", 18), + (13373, "LBRTY", "Liberty", 18), + (13381, "PHX", "Phoenix", 18), + (13396, "MASA", "Masa Token", 18), + (13473, "tIMX", "Test IMX", 18), + (13505, "G", "Sepolia Gravity", 18), + (13579, "tTRUST", "Testnet TRUST", 18), + (13600, "KNB", "Kronobit", 18), + (13746, "TG7T", "TG7T", 18), + (13766, "TRX", "TRX", 18), + (13812, "OPN", "Susono", 18), + (14000, "ECG", "ECG", 18), + (14088, "ZRHt", "Zeroth", 18), + (14149, "BTH", "Bitharvest Mainnet Native Token", 18), + (14235, "lzrBTC", "lzrBTC", 18), + (14324, "EVO", "Evolve", 18), + (14333, "tVTRU", "Vitruveo Test Coin", 18), + (14601, "S", "Sonic", 18), + (14800, "VANA", "VANA", 18), + (14801, "DAT", "DAT", 18), + (14853, "eHMND", "eHMND", 18), + (15000, "QUAI", "Quai", 18), + (15003, "dIMX", "Dev IMX", 18), + (15257, "POODL", "Poodl", 18), + (15259, "POODL", "Poodl", 18), + (15430, "KYMTC", "KYMTC", 18), + (15526, "NRXN", "NirmalX Nova", 18), + (15551, "LOOP", "LOOP", 18), + (15555, "EVM", "Trust EVM", 18), + (15557, "EOS", "EOS", 18), + (15885, "BRT", "BRT", 18), + (15888, "BRT", "BRT", 18), + (16000, "MTT", "MetaDot Token", 18), + (16001, "MTTest", "MetaDot Token TestNet", 18), + (16116, "OAS", "Oasys", 18), + (16166, "CPH", "Cypherium", 18), + (16180, "PLYR", "PLYR", 18), + (16182, "ETH", "Ether", 18), + (16350, "INC", "Testnet INC", 18), + (16481, "ETH", "Pivotal ETH", 18), + (16507, "GSYS", "Genesys", 18), + (16600, "A0GI", "A0GI", 18), + (16601, "A0GI", "A0GI", 18), + (16602, "0G", "0G", 18), + (16661, "0G", "0G", 18), + (16688, "ERIS", "Eris", 18), + (16718, "AMB", "Amber", 18), + (16868, "NGRX", "Nagara", 18), + (16869, "tNGRX", "Nagara Testnet Token", 18), + (16888, "tIVAR", "tIvar", 18), + (17000, "ETH", "Testnet ETH", 18), + (17001, "ETH", "Redstone Testnet Ether", 18), + (17069, "ETH", "Ether", 18), + (17071, "POP", "OnchainPoints.xyz", 18), + (17117, "OAS", "Oasys", 18), + (17171, "G8C", "G8Chain", 18), + (17172, "ECLP", "Eclipse", 16), + (17180, "PLT", "Palette Token", 18), + (17217, "KONET", "KONET", 18), + (17735, "ESPT", "Esport Token", 18), + (17771, "DMD", "DMD", 18), + (17777, "EOS", "EOS", 18), + (18000, "ZKST", "ZKST", 18), + (18122, "STN", "STN", 18), + (18159, "POM", "Proof Of Memes", 18), + (18181, "G8C", "G8Coin", 18), + (18231, "ETH", "unreal Ether", 18), + (18233, "reETH", "unreal Ether", 18), + (18686, "MXC", "MXC zkEVM Moonchain", 18), + (18880, "tZKJ", "tZKJ", 18), + (18881, "UOS", "Ultra Token", 18), + (18888, "TKX", "Titan tkx", 18), + (18889, "TKX", "Titan tkx", 18), + (19011, "OAS", "OAS", 18), + (19077, "BCX", "BCX", 18), + (19180, "LCC", "LocaCoin", 18), + (19191, "BCX", "BCX", 18), + (19224, "DCSM", "Decentraconnect Social", 18), + (19478, "TC", "Trustivon", 18), + (19480, "QMS", "QMS", 18), + (19515, "SEP", "SEP", 18), + (19516, "SEP", "SEP", 18), + (19517, "SEP", "SEP", 18), + (19518, "SEP", "SEP", 18), + (19527, "DOT", "Magnet Network", 18), + (19546, "ETH", "ETH", 18), + (19600, "LBC", "LBRY Credits", 8), + (19777, "ATX", "Astra", 18), + (19845, "BTCIX", "BTCIX Network", 18), + (19991, "UOS", "Ultra Token", 18), + (19998, "SUP", "SUP", 18), + (20001, "ETHW", "EthereumPoW", 18), + (20010, "KPG", "Kepeng", 18), + (20011, "KPGT", "Kepeng Test", 18), + (20033, "AGLS", "AGLS", 18), + (20041, "NIZA", "Niza Global", 18), + (20047, "NOION", "Noion", 18), + (20073, "NIZA", "Niza Global", 18), + (20143, "MON", "Devnet MON Token", 18), + (20226, "MOLI", "Molibra", 18), + (20250, "NCH", "Native Cheesecoin", 18), + (20260, "MoSE", "MITOSE", 18), + (20261, "MCOS", "MACos Coin", 18), + (20310, "sBTC", "Signet BTC", 18), + (20441, "X1", "XUSD ONE", 18), + (20678, "vETH", "vETH", 18), + (20729, "CLO", "Callisto", 18), + (20736, "hP2", "Hooked P2", 18), + (20765, "JONO", "Jono11 Token", 18), + (20770, "CLT", "Clutch", 18), + (20771, "CLT", "Clutch", 18), + (20993, "ETH", "Ether", 18), + (21000, "ACTN", "Action", 18), + (21004, "C4EI", "C4EI", 18), + (21097, "tINCO", "test-Inco", 18), + (21133, "AAH", "AAH", 18), + (21210, "FREE", "FREE", 18), + (21211, "FREE", "FREE", 18), + (21223, "DCP", "DCP", 18), + (21224, "DCP", "DCP", 18), + (21320, "SHCX", "SushiiCoin", 18), + (21337, "CPAY", "CPAY", 18), + (21363, "LETH", "Lestnet Ether", 18), + (21816, "OMC", "omChain", 18), + (21912, "ONF", "Origin NFT", 18), + (22023, "SFL", "shuffle", 18), + (22028, "KAM", "KriptoAman", 18), + (22040, "AMB", "Amber", 18), + (22222, "ZBC", "Zebec", 18), + (22324, "GOLDX", "GoldX", 18), + (22776, "MAPO", "MAPO", 18), + (22888, "ACCESS", "Access Coin", 18), + (23006, "ABN", "Antofy", 18), + (23023, "PBLK", "Premium Block", 18), + (23118, "IDE", "IDE", 18), + (23232, "GOTAS", "GOTAS", 18), + (23294, "ROSE", "Sapphire Rose", 18), + (23295, "TEST", "Sapphire Test Rose", 18), + (23451, "DRX", "DreyerX", 18), + (23452, "DRX", "DreyerX", 18), + (23888, "ETH", "Ether", 18), + (24076, "KYMTC", "KYMTC", 18), + (24101, "CENT", "CENT", 18), + (24116, "STEAMX", "SteamX", 18), + (24125, "XURA", "XURA", 18), + (24484, "WEB", "Webchain Ether", 18), + (24734, "MINTME", "MintMe.com Coin", 18), + (24816, "RECALL", "Recall", 18), + (25186, "LILA", "LiquidLayer", 18), + (25327, "ETH", "ETH", 18), + (25363, "ETH", "Ether", 18), + (25821, "H2", "Lambda H2", 18), + (25839, "tALV", "AlveyCoin Testnet", 18), + (25888, "GOLDT", "GOLDT", 18), + (25925, "tKUB", "KUB Coin", 18), + (26026, "tFRM", "Ferrum", 18), + (26100, "qpFRM", "Ferrum", 18), + (26217, "IRL", "Integra", 18), + (26218, "IRL", "Integra", 18), + (26262, "BOSA", "Coinbosa", 18), + (26482, "DUCX", "DUCX", 18), + (26483, "DUCX", "DUCX", 18), + (26514, "ETH", "Ether", 18), + (26600, "HTZ", "Hertz", 18), + (26863, "OAC", "OAC", 18), + (26888, "AB", "AB", 18), + (26988, "NEW", "Newton", 18), + (27125, "Dapo", "Dapo", 18), + (27181, "KLAOS", "KLAOS", 18), + (27483, "ETH", "Sepolia Ether", 18), + (27827, "ZERO", "ZERO", 18), + (28125, "Dapo", "Dapo", 18), + (28516, "ETH", "Ether", 18), + (28518, "ETH", "Ether", 18), + (28528, "ETH", "Goerli Ether", 18), + (28540, "RVO", "RVO", 18), + (28882, "ETH", "Ether", 18), + (29112, "TOPIA", "TOPIA", 18), + (29223, "NEXA", "Nexa", 18), + (29225, "NEXA", "Nexa", 18), + (29536, "KEC", "KaiChain Testnet Native Token", 18), + (29548, "OAS", "OAS", 18), + (30000, "QCO", "QCO", 18), + (30067, "ECE", "ECE", 18), + (30088, "MY", "Miyou", 18), + (30103, "CAU", "Canxium", 18), + (30303, "ETH", "Ether", 18), + (30730, "MOVE", "Move", 18), + (30731, "MOVE", "Move", 18), + (30732, "MOVE", "Move", 18), + (30939, "DLT", "Dilithium3", 18), + (31102, "ESN", "Ethersocial Network Ether", 18), + (31223, "CLD", "CloudTx", 18), + (31224, "CLD", "CloudTx", 18), + (31337, "GO", "GoChain Coin", 18), + (31414, "MTHN", "MTHN Testnet", 18), + (31415, "ETH", "Ethereum", 18), + (31611, "BTC", "Bitcoin", 18), + (31612, "BTC", "Bitcoin", 18), + (31753, "INTD", "Intdestcoin", 18), + (31754, "INTD", "Intdestcoin Testnet", 18), + (32001, "ETH", "W3Gamez Testnet Ether", 18), + (32026, "NUMN", "Numen", 18), + (32323, "BASED", "BasedAI", 18), + (32382, "SANR", "SANR", 18), + (32520, "Brise", "Bitrise Token", 18), + (32659, "FSN", "Fusion", 18), + (32769, "ZIL", "Zilliqa", 18), + (32770, "ZIL", "Zilliqa", 18), + (32990, "ZIL", "Zilliqa", 18), + (33033, "NGL", "Entangle", 18), + (33101, "ZIL", "Zilliqa", 18), + (33103, "ZIL", "Zilliqa", 18), + (33111, "APE", "ApeCoin", 18), + (33133, "NGL", "Entangle", 18), + (33139, "APE", "ApeCoin", 18), + (33210, "XCLOUD", "XCLOUD", 18), + (33333, "AVS", "Aves", 18), + (33385, "ZIL", "Zilliqa", 18), + (33401, "SLING", "Sling", 18), + (33431, "ETH", "Ether", 18), + (33469, "ZIL", "Zilliqa", 18), + (33710, "TR5", "Test R5", 18), + (33979, "ETH", "Ether", 18), + ( + 33999, + "DAPPST", + "Pencils Protocol Sepolia Testnet Token", + 18, + ), + (34443, "ETH", "Ether", 18), + (34504, "ZEUSX", "The ZEUS Token", 18), + (34952, "BGB", "BGB", 18), + (35011, "taro", "TARO Coin", 18), + (35147, "COINA", "COINA", 18), + (35441, "QGOV", "QGOV", 18), + (35443, "Q", "Q token", 18), + (36888, "AB", "AB", 18), + (36900, "ADI", "ADI", 18), + (36968, "AMA", "AMA", 9), + (36969, "AMA", "AMA", 9), + (37111, "GRASS", "GRASS", 18), + (38400, "cmRPG", "Rangers Protocol Gas", 18), + (38401, "ttRPG", "Rangers Protocol Gas", 18), + (38833, "iKAS", "iKAS", 18), + (38836, "iKAS", "iKAS", 18), + (39656, "PRM", "Primal Network", 18), + (39797, "NRG", "Energi", 18), + (39815, "OHO", "OHO", 18), + (40000, "DIVC", "DIVC", 18), + (40204, "SALT", "SALT", 18), + (41455, "AZERO", "Aleph Zero", 18), + (41500, "OXYN", "Oxyn Gas", 18), + (41923, "EDU", "EDU", 18), + (42000, "HLS", "Helios", 18), + (42001, "PMON", "PMON Token", 18), + (42026, "ETH", "Ether", 18), + (42069, "peggle", "pegglecoin", 18), + (42070, "WMTx", "WMTx", 18), + (42072, "AGENT", "Agent", 18), + (42096, "HEU", "Heurist", 18), + (42161, "ETH", "Ether", 18), + (42170, "ETH", "Ether", 18), + (42220, "CELO", "CELO", 18), + (42261, "TEST", "Emerald Test Rose", 18), + (42262, "ROSE", "Emerald Rose", 18), + (42355, "GOLDX", "GoldX", 18), + (42420, "RWA", "Real World Asset", 18), + (42421, "RWA", "Real World Asset", 18), + (42429, "USD", "No native currency", 18), + (42431, "USD", "No native currency", 18), + (42766, "USDC", "USDC Token", 18), + (42793, "XTZ", "tez", 18), + (42801, "OAS", "OAS", 18), + (42888, "ETH", "Ether", 18), + (43110, "ATH", "Athereum Ether", 18), + (43111, "ETH", "Ether", 18), + (43113, "AVAX", "Avalanche", 18), + (43114, "AVAX", "Avalanche", 18), + (43288, "BOBA", "Boba Token", 18), + (43419, "GUN", "GUN", 18), + (43521, "M", "Formicarium M", 18), + (43522, "M", "Insectarium M", 18), + (43851, "USDC", "USDC Token", 18), + (44444, "FREN", "FREN", 18), + (44445, "QTM", "Quantum", 18), + (44787, "CELO", "CELO", 18), + (45000, "TXL", "TXL", 18), + (45003, "JUNE", "JUNE", 18), + (45004, "DAI1", "DAI1", 18), + (45005, "USDT1", "USDT1", 18), + (45006, "USD1", "USD1", 18), + (45007, "mBTC1", "mBTC1", 18), + (45008, "GLD1", "GLD1", 18), + (45009, "LTC1", "LTC1", 18), + (45010, "DOGE1", "DOGE1", 18), + (45011, "EUR1", "EUR1", 18), + (45012, "SGD1", "SGD1", 18), + (45013, "BCH1", "BCH1", 18), + (45014, "LINK1", "LINK1", 18), + (45056, "ETH", "ETHER", 18), + (45454, "SWP", "SWP", 18), + (45510, "DEE", "Deelance", 18), + (45513, "BLESS", "Bless", 18), + (46630, "ETH", "Sepolia Ether", 18), + (46634, "GNOD", "Gnodi", 18), + (46688, "T-FSN", "Testnet Fusion", 18), + (47763, "GAS", "Gas", 18), + (47803, "BAX", "BAX", 18), + (47805, "REI", "REI", 18), + (48359, "vETH", "Testnet vETH", 18), + (48795, "FUEL", "FUEL", 18), + (48898, "ETH", "ETH", 18), + (48899, "ETH", "ETH", 18), + (48900, "ETH", "ETH", 18), + (49049, "WIRE", "WIRE", 18), + (49088, "BFC", "Bifrost", 18), + (49321, "GUN", "GUN", 18), + (49797, "NRG", "Energi", 18), + (50000, "CITRO", "CITRO", 18), + (50001, "ETH", "Ether", 18), + (50002, "MNT", "Hoodi Mantle", 18), + (50005, "OAS", "OAS", 18), + (50006, "OAS", "OAS", 18), + (50021, "GCD", "GCD", 18), + (50104, "SOPH", "Sophon", 18), + (50312, "STT", "Somnia Testnet", 18), + (50341, "RDO", "Reddio", 18), + (50342, "RDO", "Reddio", 18), + (50366, "ASH", "ASH", 18), + (50505, "STB", "STB", 18), + (50888, "ERB", "ERB", 18), + (51178, "MOZ", "Lumoz Test Token", 18), + (51712, "SRDX", "Sardis", 18), + (51888, "ETH", "Ether", 18), + (52014, "ETN", "Electroneum", 18), + (52225, "CCC", "Cytonic", 18), + (52226, "CCC", "Cytonic", 18), + (53277, "DOID", "DOID", 18), + (53302, "ETH", "Sepolia Ether", 18), + (53456, "ETH", "Ether", 18), + (53457, "DODO", "DODO", 18), + (53935, "JEWEL", "Jewel", 18), + (54170, "@G", "Graphite", 18), + (54176, "OVER", "Over", 18), + (54211, "ISLMT", "Islamic Coin", 18), + (54321, "TOROE", "Toroe", 18), + (55004, "ETH", "Ether", 18), + (55007, "ETH", "Ether", 18), + (55244, "ETH", "Ether", 18), + (55377, "ETH", "Sepolia Ether", 18), + (55378, "ETH", "Ether", 18), + (55551, "PTON", "Photon", 18), + (55555, "REI", "Rei", 18), + (55556, "tREI", "tRei", 18), + (55614, "FLA", "Flamma", 18), + (55930, "HAVE", "HAVE", 18), + (55931, "MOCK", "MOCK", 18), + (56026, "ETH", "ETH", 18), + (56288, "BOBA", "Boba Token", 18), + (56400, "ZERO", "ZERO", 18), + (56671, "KASH", "KASH", 18), + (56672, "KASH", "KASH", 18), + (56789, "NOVA", "Nova", 18), + (56797, "DOID", "DOID", 18), + (57000, "TSYS", "Testnet Syscoin", 18), + (57054, "S", "Sonic", 18), + (57073, "ETH", "Ether", 18), + (57451, "SEC", "COINSEC", 18), + (58008, "ETH", "Sepolia Ether", 18), + (58680, "MOZ", "Lumoz Quidditch Testnet Token", 18), + (59140, "ETH", "Linea Ether", 18), + (59141, "ETH", "Linea Ether", 18), + (59144, "ETH", "Linea Ether", 18), + (59902, "tMETIS", "tMetis", 18), + (59971, "GCODE", "GenesysCode", 18), + (60000, "TKM", "TKM", 18), + (60001, "TKM", "TKM", 18), + (60002, "TKM", "TKM", 18), + (60103, "TKM", "TKM", 18), + (60186, "EBLA", "EBLA", 18), + (60187, "EBLA", "EBLA", 18), + (60188, "EBLA", "EBLA", 18), + (60600, "POT", "POTOS Token", 18), + (60603, "POT", "POTOS Token", 18), + (60808, "ETH", "Ether", 18), + (60850, "ETH", "Ether", 18), + (61022, "BTC", "BTC", 18), + (61166, "MAGIC", "MAGIC", 18), + (61406, "KEC", "KaiChain Native Token", 18), + (61564, "JELLO", "JELLO", 18), + (61800, "AIUM", "Axelium", 18), + (61803, "EGAZ", "EGAZ", 18), + (61916, "DKN", "DoKEN", 18), + (62049, "ETH", "Ether", 18), + (62050, "ETH", "Ether", 18), + (62092, "tTTX", "tTTX", 18), + (62124, "FRAC", "Fractal", 18), + (62298, "cBTC", "Citrea BTC", 18), + (62320, "CELO", "CELO", 18), + (62606, "APOLLO", "Apollo", 18), + (62621, "MTV", "MultiVAC", 18), + (62831, "PLYR", "PLYR", 18), + (62850, "SIGMA", "SIGMA", 18), + (63000, "ECS", "eCredits", 18), + (63001, "ECS", "eCredits", 18), + (63002, "ECS", "eCredits", 18), + (63157, "GHST", "Aavegotchi GHST Token", 18), + (63868, "UNIT", "Unit", 18), + (64002, "ETH", "Ether", 18), + (64327, "MIDS", "Midas", 18), + (64460, "MIGO", "MigoCoin", 18), + (65349, "CRAT", "CRATD2C", 18), + (65357, "VE", "Vecno", 18), + (65450, "SCOL", "Scolcoin", 18), + (65535, "XCC", "XCC", 18), + (65536, "ATA", "ATA", 18), + (66665, "CETH", "CreatorETH", 18), + (66666, "BAC", "Bitasset Chain Native Token", 18), + (66988, "JNS", "Janus", 18), + (67390, "MCD", "MCD", 18), + (67588, "COSMIC", "Cosmic Chain", 18), + (68414, "NXPC", "NEXPACE", 18), + (68770, "OAS", "OAS", 18), + (68775, "OAS", "OAS", 18), + (69000, "ANIME", "Animecoin", 18), + (69420, "CHEESE", "CHEESE", 18), + (69923, "ILYt", "ILITY Token", 18), + (70000, "TKM", "TKM", 18), + (70001, "TKM", "TKM", 18), + (70002, "TKM", "TKM", 18), + (70007, "SEVEN", "Seven", 18), + (70103, "TKM", "TKM", 18), + (70700, "ETH", "Ether", 18), + (70701, "ETH", "Ether", 18), + (71111, "GuapX", "GuapcoinX", 18), + (71117, "WCO", "WadzChain Coin", 18), + (71393, "CKB", "CKB", 8), + (71401, "pCKB", "pCKB", 18), + (71402, "pCKB", "pCKB", 18), + (72020, "EAV7", "EAV7", 18), + (72080, "tNXRA", "tNXRA", 18), + (72344, "RUSD", "Radius USD", 18), + (72778, "CAGA", "Caga", 18), + (72888, "CAGA", "CAGA", 18), + (72957, "USDr", "USD Rayls", 18), + (72992, "GROC", "Groc", 18), + (73114, "ICBT", "ICB Testnet Token", 18), + (73115, "ICBX", "ICB Native Token", 18), + (73285, "NEBX", "Nebula Cash", 18), + (73571, "SMN", "SELEMAN", 18), + (73790, "NVC", "NeuroVatic Coin", 18), + (73799, "VT", "Volta Token", 18), + (73927, "ETH", "Ether", 18), + (75000, "RESIN", "Ether", 18), + (75338, "APPL", "AppLayer", 18), + (75512, "OAS", "OAS", 18), + (75513, "OAS", "OAS", 18), + (76672, "CARR", "CarrChain Coin", 18), + (77001, "BORA", "BORA", 18), + (77077, "AUT", "Autyon", 18), + (77238, "tFNC", "Foundry Chain Testnet", 18), + (77410, "ETH", "Sepolia Ether", 18), + (77612, "VNT", "VNT", 18), + (77652, "CARR", "CarrChain Coin", 18), + (77677, "ETH", "Ether", 18), + (77777, "TOROE", "Toroe", 18), + (77778, "SD", "StreetDog", 18), + (78110, "FIN", "Firenze Ether", 18), + (78281, "DFLY", "Dragonfly", 18), + (78430, "AMP", "AMP", 18), + (78431, "BLT", "BLT", 18), + (78432, "CON", "CON", 18), + (78600, "VANRY", "Vanguard Vanry", 18), + (78651, "ETH", "Sepolia Ether", 18), + (79879, "STAND", "Standard in Gold", 18), + (80001, "MATIC", "MATIC", 18), + (80002, "POL", "POL", 18), + (80008, "ETH", "Ether", 18), + (80069, "BERA", "Testnet BERA Token", 18), + (80084, "BERA", "BERA Token", 18), + (80085, "BERA", "BERA Token", 18), + (80094, "BERA", "BERA Token", 18), + (80096, "HZC", "Hizoco", 18), + (80451, "GRT", "The Graph", 18), + (80808, "HPX", "HPX", 18), + (80931, "FORT", "FORT", 18), + (81008, "ZRN", "Zorin", 18), + (81041, "NRK", "NRK", 18), + (81224, "ETH", "Ether", 18), + (81341, "MEER-T", "Amana Testnet", 18), + (81342, "MEER-M", "Amana Mixnet", 18), + (81343, "MEER-P", "Amana Privnet", 18), + (81351, "MEER-T", "Flana Testnet", 18), + (81352, "MEER-M", "Flana Mixnet", 18), + (81353, "MEER-P", "Flana Privnet", 18), + (81361, "MEER-T", "Mizana Testnet", 18), + (81362, "MEER-M", "Mizana Mixnet", 18), + (81363, "MEER-P", "Mizana Privnet", 18), + (81457, "ETH", "Ether", 18), + (81720, "QNET", "Quantum Chain", 18), + (82459, "SU", "Service Unit Token", 18), + (82614, "VEMP", "VEMP", 18), + (82716, "PYLUN", "PYLUN", 18), + (83144, "KICK", "KICK Testnet Token", 18), + (83278, "Esa", "Esa", 18), + (83592, "KTN", "Katron AI", 18), + (83868, "KICK", "KICK Testnet Token", 18), + (83872, "ZEDX", "Zedxion", 9), + (84531, "ETH", "Goerli Ether", 18), + (84532, "ETH", "Sepolia Ether", 18), + (84841, "O", "O.XYZ", 18), + (84886, "AER", "Aerie", 18), + (85321, "GDPR", "GDPR", 18), + (85449, "CYBER", "Cyber Trust", 18), + (86606, "CP", "CP", 18), + (86608, "CP", "CP", 18), + (88002, "tZBC", "Zebec Test Token", 18), + (88008, "XOM", "OmniCoin", 18), + (88088, "PLUS", "PLUS", 18), + (88118, "SHARK", "Shark", 18), + (88188, "ATOS", "Atoshi", 18), + (88559, "INO", "InoAi", 18), + (88688, "ETH", "Ether", 18), + (88788, "PTEK", "PropTech Token", 18), + (88800, "ZKAS", "ZKAS", 18), + (88811, "UNIT0", "UNIT0", 18), + (88817, "UNIT0", "UNIT0", 18), + (88819, "UNIT0", "UNIT0", 18), + (88866, "MAX", "MAX", 18), + (88880, "CHZ", "Chiliz", 18), + (88882, "CHZ", "Chiliz", 18), + (88888, "CHZ", "Chiliz", 18), + (88899, "UNITE", "Unite", 18), + (88991, "OKAS", "Otckas", 18), + (89001, "INSAN", "INSAN", 18), + (90001, "PUNDAI", "Pundi AIFX", 18), + (90002, "USC", "USC", 18), + (90210, "BVE", "Beverly Hills Testnet Ether", 18), + (90354, "ETH", "Ethereum", 18), + (90909, "QB", "QuantumBit", 18), + (91002, "tZBC", "Nautilus Zebec Testnet Tokens", 18), + (91111, "ETH", "Ether", 18), + (91120, "DAP", "DAP", 18), + (91342, "ETH", "Sepolia Ether", 18), + (91715, "tcBNB", "BNB Chain Native Token", 18), + (92001, "LAMB", "test-Lamb", 18), + (92278, "MPT", "Miracle Play Token", 18), + (92531, "WIRE", "WIRE", 18), + (92532, "WIRE", "WIRE", 18), + (92533, "WIRE", "WIRE", 18), + (93572, "LILA", "LiquidLayer Testnet", 18), + (93747, "SVM", "SVM", 18), + (94524, "ETH", "Ether", 18), + (95432, "SRIX", "SRIX", 18), + (96368, "tLUX", "tLux", 18), + (96369, "LUX", "Lux", 18), + (96370, "MOZ", "Lumoz Mainnet Token", 18), + (96371, "ETH", "Ether", 18), + (96970, "MANTIS", "Mantis", 18), + (97053, "TSC", "Tetron Testnet", 18), + (97055, "TSC", "Tetron Mainnet", 18), + (97288, "BOBA", "Boba Token", 18), + (97435, "SLINGT", "Sling Test", 18), + (97453, "SDA", "Sidra Digital Asset", 18), + (97476, "ETH", "Ether", 18), + (97477, "ETH", "Ether", 18), + (97531, "GREEN", "GREEN", 18), + (97741, "PEPU", "PEPU", 18), + (97766, "MBC", "MBC", 18), + (97970, "OZ7", "OptimusZ7", 18), + (98864, "ETH", "Plume Sepolia Ether", 18), + (98865, "ETH", "Plume Ether", 18), + (98866, "PLUME", "Plume", 18), + (98867, "PLUME", "Plume", 18), + (98875, "ETH", "Ether", 18), + (98881, "ETH", "Ether", 18), + (98964, "Pay1", "Pay1", 18), + (98985, "SPN", "SPN", 18), + (99099, "$EL", "eLiberty", 18), + (99110, "DC", "Dorsen Chain", 18), + (99119, "tDC", "Dorsen Chain", 18), + (99876, "EMC", "Edge Matrix Chain Token", 18), + (99879, "EMC", "Edge Matrix Chain Token", 18), + (99998, "UBC", "UBC", 18), + (99999, "ADI", "ADI", 18), + (100000, "QKC", "QKC", 18), + (100001, "QKC", "QKC", 18), + (100002, "QKC", "QKC", 18), + (100003, "QKC", "QKC", 18), + (100004, "QKC", "QKC", 18), + (100005, "QKC", "QKC", 18), + (100006, "QKC", "QKC", 18), + (100007, "QKC", "QKC", 18), + (100008, "QKC", "QKC", 18), + (100009, "VET", "VeChain", 18), + (100010, "VET", "VeChain", 18), + (100011, "QKC", "QKC", 18), + (100021, "ETH", "Ether", 18), + (100100, "xDAI", "Chiado xDAI", 18), + (100501, "SK", "SK", 18), + (100610, "RDP", "RDP", 18), + (100611, "RDL", "RDL", 18), + (101003, "JUNE", "Socotra JUNE", 18), + (101010, "FREE", "FREE", 18), + (101088, "XTC", "Xitcoin", 18), + (101089, "XTC", "Xitcoin", 18), + (101101, "VORD", "Vordium", 18), + (101102, "VORD", "Vordium Testnet", 18), + (102030, "CTC", "CTC", 18), + (102031, "tCTC", "Testnet CTC", 18), + (102032, "devCTC", "Devnet CTC", 18), + (103090, "◈", "CRFI", 18), + (103454, "MASA", "Masa Token", 18), + (104566, "CAS", "KaspaClassic", 18), + (105105, "STRAX", "STRAX", 18), + (105363, "MOZ", "Lumoz Testnet Token", 18), + (108801, "BRO", "Brother", 18), + (110000, "QKC", "QKC", 18), + (110001, "QKC", "QKC", 18), + (110002, "QKC", "QKC", 18), + (110003, "QKC", "QKC", 18), + (110004, "QKC", "QKC", 18), + (110005, "QKC", "QKC", 18), + (110006, "QKC", "QKC", 18), + (110007, "QKC", "QKC", 18), + (110008, "QKC", "QKC", 18), + (110011, "QKC", "QKC", 18), + (110110, "MARS", "Mars Credit", 18), + (111000, "SIBR", "TestSIBR", 18), + (111111, "SIBR", "Siberium", 18), + (111188, "reETH", "re.al Ether", 18), + (111451, "XAU", "Aurum", 18), + (112358, "METAO", "Metao", 18), + (119139, "DAP", "DAP", 18), + (120893, "ETH", "Sepolia Ether", 18), + (121212, "GAS", "Esquiline Gas", 18), + (121213, "USDC", "USDC", 18), + (121214, "USDC", "USDC", 18), + (121215, "USDC", "USDC", 18), + (121224, "FUMA", "FUSHUMA", 18), + (121525, "NOVA", "Ethernova", 18), + (122605, "SWSS", "SWSS Coin", 18), + (123321, "GEM", "GEM", 18), + (123456, "ADIL", "Devnet ADIL", 18), + (124832, "MITO", "MITO", 18), + (127001, "G", "Gravity", 18), + (127823, "XTZ", "tez", 18), + (128123, "XTZ", "tez", 18), + (129399, "ETH", "Ether", 18), + (130526, "RPHX", "RPHX", 18), + (131071, "MRSN", "Mersennet", 18), + (131313, "DIONE", "DIONE", 18), + (131419, "ETND", "ETND", 18), + (132902, "ETH", "Ether", 18), + (139420, "tMIDX", "Midpoint Cross Testnet", 18), + (140586, "BEX", "BEX", 18), + (141319, "MAG", "MagApe", 18), + (141491, "BTH", "Bitharvest Testnet Native Token", 18), + (142857, "ict", "ict", 18), + (153043, "WHEAT", "WheatCoin", 18), + (153153, "DIONE", "DIONE", 18), + (153871, "USD", "No native currency", 18), + (158245, "XCOIN", "XCOIN", 18), + (158345, "XCOIN", "XCOIN", 18), + (161201, "OPN", "Openledger", 18), + (161212, "PLAY", "Play", 18), + (161803, "ETH", "Ether", 18), + (165279, "ECLAT", "Eclat", 18), + (167000, "ETH", "Ether", 18), + (167004, "ETH", "Ether", 18), + (167005, "ETH", "Ether", 18), + (167006, "ETH", "Ether", 18), + (167007, "ETH", "Ether", 18), + (167008, "ETH", "Ether", 18), + (167009, "ETH", "Ether", 18), + (167013, "ETH", "Ether", 18), + (168168, "ZCD", "ZCD", 18), + (168169, "MUD", "MUD", 18), + (171000, "FAIR", "FAIR", 18), + (171717, "WCO", "WadzChain Token", 18), + (175177, "tstLIT", "Test LIT", 18), + (175188, "tstLPX", "Test LPX", 18), + (175190, "tLit", "Test Lit", 18), + (175200, "LITKEY", "Lit Protocol", 18), + (177155, "JULIAN", "JULIAN", 18), + (179170, "CLT", "ClearToken", 18), + (181228, "ETH", "Ether", 18), + (188710, "BDCC", "Bitica Coin", 18), + (188881, "CONDOR", "Condor Native Token", 18), + (190415, "ETH", "Ether", 18), + (191919, "ALTB", "Altblockscan", 18), + (192940, "ETH", "Ether", 18), + (193939, "ETH", "Ethereum", 18), + (197197, "ETH", "Ether", 18), + (197198, "ETH", "Ether", 18), + (198989, "BSW", "Lydia Token", 18), + (199991, "MAZZE", "MAZZE Testnet", 18), + (200000, "FAI", "FAI", 18), + (200024, "NOS", "Nitro", 18), + (200101, "mTAda", "milkTAda", 18), + (200200, "ZOO", "Zoo", 18), + (200202, "mTAlgo", "milkTAlgo", 18), + (200625, "AKA", "Akroma Ether", 18), + (200810, "BTC", "BTC", 18), + (200901, "BTC", "BTC", 18), + (201018, "atp", "ATP", 18), + (201030, "atp", "ATP", 18), + (201804, "MYTH", "Mythos", 18), + (202020, "tDEL", "Decimal", 18), + (202105, "TON", "TON", 18), + (202202, "BECX", "Bethel", 18), + (202209, "RISK", "RISK", 18), + (202212, "XN", "XN", 18), + (202401, "ETH", "ETH", 18), + (202424, "BFIT", "BFIT", 18), + (202599, "JU", "JU Testnet Token", 18), + (202601, "RON", "Ronin", 18), + (202624, "TWL", "Twala Coin", 18), + (204005, "XN", "XN", 18), + (205205, "tSTRAX", "tSTRAX", 18), + (210000, "JU", "JU", 18), + (210049, "tGAGI", "GitAGI", 18), + (210209, "SOR", "Sorian", 18), + (210210, "tSOR", "Sorian Testnet", 18), + (210425, "lat", "LAT", 18), + (212013, "HEI", "Heima", 18), + (220315, "MAS", "Master Bank", 18), + (221230, "REAP", "Reap", 18), + (221231, "tREAP", "test-Reap", 18), + (221978, "MNR", "Manora", 18), + (222222, "WETH", "Wrapped ETH", 18), + (222555, "DEEPL", "DeepL", 18), + (222666, "DEEPL", "DeepL", 18), + (222888, "MOCA", "MOCA", 18), + (223344, "TBOC", "B20", 18), + (224168, "TAFECO", "Taf ECO Chain Mainnet", 18), + (224400, "ETH", "CONET ETH", 18), + (224422, "CONET", "CONET Sebolia", 18), + (224433, "CONET", "CONET Cancun", 18), + (229772, "aETH", "AbyssETH", 18), + (230315, "tHSK", "HashKey Token", 18), + (234666, "HYM", "HAYMO", 18), + (235711, "UNI", "Universe Token", 18), + (240240, "STO", "Studio Token", 18), + (240241, "STO", "Studio Token", 18), + (240515, "BTC", "BTC", 18), + (240884, "HIP", "HIPERCAPITAL FINANCE Token", 18), + (241120, "tNOM", "TestNom", 18), + (246529, "ATS", "ARTIS sigma1 Ether", 18), + (246785, "tATS", "ARTIS tau1 Ether", 18), + (247253, "OAS", "OAS", 18), + (250210, "PTH", "PlasticHero", 18), + (250611, "STC", "StreamChain", 18), + (252525, "tCLT", "CLT", 18), + (256256, "CMP", "Caduceus Token", 18), + (258432, "ALTHEA", "Althea", 18), + (262144, "MPCQ", "MPCQ", 18), + (262371, "ECLAT", "Eclat Testnet", 18), + (266256, "GZN", "Gear Zero Network Native Token", 18), + (271271, "EGON", "EgonCoin", 18), + (271828, "FAT", "DC FAT", 18), + (271829, "FAT", "DC FAT", 18), + (272247, "NXY", "Nxy", 18), + (272520, "NXY", "Nxy", 18), + (281121, "$OC", "SoChain", 18), + (281123, "ETH", "Ether", 18), + (282828, "ETH", "Sepolia Ether", 18), + (290290, "PMT", "PMT", 18), + (290783, "PBX", "PBX", 18), + (292003, "CIP", "CIP", 18), + (309075, "OWCT", "OWCT", 18), + (313313, "SAHARA", "Sahara AI", 18), + (314159, "tFIL", "testnet filecoin", 18), + (320261, "tNUMN", "Testnet Numen", 18), + (322202, "PRX", "PAREX", 18), + (323213, "BGBC", "Bloom", 18), + (323432, "WOMOX", "ATestingToken", 18), + (325000, "ETH", "Ethereum", 18), + (327126, "WABA", "WABA", 18), + (328527, "ETH", "Ether", 18), + (330844, "TC", "TTcoin", 18), + (333313, "BGBC", "Bloom", 18), + (333331, "AVST", "AvesT", 18), + (333333, "USNT", "USNT", 18), + (333666, "tOONE", "tOONE", 18), + (333777, "tOONE", "tOONE", 18), + (333888, "tPOLIS", "tPolis", 18), + (333999, "POLIS", "Polis", 18), + (335700, "SCEN", "SCEN", 18), + (336655, "UBTC", "UBTC", 18), + (336666, "UBTC", "UBTC", 18), + (355110, "BTF", "Bitfinity Token", 18), + (355113, "BTF", "Bitfinity Token", 18), + (360890, "vTFUEL", "vTFUEL", 18), + (363636, "DGC", "Digit Coin", 18), + (369369, "WATT", "WATT", 18), + (373737, "HAP", "HAP", 18), + (380929, "ETH", "Ether", 18), + (381185, "ETH", "Ether", 18), + (381931, "METAL", "Metal", 18), + (381932, "METAL", "Metal", 18), + (383353, "CHEESE", "CHEESE", 18), + (404040, "TPBX", "Tipboxcoin", 18), + (411994, "PLN", "PLN", 18), + (413413, "AIE", "AIE", 18), + (420000, "ETH", "Ethereum", 18), + (420042, "VSG", "Vector Smart Gas", 18), + (420420, "KEK", "KEK", 18), + (420666, "tKEK", "tKEK", 18), + (420692, "AltETH", "Alterium ETH", 18), + (421611, "ETH", "Arbitrum Rinkeby Ether", 18), + (421613, "AGOR", "Arbitrum Goerli Ether", 18), + (421614, "ETH", "Sepolia Ether", 18), + (424242, "FTN", "FTN", 18), + (431140, "AVAX", "Avalanche", 18), + (432201, "ALOT", "Dexalot", 18), + (432204, "ALOT", "Dexalot", 18), + (440017, "@G", "Graphite", 18), + (444444, "ETH", "Sepolia Ether", 18), + (444900, "tWLK", "Weelink Chain Token", 18), + (450815, "tOKRW", "Testnet OKRW", 18), + (471100, "ETH", "Sepolia Ether", 18), + (473861, "UPRO", "Ultra Pro", 18), + (474142, "OPC", "OpenCoin", 10), + (482120, "BTCw", "Bitcoin Swap", 18), + (484752, "ETH", "Sepolia Ether", 18), + (486487, "GOBBL", "Gobbl Token", 18), + (490000, "AI3", "AI3", 18), + (490092, "PMPT", "PMPT", 18), + (504441, "PDA", "Playdapp", 18), + (511111, "ETH", "Ether", 18), + (512512, "CMP", "Caduceus Testnet Token", 18), + (513100, "ETHF", "EthereumFair", 18), + (524287, "MRSN", "Mersennet", 18), + (526916, "DCT", "DO", 18), + (534351, "ETH", "Ether", 18), + (534352, "ETH", "Ether", 18), + (534353, "ETH", "Ether", 18), + (534354, "TSETH", "Ether", 18), + (534849, "SHI", "Shina Inu", 18), + (535037, "BESC", "BeanEco SmartChain", 18), + (541764, "OVER", "Over", 18), + (543210, "ETH", "Ether", 18), + (552981, "OWCT", "OWCT", 18), + (555555, "PEN", "Pentagon", 18), + (555666, "ECLPS", "Eclipse", 18), + (555777, "ETH", "Sepolia Ether", 18), + (555888, "DST", "Ether", 18), + (560000, "HETU", "HETU", 18), + (560013, "ROGUE", "Rogue", 18), + (560048, "ETH", "Hoodi Ether", 18), + (563321, "PEER", "PeerCash", 18), + (612044, "tONE", "TestnetONE", 18), + (612055, "ONE", "ONE", 18), + (620156, "PEER", "PeerCash", 18), + (621847, "DJT", "TrumpChain", 18), + (622277, "HYP", "Hypra", 18), + (622463, "TON", "TON", 18), + (631571, "GHST", "Polter GHST", 18), + (641230, "BRNKC", "Bear Network Chain Native Token", 18), + (651940, "ALL", "ALL", 18), + (656476, "EDU", "EDU", 18), + (660279, "XAI", "Xai", 18), + (666666, "VS", "VS", 18), + (666888, "HLUSD", "Hela HLUSD", 18), + (668668, "CNW", "Conwai", 18), + (685685, "ETH", "Ether", 18), + (685689, "ETH", "Ether", 18), + (686868, "WON", "Won", 18), + (695569, "ETH", "Ether", 18), + (696969, "GAL", "Galadriel Devnet token", 18), + (698369, "GOLDPN", "GoldPrimeaNetwork", 18), + (706883, "FDS", "Fidesinnova", 18), + (710420, "TILT", "TILT", 18), + (713715, "SEI", "Sei", 18), + (715131, "ZTH", "Zether", 18), + (721529, "ERAM", "ERAM", 18), + (723107, "TIX", "TIX Token", 18), + (723487, "RUSD", "Radius USD", 18), + (726578, "HAN", "HAN", 18), + (737373, "ETH", "Ether", 18), + (743111, "ETH", "Sepolia Ether", 18), + (747474, "ETH", "Ether", 18), + (751230, "tBRNKC", "Bear Network Chain Testnet Token", 18), + (752024, "CAPS", "Capsule Coin", 18), + (752025, "CAPS", "Capsule Coin", 18), + (756689, "PYZ", "PYZ", 18), + (761412, "MIX", "Miexs Coin", 18), + (763373, "ETH", "Sepolia Ether", 18), + (763374, "ETH", "Ether", 18), + (763375, "ETH", "Ether", 18), + (764984, "L1T", "Lamina1 Test", 18), + (767368, "L1IDT", "L1ID Test", 18), + (776877, "MDM", "Modularium", 18), + (777772, "MNR", "MANORA", 18), + (777777, "WINR", "Winr", 18), + (777888, "OONE", "OONE", 18), + (778889, "UST", "Unitsky Token", 18), + (786786, "ZEBRO", "Zebrocoin", 18), + (787111, "mUSD", "mantraUSD", 18), + (787878, "WANNA", "WANNA", 18), + (789789, "EMED", "EMERALDZ", 18), + (797290, "SRX", "Syrax Token", 18), + (800001, "OCTA", "OctaSpace", 18), + (806582, "ETP", "Ethpar", 18), + (808080, "tBIZT", "tBIZT", 18), + (808813, "ETH", "Sepolia Ether", 18), + (810180, "ETH", "Ether", 18), + (810181, "ETH", "Ether", 18), + (810182, "ETH", "Ether", 18), + (812242, "ETH", "Sepolia Ether", 18), + (812397, "OAS", "OAS", 18), + (820522, "tTAS", "TAS", 18), + (821207, "GMB", "Gemba", 18), + (827431, "CURVE", "Curve", 18), + (838838, "HYPEC", "HyperCluster Token", 18), + (839320, "PRM", "Primal Network", 18), + (839999, "BTC", "Bitcoin", 18), + (840000, "tBTC", "Test Bitcoin", 8), + (846000, "APTA", "APTA", 18), + (853211, "ETH", "Ether", 18), + (855456, "DODAO", "Dodao", 18), + (879151, "BLX", "BlocX", 18), + (886699, "PNIC", "PNIC", 18), + (888882, "REXX", "REXX", 18), + (888888, "VS", "VS", 18), + (888991, "UNITE", "Testnet Unite", 18), + (900000, "POSI", "Posichain Native Token", 18), + (900190, "CRTC", "CryptoChain Token", 18), + (910000, "POSI", "Posichain Native Token", 18), + (911867, "ETH", "Ether", 18), + (912559, "RIA", "RIA", 18), + (918273, "DIVE", "DIVE", 18), + (920000, "POSI", "Posichain Native Token", 18), + (920001, "POSI", "Posichain Native Token", 18), + (923018, "FNCY", "FNCY", 18), + (955081, "JONO", "Jono12 Token", 18), + (955305, "ELV", "ELV", 18), + (963369, "AVI", "AVI Coin", 18), + (978657, "MAGIC", "Testnet MAGIC", 18), + (978658, "MAGIC", "Testnet MAGIC", 18), + (984122, "TIA", "TIA", 18), + (984123, "TIA", "TIA", 18), + (988207, "ECROX", "ECROX COIN", 18), + (998899, "CHAIN", "CHAIN", 18), + (999999, "AMC", "AMC", 18), + (1000001, "ETK", "ETK", 18), + (1001001, "DEX", "Dexpace", 18), + (1001996, "ETH", "Ether", 18), + (1008686, "Naga", "Naga", 18), + (1100789, "NMT", "NMT", 18), + (1122005, "DOGE", "Dogecoin", 18), + (1127469, "TILTG", "Tiltyard Token", 18), + (1212101, "FREE", "FREE", 18), + (1212111, "FREE", "FREE", 18), + (1234567, "SHR", "SHARECLE COIN", 18), + (1261120, "ETH", "Sepolia Ether", 18), + (1313114, "ETHO", "Etho Protocol", 18), + (1313500, "XERO", "Xerom Ether", 18), + (1337702, "kiETH", "kintsugi Ethere", 18), + (1337802, "ETH", "Testnet ETH", 18), + (1337803, "ETH", "Testnet ETH", 18), + (1398243, "ATA", "ATA", 18), + (1398244, "ATA", "ATA", 18), + (1440000, "XRP", "XRP", 18), + (1440002, "XRP", "XRP", 18), + (1449000, "XRP", "XRP", 18), + (1501869, "WATER", "WATER", 18), + (1612127, "ETH", "Ether", 18), + (1637450, "tBNB", "tBNB", 18), + (1658000, "BWA", "BWA", 18), + (1698369, "GOLDPN", "GoldPrimeaNetwork Test", 18), + (1716125, "QPC", "QuantPay Chain", 18), + (1731313, "ETH", "Ether", 18), + (1998991, "XPT", "Xphere Testnet", 18), + (2019775, "ETH", "Ether", 18), + (2021398, "USD", "DeBank USD", 18), + (2022091, "RISKT", "RISK Test Token", 18), + (2099156, "PI", "Plian Token", 18), + (2121217, "GG", "GG", 18), + (2203181, "lat", "LAT", 18), + (2206132, "lat", "LAT", 18), + (2222222, "CWEB", "CWEB", 18), + (2481632, "RECALL", "Recall", 18), + (2611555, "DGC", "DGC", 18), + (2632500, "COTI", "COTI", 18), + (2640162, "WTC", "Winmar Tech Chain", 18), + (2651420, "ETH", "Sepolia Ether", 18), + (2702128, "ETH", "ETH", 18), + (3132023, "SAHARA", "Sahara AI", 18), + (3141592, "tFIL", "testnet filecoin", 18), + (3397901, "ETH", "Ether", 18), + (3441005, "MANTA", "Manta", 18), + (3441006, "ETH", "Ether", 18), + (4000003, "ZERO", "ZERO", 18), + (4278608, "AIP", "AIP", 18), + (4281033, "ETH", "Ether", 18), + (4284265, "ZUUX", "ZUUX", 18), + (4444444, "ETH", "Sepolia Ether", 18), + (4457845, "ETH", "Ether", 18), + (5042002, "USDC", "USDC", 18), + (5112023, "NUMB", "NUMB Token", 18), + (5167003, "MXC", "MXC Wannsee zkEVM Testnet", 18), + (5167004, "MXC", "Moonchain Geneva Testnet", 18), + (5201420, "ETN", "Electroneum", 18), + (5318007, "lREACT", "Lasna React", 18), + (5318008, "REACT", "Kopli React", 18), + (5511555, "PXP", "PointPay", 18), + (5555555, "IMV", "Imversed Token", 18), + (5555558, "IMV", "Imversed Token", 18), + (5734951, "ETH", "Ether", 18), + (6038361, "ETH", "Sepolia Ether", 18), + (6231991, "HARRY", "HarryPotterObamaSonic10Inu", 18), + (6281971, "DOGE", "Dogecoin", 18), + (6666665, "SAFE", "SAFE(AnWang)", 18), + (6666666, "SAFE", "SAFE(AnWang)", 18), + (6666689, "TING", "Ting", 18), + (6912115, "EGAS", "EGAS", 18), + (6985385, "H", "H", 18), + (7000700, "JMDT", "JMDT", 18), + (7080969, "tHP", "tHP", 18), + (7082400, "COTI", "COTI", 18), + (7225878, "OAS", "OAS", 18), + (7355310, "VETH", "Vessel ETH", 18), + (7668378, "QOM", "Shiba Predator", 18), + (7762959, "MUSIC", "Musicoin", 18), + (7771777, "VYO", "VYO", 18), + (7773777, "VYO", "VYO", 18), + (7777777, "ETH", "Ether", 18), + (7849306, "USDX", "USDX", 18), + (8000008, "ETH", "Ether", 18), + (8000800, "tJMDT", "Test JMDT", 18), + (8007736, "PI", "Plian Token", 18), + (8008135, "tFHE", "tFHE", 18), + (8080808, "ETH", "Ether", 18), + (8601152, "WATER", "WATER", 18), + (8794598, "HAP", "HAP", 18), + (8888881, "QARE", "QARE", 18), + (8888888, "QARE", "QARE", 18), + (9322252, "GAS", "Gas", 18), + (9322253, "GAS", "Gas", 18), + (9999999, "FLT", "FLT", 18), + (10058111, "ETH", "Ether", 18), + (10058112, "ETH", "Sepolia Ether", 18), + (10067275, "TPI", "Plian Token", 18), + (10101010, "SVRN", "Soverun", 18), + (10111945, "STU", "Satu", 18), + (10241024, "ETH", "Ethereum", 18), + (10241025, "ETH", "Ethereum", 18), + (11111110, "CC", "ClawCoin", 18), + (11111111, "CC", "ClawCoin", 18), + (11142220, "CELO", "CELO", 18), + (11145513, "BLESS", "Bless", 18), + (11155111, "ETH", "Sepolia Ether", 18), + (11155420, "ETH", "Sepolia Ether", 18), + (11155931, "ETH", "RISE Testnet Ether", 18), + (11166111, "ETH", "Ethereum", 18), + (12020498, "LRPO", "Lummio Reward Points", 18), + (12052024, "ETH", "Ether", 18), + (12082025, "OFC", "ONFA Coin", 18), + (12142816, "WMC", "Winmar Coin", 18), + (12227331, "GAS", "Gas", 18), + (12227332, "GAS", "Gas", 18), + (13068200, "COTI2", "COTI2", 18), + (13371337, "TPEP", "PepChain Churchill Ether", 18), + (13600000, "H", "H", 18), + (13863860, "SIS", "Symbiosis", 18), + (14288640, "DEB", "DAON", 18), + (16658437, "TPI", "Plian Testnet Token", 18), + (16969696, "PRIVIX", "Privix Coin", 18), + (17000920, "ETH", "ETH", 18), + (17081945, "tSTU", "Satu Testnet", 18), + (18071918, "MAND", "Mand", 18), + (18289463, "ILT", "IOLite Ether", 18), + (18896214, "CNX", "Crynux", 18), + (18896215, "CNX", "Crynux", 18), + (19850818, "tDBC", "DeepBrainChain", 18), + (19880818, "DBC", "DeepBrainChain", 18), + (20180427, "FREE", "FREE", 18), + (20180430, "SMT", "SmartMesh Native Token", 18), + (20181205, "QKI", "quarkblockchain Native Token", 18), + (20201022, "PG", "Pego Native Token", 18), + (20221001, "ETH", "Sepolia Ether", 18), + (20230825, "VCT", "Testnet Vcity Token", 18), + (20240324, "USD", "DeBank USD", 18), + (20240603, "ETH", "Ether", 18), + (20241133, "sETH", "SWANETH", 18), + (20250217, "XP", "Xphere", 18), + (20250407, "lat", "LAT", 18), + (20250825, "VCITY", "Vcity Coin", 18), + (20256789, "ETP", "ETP Chain Native Token", 18), + (20260131, "MA", "MetaAssets", 18), + (20260532, "tGRD", "GridMind Test GRD", 18), + (20482050, "ETH", "Ether", 18), + (21000000, "BTCN", "Bitcorn", 18), + (21000001, "BTCN", "Bitcorn", 18), + (21072026, "ZAGROS", "Zagros", 18), + (22052002, "xlon", "Excelon", 18), + (24132016, "USDC", "USDC", 18), + (24772477, "6DO-T", "6Degree-Testnet Coin", 18), + (27082017, "TEXL", "TExlcoin", 18), + (27082022, "EXL", "Exlcoin", 18), + (28122024, "ETH", "Ether", 18), + (28945486, "AUX", "Auxilium coin", 18), + (29032022, "FLA", "Flacoin", 18), + (31415926, "tFIL", "testnet filecoin", 18), + (33626250, "TEEth", "SUAVE Toliman Eth", 18), + (33772211, "XOC", "Xone Coin", 18), + (34949059, "CITRO", "Citronus", 18), + (35855456, "JOYS", "JOYS", 18), + (37084624, "sFUEL", "sFUEL", 18), + (39916801, "KOZI", "Kozi", 18), + (42069000, "ETH", "Ether", 18), + (42424242, "GEN", "GEN Token", 18), + (43214913, "MAI", "maistestsubnet", 18), + (50591822, "POL", "Polygon", 18), + (52027071, "DTBC", "Deviant Token", 18), + (52027080, "tDTBC", "Deviant Token Testnet", 18), + (52164803, "tFLT", "tFLT", 18), + (61022448, "DKA", "dKargo", 18), + (61717561, "AQUA", "Aquachain Ether", 18), + (65000000, "ATN", "Auton", 18), + (65010000, "ATN", "Bakerloo Auton", 18), + (65010001, "ATN", "Bakerloo Auton", 18), + (65010002, "ATN", "Bakerloo Auton", 18), + (65010003, "ATN", "Bakerloo Auton", 18), + (65100000, "ATN", "Piccadilly Auton", 18), + (65100001, "ATN", "Piccadilly Auton", 18), + (65100002, "ATN", "Piccadilly Auton", 18), + (65100003, "ATN", "Piccadilly Auton", 18), + (65100004, "ATN", "Piccadilly Auton", 18), + (66666666, "WINR", "Winr", 18), + (68840142, "ETH", "Sepolia Ether", 18), + (77777777, "CRPTOS", "Cryptos", 18), + (77787778, "HETH", "0xHash", 18), + (79479957, "SX", "SX Network", 18), + (82696765, "ETH", "Sepolia Ether", 18), + (88558801, "ZBS", "Backstop Testnet 1", 18), + (88888888, "$TEAM", "TEAM", 18), + (89127398, "KROWN", "KROWN", 18), + (89346162, "ETH", "Ether", 18), + (91562037, "tMSTC", "MST Native Coin", 18), + (94204209, "ETH", "Sepolia Ether", 18), + (96969696, "PRIVIX", "Privix Coin", 18), + (97912060, "CHAD", "ChadChain", 18), + (99415706, "TOYS", "TOYS", 18), + (100000000, "ETHOS", "ETHOS", 18), + (100100101, "DEX", "Dexpace", 18), + (108160679, "ORAI", "Oraichain Token", 18), + (111557560, "ETH", "Sepolia Ether", 18), + (123420111, "ETH", "Sepolia Ether", 18), + (161221135, "ETH", "Plume Sepolia Ether", 18), + (168587773, "ETH", "Sepolia Ether", 18), + (188962142, "CNX", "Sepolia Crynux", 18), + (188962150, "CNX", "Testnet Crynux", 18), + (192837465, "GTH", "Gather", 18), + (222000222, "gMELD", "gMeld", 18), + (241320161, "USDC", "USDC", 18), + (245022926, "NEON", "Neon", 18), + (245022929, "NEON", "Neon", 18), + (245022934, "NEON", "Neon", 18), + (245022940, "NEON", "Neon", 18), + (253368190, "TIA", "TIA", 18), + (278611351, "SFUEL", "sFuel", 18), + (311752642, "OLT", "OLT", 18), + (324705682, "CREDIT", "Credits", 18), + (328527624, "ETH", "Sepolia Ether", 18), + (333000333, "gMELD", "gMeld", 18), + (344106930, "sFUEL", "sFUEL", 18), + (356256156, "GTH", "Gather", 18), + (420420417, "PAS", "PAS", 18), + (420420418, "KSM", "KSM", 18), + (420420419, "DOT", "DOT", 18), + (420420421, "WND", "Westies", 18), + (420420422, "PAS", "PAS", 18), + (476158412, "sFUEL", "sFUEL", 18), + (476462898, "SkpGPT", "SkpGPT", 18), + (486217935, "GTH", "Gather", 18), + (503129905, "sFUEL", "sFUEL", 18), + (531050104, "SOPH", "Sophon", 18), + (661898459, "SMART", "Smart", 6), + (666666666, "DEGEN", "DEGEN", 18), + (728126428, "TRX", "Tron", 6), + (737998412, "TAU", "TAU", 18), + (888888888, "ETH", "Ether", 18), + (889910245, "PTCE", "PTCE", 18), + (889910246, "PTCE", "PTCE", 18), + (974399131, "sFUEL", "sFUEL", 18), + (994873017, "LUMIA", "Lumia", 18), + (999999999, "ETH", "Sepolia Ether", 18), + (1000000003, "dSK", "dev3SK", 18), + (1020352220, "sFUEL", "sFUEL", 18), + (1122334455, "IPOS", "IPOS Network Ether", 18), + (1146703430, "CYB", "Cyb", 18), + (1187947933, "CREDIT", "Credits", 18), + (1213549903, "GAS", "Gas", 18), + (1229800785, "ITANI", "iTani", 18), + (1273227453, "sFUEL", "sFUEL", 18), + (1278060416, "VASYL", "OFFICIAL VASYL", 18), + (1313161554, "ETH", "Ether", 18), + (1313161555, "ETH", "Ether", 18), + (1313161556, "ETH", "Ether", 18), + (1313161560, "ETH", "Ether", 18), + (1313161567, "TURBO", "Turbo", 18), + (1313161573, "TUXA", "TUXA", 18), + (1313161911, "CNX", "Crynux", 18), + (1350216234, "sFUEL", "sFUEL", 18), + (1351057110, "sFUEL", "sFUEL", 18), + (1380012617, "ETH", "Ethereum", 18), + (1380996178, "RPTR", "Raptor", 18), + (1414484564, "tTOR", "Torium Test Token", 18), + (1415006552, "TWIX", "TWIX", 18), + (1417429182, "Z", "ZERO", 18), + (1444673419, "sFUEL", "sFUEL", 18), + (1482601649, "sFUEL", "sFUEL", 18), + (1511670449, "GPT", "GPT", 18), + (1517929550, "sFUEL", "sFUEL", 18), + (1523903251, "HAUST", "HAUST", 18), + (1564830818, "sFUEL", "sFUEL", 18), + (1570754601, "HAUST", "HAUST", 18), + (1660990954, "ETH", "Ether", 18), + (1666600000, "ONE", "ONE", 18), + (1666600001, "ONE", "ONE", 18), + (1666600002, "ONE", "ONE", 18), + (1666600003, "ONE", "ONE", 18), + (1666700000, "ONE", "ONE", 18), + (1666700001, "ONE", "ONE", 18), + (1666900000, "ONE", "ONE", 18), + (1666900001, "ONE", "ONE", 18), + (1702448187, "ETH", "ETHER", 18), + (1722641160, "ETH", "Sepolia Ether", 18), + (1802203764, "ETH", "Ether", 18), + (1903648807, "GEMU", "Gemuchain", 18), + (1918988905, "ETH", "Ethereum", 18), + (1952959480, "LUMIA", "Lumia", 18), + (2021121117, "HOP", "DataHoppers", 18), + (2026092601, "JULIAN", "JULIAN", 18), + (2030232745, "LUMIA", "Lumia", 18), + (2046399126, "sFUEL", "sFUEL", 18), + (2478899481, "ACME", "ACME", 18), + (2494104990, "TRX", "Tron", 6), + (2863311531, "ETH", "Ether", 18), + (3078101055, "GUT", "GUT", 18), + (3125659152, "PIRL", "Pirl Ether", 18), + (3416255149, "ULTIMA", "Ultima", 6), + (3448148188, "TRX", "Tron", 6), + (4216137055, "OLT", "OLT", 18), + (7078815900, "ETH", "Testnet ETH", 18), + (7088110746, "ETH", "Testnet ETH", 18), + (8691942025, "OFCT", "ONFA Coin", 18), + (11297108099, "PALM", "PALM", 18), + (11297108109, "PALM", "PALM", 18), + (28872323069, "GS-ETH", "GitSwarm Ether", 18), + (37714555429, "sXAI", "sXai", 18), + (44474237230, "Der", "Deriw", 18), + (88153591557, "CGT", "GelatoCGT", 18), + (96737205180, "ALD", "ALD Token", 18), + (107107114116, "ETH", "Ether", 18), + (111222333444, "ALT", "ALT", 18), + (111551119090, "TON", "Tokamak Network", 18), + (123420000220, "tFLT", "tFLT", 18), + (123420000558, "ETH", "Ether", 18), + (123420000586, "ETH", "Ether", 18), + (123420000588, "ETH", "Ether", 18), + (123420001114, "CAMP", "Camp", 18), + (197710212030, "NTT", "Ntity", 18), + (197710212031, "NTTH", "Ntity Haradev", 18), + (202402181627, "ETH", "Ether", 18), + (383414847825, "ZENIQ", "Zeniq", 18), + (666301171999, "PDC", "PDC", 18), + (666301179999, "SMM", "SmartPay Mobile Money", 18), + (6022140761023, "MOLE", "Molereum Ether", 18), + (16604737732183, "TIA", "TIA", 18), + (123354377739506, "USDST", "USDST", 18), + (195049586845898, "USDST", "USDST", 18), + (428962654539583, "ETH", "Ether", 18), + (868455272153094, "CKB", "CKB", 8), + (920637907288165, "ETH", "Ether", 18), + (2713017997578000, "ETH", "Ether", 18), + (2716446429837000, "ETH", "Ether", 18), + (2716446429837001, "DFFC", "DuckFourFourCoin", 18), +]; diff --git a/crates/clear-signing/src/render_shared.rs b/crates/clear-signing/src/render_shared.rs index fbaf6b1..c11e5ac 100644 --- a/crates/clear-signing/src/render_shared.rs +++ b/crates/clear-signing/src/render_shared.rs @@ -4,6 +4,7 @@ use num_bigint::BigUint; use crate::decoder::ArgumentValue; use crate::error::Error; +use crate::native_currencies::NATIVE_CURRENCIES; use crate::provider::DataProvider; use crate::token::TokenMeta; use crate::types::descriptor::Descriptor; @@ -75,26 +76,19 @@ pub(crate) fn resolve_metadata_constant_biguint( } } -/// Get native token metadata for a chain. +/// Get native token metadata for a chain from the EIP-155 chain list +/// (chainid.network). Unknown chains fall back to ETH with 18 decimals. pub(crate) fn native_token_meta(chain_id: u64) -> TokenMeta { - let (symbol, name) = match chain_id { - 1 | 5 | 11155111 => ("ETH", "Ether"), - 137 | 80001 => ("MATIC", "Polygon"), - 56 | 97 => ("BNB", "BNB"), - 43114 | 43113 => ("AVAX", "Avalanche"), - 250 => ("FTM", "Fantom"), - 14 => ("FLR", "Flare"), - 19 => ("SGB", "Songbird"), - 114 => ("C2FLR", "Coston2 Flare"), - 16 => ("CFLR", "Coston Flare"), - 42161 | 421613 => ("ETH", "Ether"), - 10 | 420 => ("ETH", "Ether"), - 8453 | 84531 => ("ETH", "Ether"), - _ => ("ETH", "Ether"), - }; + let (symbol, name, decimals) = NATIVE_CURRENCIES + .binary_search_by_key(&chain_id, |&(id, ..)| id) + .map(|i| { + let (_, symbol, name, decimals) = NATIVE_CURRENCIES[i]; + (symbol, name, decimals) + }) + .unwrap_or(("ETH", "Ether", 18)); TokenMeta { symbol: symbol.to_string(), - decimals: 18, + decimals, name: name.to_string(), } } @@ -436,11 +430,19 @@ mod tests { #[test] fn test_native_token_meta() { assert_eq!(native_token_meta(1).symbol, "ETH"); - assert_eq!(native_token_meta(137).symbol, "MATIC"); + assert_eq!(native_token_meta(137).symbol, "POL"); + assert_eq!(native_token_meta(80001).symbol, "MATIC"); + assert_eq!(native_token_meta(42220).symbol, "CELO"); + assert_eq!(native_token_meta(100).symbol, "XDAI"); assert_eq!(native_token_meta(56).symbol, "BNB"); assert_eq!(native_token_meta(14).symbol, "FLR"); assert_eq!(native_token_meta(19).symbol, "SGB"); - assert_eq!(native_token_meta(99999).symbol, "ETH"); + assert_eq!(native_token_meta(u64::MAX).symbol, "ETH"); + } + + #[test] + fn test_native_currencies_sorted_by_chain_id() { + assert!(NATIVE_CURRENCIES.windows(2).all(|w| w[0].0 < w[1].0)); } #[test] diff --git a/crates/clear-signing/tests/quickswap_integration.rs b/crates/clear-signing/tests/quickswap_integration.rs index 104cb84..2f459ff 100644 --- a/crates/clear-signing/tests/quickswap_integration.rs +++ b/crates/clear-signing/tests/quickswap_integration.rs @@ -224,7 +224,7 @@ async fn quickswap_swap_exact_tokens_for_tokens() { #[tokio::test] async fn quickswap_swap_exact_eth_for_tokens() { - // Native MATIC -> USDT swap with value + // Native POL -> USDT swap with value let result = run_quickswap_test( "0x7ff36ab5000000000000000000000000000000000000000000000000000000000749b4d10000000000000000000000000000000000000000000000000000000000000080000000000000000000000000fe3de3b49d1de7eb0cb28b57ac2abfdb3f1118dd00000000000000000000000000000000000000000000000000000000c809982100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000d500b1d8e8ef31e21c99d1db9a6444d3adf1270000000000000000000000000c2132d05d31c914a87c6611c10748aeb04b58e8f", "0x05dacd13ca9e300000", @@ -232,7 +232,7 @@ async fn quickswap_swap_exact_eth_for_tokens() { ).await; assert_eq!(result.intent, "Swap"); - assert_eq!(get_entry_value(&result, "Amount to Send"), "108 MATIC"); + assert_eq!(get_entry_value(&result, "Amount to Send"), "108 POL"); assert_eq!( get_entry_value(&result, "Minimum to Receive"), "122.270929 USDT" @@ -342,7 +342,7 @@ async fn quickswap_remove_liquidity_eth_with_permit() { #[tokio::test] async fn quickswap_add_liquidity_eth() { - // Add PDDOLLAR + native MATIC liquidity with value + // Add PDDOLLAR + native POL liquidity with value let result = run_quickswap_test( "0xf305d719000000000000000000000000146e58d34eab0bff7e0a63cfe9332908d680c66700000000000000000000000000000000000001516b4d1f2b1d156a60b6f7412a000000000000000000000000000000000000014fbb679dbb89bcfd0bc04a7f8e0000000000000000000000000000000000000000000000001b9de674df0700000000000000000000000000008a2f7f99b3b20cbe8343ac9f4292c9a1b12a0131000000000000000000000000000000000000000000000000000000006404ce44", "0x1bc16d674ec80000", diff --git a/scripts/generate_native_currencies.py b/scripts/generate_native_currencies.py new file mode 100755 index 0000000..c910f72 --- /dev/null +++ b/scripts/generate_native_currencies.py @@ -0,0 +1,60 @@ +#!/usr/bin/env python3 +"""Generate crates/clear-signing/src/native_currencies.rs from the EIP-155 chain list. + +Usage: scripts/generate_native_currencies.py [path/to/chains_mini.json] + +Without an argument, the script downloads https://chainid.network/chains_mini.json. +""" + +import json +import pathlib +import sys +import urllib.request + +SOURCE_URL = "https://chainid.network/chains_mini.json" +OUT = pathlib.Path(__file__).resolve().parent.parent / "crates/clear-signing/src/native_currencies.rs" + + +def rust_str(value: str) -> str: + escaped = [] + for ch in value: + if ch in ('"', "\\"): + escaped.append("\\" + ch) + elif ord(ch) < 0x20: + escaped.append(f"\\u{{{ord(ch):x}}}") + else: + escaped.append(ch) + return '"' + "".join(escaped) + '"' + + +def main() -> None: + if len(sys.argv) > 1: + chains = json.loads(pathlib.Path(sys.argv[1]).read_text()) + else: + with urllib.request.urlopen(SOURCE_URL) as resp: + chains = json.load(resp) + + rows = {} + for chain in chains: + native = chain.get("nativeCurrency") or {} + if not all(k in native for k in ("symbol", "name", "decimals")): + continue + rows[int(chain["chainId"])] = (native["symbol"], native["name"], int(native["decimals"])) + + lines = [ + "// @generated by scripts/generate_native_currencies.py from", + f"// {SOURCE_URL}. Do not edit by hand.", + "", + "/// `(chain_id, symbol, name, decimals)`, sorted by `chain_id`.", + "pub(crate) static NATIVE_CURRENCIES: &[(u64, &str, &str, u8)] = &[", + ] + for chain_id in sorted(rows): + symbol, name, decimals = rows[chain_id] + lines.append(f" ({chain_id}, {rust_str(symbol)}, {rust_str(name)}, {decimals}),") + lines.append("];") + OUT.write_text("\n".join(lines) + "\n") + print(f"wrote {len(rows)} chains to {OUT}") + + +if __name__ == "__main__": + main() From eeda785776ce9f517644f57412b3de39dd0be127 Mon Sep 17 00:00:00 2001 From: Manuel Wedler Date: Wed, 21 Oct 2026 14:31:49 +0200 Subject: [PATCH 4/7] fix: render calldata fields on array paths as nested calls (#20) A calldata field with an array path (calls.[].data) went through format_value and rendered raw hex, and the resolver did not load the descriptors of the inner calls. Render each element with the nested calldata renderer in the calldata and EIP-712 flows, expand array data paths in the resolver, and scope all element-relative path params (calleePath, amountPath, spenderPath, selectorPath, chainIdPath, collectionPath) to the element, not only tokenPath. --- crates/clear-signing/src/eip712.rs | 19 ++ crates/clear-signing/src/engine.rs | 64 +++++- .../src/resolver/nested_resolution.rs | 57 +++++ crates/clear-signing/tests/spec_compliance.rs | 203 ++++++++++++++++++ 4 files changed, 335 insertions(+), 8 deletions(-) diff --git a/crates/clear-signing/src/eip712.rs b/crates/clear-signing/src/eip712.rs index e26a6eb..e503681 100644 --- a/crates/clear-signing/src/eip712.rs +++ b/crates/clear-signing/src/eip712.rs @@ -396,6 +396,25 @@ fn render_typed_fields<'a>( { continue; } + // Each element of a calldata array is its own nested call. + if matches!(format.as_ref(), Some(FieldFormat::Calldata)) { + let entry = render_typed_calldata_field( + descriptor, + message, + &val, + item_params.as_ref(), + label, + container, + data_provider, + descriptors, + depth, + warnings, + nested_fallback, + ) + .await?; + entries.push(entry); + continue; + } let formatted = format_typed_value( descriptor, &val, diff --git a/crates/clear-signing/src/engine.rs b/crates/clear-signing/src/engine.rs index 23a3c2e..0d7c5e5 100644 --- a/crates/clear-signing/src/engine.rs +++ b/crates/clear-signing/src/engine.rs @@ -322,6 +322,20 @@ fn render_fields<'a>( { continue; } + // Each element of a calldata array is its own nested call. + if matches!(format.as_ref(), Some(FieldFormat::Calldata)) { + let entry = render_calldata_field( + ctx, + &val, + item_params.as_ref(), + label, + warnings, + nested_fallback, + ) + .await?; + entries.push(entry); + continue; + } let formatted = format_value( ctx, &val, @@ -1177,20 +1191,32 @@ pub(crate) fn split_array_iter_path(path: &str) -> Option<(&str, &str)> { Some((base, rest)) } -/// Scope the element-relative `tokenPath` to the array element being rendered -/// by rewriting its first `.[]` to a concrete index, so `tokenPath` +/// Scope the element-relative path params to the array element being +/// rendered by rewriting their first `.[]` to a concrete index, so `tokenPath` /// `details.[].token` resolves to `details.[index].token` for element `index`. -/// No-op when `tokenPath` is absent or has no `.[]`. Only `tokenPath` is -/// rewritten; other element-relative path params (`calleePath`, `amountPath`, -/// `spenderPath`) are not scoped here. Shared by the calldata and EIP-712 flat -/// array-iteration paths (field rendering + interpolation). +/// Applies to `tokenPath`, `chainIdPath`, `selectorPath`, `calleePath`, +/// `amountPath`, `spenderPath` and `collectionPath`. A path without `.[]` +/// stays unchanged. Shared by the calldata and EIP-712 flat array-iteration +/// paths (field rendering + interpolation). pub(crate) fn index_array_params( params: Option<&FormatParams>, index: usize, ) -> Option { let mut params = params.cloned()?; - if let Some(token_path) = params.token_path.as_ref() { - params.token_path = Some(token_path.replacen(".[]", &format!(".[{index}]"), 1)); + let indexed = format!(".[{index}]"); + for path in [ + &mut params.token_path, + &mut params.chain_id_path, + &mut params.selector_path, + &mut params.callee_path, + &mut params.amount_path, + &mut params.spender_path, + &mut params.collection_path, + ] + .into_iter() + .flatten() + { + *path = path.replacen(".[]", &indexed, 1); } Some(params) } @@ -2631,6 +2657,28 @@ mod tests { enums } + #[test] + fn test_index_array_params_scopes_all_element_paths() { + let params: FormatParams = serde_json::from_value(serde_json::json!({ + "tokenPath": "items.[].token", + "calleePath": "calls.[].target", + "amountPath": "calls.[].value", + "spenderPath": "calls.[].spender", + "selectorPath": "calls.[].selector", + "chainIdPath": "calls.[].chainId", + "collectionPath": "collections.[]" + })) + .unwrap(); + let indexed = index_array_params(Some(¶ms), 2).unwrap(); + assert_eq!(indexed.token_path.as_deref(), Some("items.[2].token")); + assert_eq!(indexed.callee_path.as_deref(), Some("calls.[2].target")); + assert_eq!(indexed.amount_path.as_deref(), Some("calls.[2].value")); + assert_eq!(indexed.spender_path.as_deref(), Some("calls.[2].spender")); + assert_eq!(indexed.selector_path.as_deref(), Some("calls.[2].selector")); + assert_eq!(indexed.chain_id_path.as_deref(), Some("calls.[2].chainId")); + assert_eq!(indexed.collection_path.as_deref(), Some("collections.[2]")); + } + #[test] fn enum_lookup_matches_bool_keys_case_insensitively() { let params = FormatParams { diff --git a/crates/clear-signing/src/resolver/nested_resolution.rs b/crates/clear-signing/src/resolver/nested_resolution.rs index 5fa819c..baabd19 100644 --- a/crates/clear-signing/src/resolver/nested_resolution.rs +++ b/crates/clear-signing/src/resolver/nested_resolution.rs @@ -117,6 +117,16 @@ fn resolve_recursive<'a>( results.push(resolved); + let calldata_fields: Vec = calldata_fields + .iter() + .flat_map(|field| { + field.expand_array(|base| match crate::engine::resolve_path(&decoded, base) { + Some(ArgumentValue::Array(items)) => items.len(), + _ => 0, + }) + }) + .collect(); + for field in &calldata_fields { let data_path = match &field.data_path { Some(p) => p, @@ -213,6 +223,23 @@ pub async fn resolve_descriptors_for_typed_data( results.push(selected.outer.clone()); + let calldata_fields: Vec = calldata_fields + .iter() + .flat_map(|field| { + field.expand_array(|base| { + match crate::eip712::resolve_typed_path( + &typed_data.message, + base, + chain_id, + Some(verifying_contract), + ) { + Some(serde_json::Value::Array(items)) => items.len(), + _ => 0, + } + }) + }) + .collect(); + for field in &calldata_fields { let callee_addr = match resolve_typed_nested_callee_for_resolver( field, @@ -295,6 +322,7 @@ pub async fn resolve_descriptors_for_typed_data( } /// Info extracted from a `FieldFormat::Calldata` display field. +#[derive(Clone)] struct CalldataFieldInfo { callee_path: Option, callee: Option, @@ -305,6 +333,35 @@ struct CalldataFieldInfo { chain_id_path: Option, } +impl CalldataFieldInfo { + /// Expand a field whose data path iterates an array (`calls.[].data`) into + /// one field per element. Each `.[]` path is rewritten to the element index, + /// as the renderer does. `array_len` gives the length of the array at a base + /// path. A field without `.[]` in its data path is returned unchanged. + fn expand_array(&self, array_len: impl Fn(&str) -> usize) -> Vec { + let Some((base, _)) = self + .data_path + .as_deref() + .and_then(crate::engine::split_array_iter_path) + else { + return vec![self.clone()]; + }; + (0..array_len(base)) + .map(|i| { + let indexed = format!(".[{i}]"); + let index = |p: &Option| p.as_ref().map(|p| p.replacen(".[]", &indexed, 1)); + CalldataFieldInfo { + data_path: index(&self.data_path), + callee_path: index(&self.callee_path), + selector_path: index(&self.selector_path), + chain_id_path: index(&self.chain_id_path), + ..self.clone() + } + }) + .collect() + } +} + /// Walk display fields (resolving `$ref` references) and collect calldata-format fields. fn collect_calldata_fields( fields: &[DisplayField], diff --git a/crates/clear-signing/tests/spec_compliance.rs b/crates/clear-signing/tests/spec_compliance.rs index 1956b28..ba64c7f 100644 --- a/crates/clear-signing/tests/spec_compliance.rs +++ b/crates/clear-signing/tests/spec_compliance.rs @@ -6961,3 +6961,206 @@ async fn test_eip712_bundled_group_keeps_hidden_array_elements_aligned() { _ => panic!("expected bundled group"), } } + +// ─── calldata format on an array path (`calls.[].data`) ─── + +const BATCH_TARGET_A: &str = "0x1000000000000000000000000000000000000001"; +const BATCH_TARGET_B: &str = "0x2000000000000000000000000000000000000002"; + +/// `batch((address,bytes)[])` with two calls: `consume()` on target A and +/// `burn()` on target B. +const BATCH_CALLDATA: &str = "5773341e00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000001000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000041dedc6f70000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000444df8e7000000000000000000000000000000000000000000000000000000000"; + +fn batch_inner_descriptors() -> (Descriptor, Descriptor) { + let inner = |address: &str, signature: &str, intent: &str| { + Descriptor::from_json( + &serde_json::json!({ + "context": { "contract": { "deployments": [{"chainId": 1, "address": address}] } }, + "metadata": { "owner": "inner", "enums": {}, "constants": {}, "maps": {} }, + "display": { + "definitions": {}, + "formats": { signature: { "intent": intent, "fields": [] } } + } + }) + .to_string(), + ) + .unwrap() + }; + ( + inner(BATCH_TARGET_A, "consume()", "Consume"), + inner(BATCH_TARGET_B, "burn()", "Burn"), + ) +} + +fn batch_calldata_fields() -> serde_json::Value { + serde_json::json!([{ + "path": "calls.[].data", + "label": "Call", + "format": "calldata", + "params": { "calleePath": "calls.[].target" } + }]) +} + +fn nested_intents(entries: &[DisplayEntry]) -> Vec { + entries + .iter() + .map(|entry| match entry { + DisplayEntry::Nested { label, intent, .. } => { + assert_eq!(label, "Call"); + intent.clone() + } + _ => panic!("expected Nested entry, got {entry:?}"), + }) + .collect() +} + +/// Each element of a calldata array renders as its own nested call, with +/// `calleePath` scoped to the same element. Calldata and EIP-712 must agree. +#[tokio::test] +async fn test_calldata_array_path_renders_each_element_nested_calldata_eip712_parity() { + let (inner_a, inner_b) = batch_inner_descriptors(); + + let outer = Descriptor::from_json( + &serde_json::json!({ + "context": { "contract": { "deployments": [{"chainId": 1, "address": "0xabc"}] } }, + "metadata": { "owner": "test", "enums": {}, "constants": {}, "maps": {} }, + "display": { + "definitions": {}, + "formats": { + "batch((address target, bytes data)[] calls)": { + "intent": "Batch", + "fields": batch_calldata_fields() + } + } + } + }) + .to_string(), + ) + .unwrap(); + let calldata = hex::decode(BATCH_CALLDATA).unwrap(); + let tx = TransactionContext { + chain_id: 1, + to: "0xabc", + calldata: &calldata, + value: None, + from: None, + implementation_address: None, + }; + let descriptors = vec![ + wrap_rd(outer, 1, "0xabc").into_iter().next().unwrap(), + wrap_rd(inner_a.clone(), 1, BATCH_TARGET_A) + .into_iter() + .next() + .unwrap(), + wrap_rd(inner_b.clone(), 1, BATCH_TARGET_B) + .into_iter() + .next() + .unwrap(), + ]; + let calldata_model = format_calldata(&descriptors, &tx, &EmptyDataProvider) + .await + .unwrap(); + assert_eq!( + nested_intents(&calldata_model.entries), + vec!["Consume", "Burn"] + ); + + let typed_outer = Descriptor::from_json( + &serde_json::json!({ + "context": { "eip712": { "deployments": [{"chainId": 1, "address": "0xabc"}] } }, + "metadata": { "owner": "test", "enums": {}, "constants": {}, "maps": {} }, + "display": { + "definitions": {}, + "formats": { + "Batch(Call[] calls)Call(address target,bytes data)": { + "intent": "Batch", + "fields": batch_calldata_fields() + } + } + } + }) + .to_string(), + ) + .unwrap(); + let typed_data: TypedData = serde_json::from_value(serde_json::json!({ + "types": { + "EIP712Domain": [], + "Batch": [{ "name": "calls", "type": "Call[]" }], + "Call": [ + { "name": "target", "type": "address" }, + { "name": "data", "type": "bytes" } + ] + }, + "primaryType": "Batch", + "domain": { "chainId": 1, "verifyingContract": "0xabc" }, + "message": { + "calls": [ + { "target": BATCH_TARGET_A, "data": "0x1dedc6f7" }, + { "target": BATCH_TARGET_B, "data": "0x44df8e70" } + ] + } + })) + .unwrap(); + let typed_descriptors = vec![ + wrap_rd(typed_outer, 1, "0xabc").into_iter().next().unwrap(), + wrap_rd(inner_a, 1, BATCH_TARGET_A) + .into_iter() + .next() + .unwrap(), + wrap_rd(inner_b, 1, BATCH_TARGET_B) + .into_iter() + .next() + .unwrap(), + ]; + let typed_model = format_typed_data(&typed_descriptors, &typed_data, &EmptyDataProvider) + .await + .unwrap(); + assert_eq!( + nested_intents(&typed_model.entries), + vec!["Consume", "Burn"] + ); +} + +/// The resolver also expands `calls.[].data`, so it loads the descriptor of +/// every element's callee. +#[tokio::test] +async fn test_resolver_finds_nested_descriptors_for_calldata_array_path() { + let (inner_a, inner_b) = batch_inner_descriptors(); + let outer = Descriptor::from_json( + &serde_json::json!({ + "context": { "contract": { "deployments": [{"chainId": 1, "address": "0xabc"}] } }, + "metadata": { "owner": "test", "enums": {}, "constants": {}, "maps": {} }, + "display": { + "definitions": {}, + "formats": { + "batch((address target, bytes data)[] calls)": { + "intent": "Batch", + "fields": batch_calldata_fields() + } + } + } + }) + .to_string(), + ) + .unwrap(); + + let mut source = clear_signing::resolver::StaticSource::new(); + source.add_calldata(1, "0xabc", outer); + source.add_calldata(1, BATCH_TARGET_A, inner_a); + source.add_calldata(1, BATCH_TARGET_B, inner_b); + + let calldata = hex::decode(BATCH_CALLDATA).unwrap(); + let tx = TransactionContext { + chain_id: 1, + to: "0xabc", + calldata: &calldata, + value: None, + from: None, + implementation_address: None, + }; + let descriptors = clear_signing::resolve_descriptors_for_tx(&tx, &source, None) + .await + .unwrap(); + let addresses: Vec<&str> = descriptors.iter().map(|d| d.address.as_str()).collect(); + assert_eq!(addresses, vec!["0xabc", BATCH_TARGET_A, BATCH_TARGET_B]); +} From c6d57c2bbeb3f8dc9d8f84927cb84d790e354db2 Mon Sep 17 00:00:00 2001 From: Manuel Wedler Date: Wed, 21 Oct 2026 14:44:32 +0200 Subject: [PATCH 5/7] Match an interpolation placeholder for one element of an array field (#22) * fix: match an interpolation placeholder for one element of an array field A placeholder such as {_swapData.[0].fromAmount} did not match the display field _swapData.[].fromAmount, so the whole interpolatedIntent was dropped. When no field matches exactly, match the array field and format the named element with its format and element-scoped params. * ci: update android-actions/setup-android to v4 (#24) Google no longer serves the legacy SDK package 'tools'. setup-android v3 installs 'tools platform-tools' by default, so sdkmanager fails with "Failed to find package 'tools'" and the Android job is red on every PR. v4 installs only 'platform-tools' (fix in v4.0.2). * fix: take native currency metadata from the EIP-155 chain list (#19) native_token_meta used a short hand-written table. Chain 137 rendered as MATIC (now POL), and chains not in the table, such as Celo (42220) and Gnosis (100), rendered as ETH. Generate the table from chainid.network/chains_mini.json, the source that the Sourcify runner uses. * fix: render calldata fields on array paths as nested calls (#20) A calldata field with an array path (calls.[].data) went through format_value and rendered raw hex, and the resolver did not load the descriptors of the inner calls. Render each element with the nested calldata renderer in the calldata and EIP-712 flows, expand array data paths in the resolver, and scope all element-relative path params (calleePath, amountPath, spenderPath, selectorPath, chainIdPath, collectionPath) to the element, not only tokenPath. --------- Co-authored-by: Bartosz Rozwarski --- crates/clear-signing/src/eip712.rs | 27 ++++++ crates/clear-signing/src/engine.rs | 25 +++++ crates/clear-signing/src/render_shared.rs | 72 ++++++++++++--- crates/clear-signing/tests/spec_compliance.rs | 91 +++++++++++++++++++ 4 files changed, 204 insertions(+), 11 deletions(-) diff --git a/crates/clear-signing/src/eip712.rs b/crates/clear-signing/src/eip712.rs index e503681..60f95a6 100644 --- a/crates/clear-signing/src/eip712.rs +++ b/crates/clear-signing/src/eip712.rs @@ -2222,6 +2222,33 @@ async fn resolve_and_format_typed_interpolation( ) -> Result { let field = resolve_interpolation_field_spec(fields, excluded, path)?; + // One element of an array field (`x.[2].y` for `x.[].y`): format that + // element like field rendering does (parity with the calldata path). + if let Some(i) = field.element_index { + let element_path = field.path.replacen(".[]", &format!(".[{i}]"), 1); + let value = + resolve_typed_path_in_context(message, &element_path, container)?.ok_or_else(|| { + Error::Descriptor(format!( + "interpolatedIntent path '{}' could not be resolved from typed data", + path + )) + })?; + let item_params = crate::engine::index_array_params(field.params, i); + let mut warnings = Vec::new(); + return format_typed_value( + descriptor, + &Some(value), + field.format, + item_params.as_ref(), + container, + message, + None, + data_provider, + &mut warnings, + ) + .await; + } + // Array-iteration paths (`.[]`) format each element like field rendering and // join with " and " (parity with the calldata path). if let Some((base, rest)) = crate::engine::split_array_iter_path(field.path) { diff --git a/crates/clear-signing/src/engine.rs b/crates/clear-signing/src/engine.rs index 0d7c5e5..f6a7b62 100644 --- a/crates/clear-signing/src/engine.rs +++ b/crates/clear-signing/src/engine.rs @@ -2580,6 +2580,31 @@ async fn resolve_and_format_for_interpolation( ) -> Result { let field = resolve_interpolation_field_spec(fields, excluded, path)?; + // One element of an array field (`x.[2].y` for `x.[].y`): format that + // element like field rendering does. + if let Some(i) = field.element_index { + let element_path = field.path.replacen(".[]", &format!(".[{i}]"), 1); + let value = resolve_path(ctx.decoded, &element_path).ok_or_else(|| { + Error::Descriptor(format!( + "interpolatedIntent path '{}' could not be resolved from calldata", + path + )) + })?; + let item_params = index_array_params(field.params, i); + let mut warnings = RenderDiagnostics::new(); + return format_value( + ctx, + &Some(value), + field.format, + item_params.as_ref(), + field.path, + field.label, + field.separator, + &mut warnings, + ) + .await; + } + // Array-iteration paths (`.[]`) format each element like field rendering and // join with " and "; a scalar `resolve_path` returns None for `.[]`, which // would otherwise drop the whole interpolatedIntent. diff --git a/crates/clear-signing/src/render_shared.rs b/crates/clear-signing/src/render_shared.rs index c11e5ac..4df2997 100644 --- a/crates/clear-signing/src/render_shared.rs +++ b/crates/clear-signing/src/render_shared.rs @@ -267,6 +267,9 @@ pub(crate) struct InterpolationFieldSpec<'a> { pub format: Option<&'a FieldFormat>, pub params: Option<&'a FormatParams>, pub separator: Option<&'a str>, + /// Set when the placeholder names one element (`x.[2].y`) of an array + /// field (`x.[].y`): the element index. + pub element_index: Option, } /// Normalize a path for interpolation matching: a bare parameter name (`amount`) @@ -275,9 +278,24 @@ fn normalize_interpolation_path(path: &str) -> &str { path.strip_prefix("#.").unwrap_or(path) } -pub(crate) fn find_interpolation_field<'a>( +/// If `placeholder` names one element of the array field path `field_path` +/// (`x.[2].y` for `x.[].y`), return the element index. +fn array_element_index(field_path: &str, placeholder: &str) -> Option { + let field_path = normalize_interpolation_path(field_path); + let placeholder = normalize_interpolation_path(placeholder); + let pos = field_path.find(".[]")?; + let (base, rest) = (&field_path[..pos], &field_path[pos + 3..]); + let after_base = placeholder.strip_prefix(base)?.strip_prefix(".[")?; + let (index, after_index) = after_base.split_once(']')?; + if after_index != rest || index.is_empty() || !index.bytes().all(|b| b.is_ascii_digit()) { + return None; + } + index.parse().ok() +} + +fn find_field_matching<'a>( fields: &'a [DisplayField], - path: &str, + matcher: &dyn Fn(&str) -> Option>, ) -> Option> { for field in fields { match field { @@ -289,17 +307,20 @@ pub(crate) fn find_interpolation_field<'a>( params, separator, .. - } if normalize_interpolation_path(field_path) == normalize_interpolation_path(path) => { - return Some(InterpolationFieldSpec { - label, - path: field_path, - format: format.as_ref(), - params: params.as_ref(), - separator: separator.as_deref(), - }); + } => { + if let Some(element_index) = matcher(field_path) { + return Some(InterpolationFieldSpec { + label, + path: field_path, + format: format.as_ref(), + params: params.as_ref(), + separator: separator.as_deref(), + element_index, + }); + } } DisplayField::Group { field_group } => { - if let Some(spec) = find_interpolation_field(&field_group.fields, path) { + if let Some(spec) = find_field_matching(&field_group.fields, matcher) { return Some(spec); } } @@ -310,6 +331,24 @@ pub(crate) fn find_interpolation_field<'a>( None } +/// Find the display field for an interpolation placeholder. An exact path +/// match wins. Otherwise a placeholder that names one element of an array +/// field (`x.[2].y` for the field `x.[].y`) matches that field. +pub(crate) fn find_interpolation_field<'a>( + fields: &'a [DisplayField], + path: &str, +) -> Option> { + let wanted = normalize_interpolation_path(path); + find_field_matching(fields, &|field_path| { + (normalize_interpolation_path(field_path) == wanted).then_some(None) + }) + .or_else(|| { + find_field_matching(fields, &|field_path| { + array_element_index(field_path, path).map(Some) + }) + }) +} + pub(crate) fn resolve_interpolation_field_spec<'a>( fields: &'a [DisplayField], excluded: &[String], @@ -427,6 +466,17 @@ mod tests { ); } + #[test] + fn test_array_element_index() { + assert_eq!(array_element_index("x.[].y", "x.[2].y"), Some(2)); + assert_eq!(array_element_index("#.x.[].y", "x.[0].y"), Some(0)); + assert_eq!(array_element_index("x.[]", "x.[10]"), Some(10)); + assert_eq!(array_element_index("x.[].y", "x.[2].z"), None); + assert_eq!(array_element_index("x.[].y", "x.[-1].y"), None); + assert_eq!(array_element_index("x.[].y", "x.[].y"), None); + assert_eq!(array_element_index("x.y", "x.y"), None); + } + #[test] fn test_native_token_meta() { assert_eq!(native_token_meta(1).symbol, "ETH"); diff --git a/crates/clear-signing/tests/spec_compliance.rs b/crates/clear-signing/tests/spec_compliance.rs index ba64c7f..2254c93 100644 --- a/crates/clear-signing/tests/spec_compliance.rs +++ b/crates/clear-signing/tests/spec_compliance.rs @@ -7164,3 +7164,94 @@ async fn test_resolver_finds_nested_descriptors_for_calldata_array_path() { let addresses: Vec<&str> = descriptors.iter().map(|d| d.address.as_str()).collect(); assert_eq!(addresses, vec!["0xabc", BATCH_TARGET_A, BATCH_TARGET_B]); } + +// ─── interpolatedIntent placeholder for one element of an array field ─── + +/// A placeholder that names one element (`amounts.[1]`) of an array field +/// (`amounts.[]`) uses that field's format for that element. Calldata and +/// EIP-712 must agree. +#[tokio::test] +async fn test_interpolated_intent_array_element_placeholder_calldata_eip712_parity() { + let fields = serde_json::json!([ + { "path": "amounts.[]", "label": "Amount", "format": "unit", "params": { "base": "u" } } + ]); + let template = "First {amounts.[0]}, second {amounts.[1]}"; + + let calldata_descriptor = Descriptor::from_json( + &serde_json::json!({ + "context": { "contract": { "deployments": [{"chainId": 1, "address": "0xabc"}] } }, + "metadata": { "owner": "test", "enums": {}, "constants": {}, "maps": {} }, + "display": { + "definitions": {}, + "formats": { + "send(uint256[] amounts)": { + "intent": "Send", + "interpolatedIntent": template, + "fields": fields.clone() + } + } + } + }) + .to_string(), + ) + .unwrap(); + // send([7, 9]) + let calldata = hex::decode("43bb26340000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000009").unwrap(); + let tx = TransactionContext { + chain_id: 1, + to: "0xabc", + calldata: &calldata, + value: None, + from: None, + implementation_address: None, + }; + let calldata_model = format_calldata( + &wrap_rd(calldata_descriptor, 1, "0xabc"), + &tx, + &EmptyDataProvider, + ) + .await + .unwrap(); + + let typed_descriptor = Descriptor::from_json( + &serde_json::json!({ + "context": { "eip712": { "deployments": [{"chainId": 1, "address": "0xabc"}] } }, + "metadata": { "owner": "test", "enums": {}, "constants": {}, "maps": {} }, + "display": { + "definitions": {}, + "formats": { + "Send(uint256[] amounts)": { + "intent": "Send", + "interpolatedIntent": template, + "fields": fields + } + } + } + }) + .to_string(), + ) + .unwrap(); + let typed_data: TypedData = serde_json::from_value(serde_json::json!({ + "types": {"EIP712Domain": [], "Send": [{"name": "amounts", "type": "uint256[]"}]}, + "primaryType": "Send", + "domain": {"chainId": 1, "verifyingContract": "0xabc"}, + "message": {"amounts": [7, 9]} + })) + .unwrap(); + let typed_model = format_typed_data( + &wrap_rd(typed_descriptor, 1, "0xabc"), + &typed_data, + &EmptyDataProvider, + ) + .await + .unwrap(); + + assert_eq!( + calldata_model.interpolated_intent.as_deref(), + Some("First 7u, second 9u") + ); + assert_eq!( + typed_model.interpolated_intent, + calldata_model.interpolated_intent + ); +} From cf5619e006360735561e827df4c10d35bdd8b9e3 Mon Sep 17 00:00:00 2001 From: Manuel Wedler Date: Wed, 21 Oct 2026 14:46:47 +0200 Subject: [PATCH 6/7] Accept definitions without a label and apply the $ref label override (#23) * fix: accept definitions without a label and apply the $ref label A display definition without label failed to parse ('data did not match any variant of untagged enum DisplayField'), so the whole descriptor was rejected. The schema does not require label, and a reference's label overrides the definition's. Make Simple.label default to empty, and add the optional label to Reference and apply it when the reference expands. * ci: update android-actions/setup-android to v4 (#24) Google no longer serves the legacy SDK package 'tools'. setup-android v3 installs 'tools platform-tools' by default, so sdkmanager fails with "Failed to find package 'tools'" and the Android job is red on every PR. v4 installs only 'platform-tools' (fix in v4.0.2). * fix: take native currency metadata from the EIP-155 chain list (#19) native_token_meta used a short hand-written table. Chain 137 rendered as MATIC (now POL), and chains not in the table, such as Celo (42220) and Gnosis (100), rendered as ETH. Generate the table from chainid.network/chains_mini.json, the source that the Sourcify runner uses. * fix: render calldata fields on array paths as nested calls (#20) A calldata field with an array path (calls.[].data) went through format_value and rendered raw hex, and the resolver did not load the descriptors of the inner calls. Render each element with the nested calldata renderer in the calldata and EIP-712 flows, expand array data paths in the resolver, and scope all element-relative path params (calleePath, amountPath, spenderPath, selectorPath, chainIdPath, collectionPath) to the element, not only tokenPath. * Match an interpolation placeholder for one element of an array field (#22) * fix: match an interpolation placeholder for one element of an array field A placeholder such as {_swapData.[0].fromAmount} did not match the display field _swapData.[].fromAmount, so the whole interpolatedIntent was dropped. When no field matches exactly, match the array field and format the named element with its format and element-scoped params. * ci: update android-actions/setup-android to v4 (#24) Google no longer serves the legacy SDK package 'tools'. setup-android v3 installs 'tools platform-tools' by default, so sdkmanager fails with "Failed to find package 'tools'" and the Android job is red on every PR. v4 installs only 'platform-tools' (fix in v4.0.2). * fix: take native currency metadata from the EIP-155 chain list (#19) native_token_meta used a short hand-written table. Chain 137 rendered as MATIC (now POL), and chains not in the table, such as Celo (42220) and Gnosis (100), rendered as ETH. Generate the table from chainid.network/chains_mini.json, the source that the Sourcify runner uses. * fix: render calldata fields on array paths as nested calls (#20) A calldata field with an array path (calls.[].data) went through format_value and rendered raw hex, and the resolver did not load the descriptors of the inner calls. Render each element with the nested calldata renderer in the calldata and EIP-712 flows, expand array data paths in the resolver, and scope all element-relative path params (calleePath, amountPath, spenderPath, selectorPath, chainIdPath, collectionPath) to the element, not only tokenPath. --------- Co-authored-by: Bartosz Rozwarski --------- Co-authored-by: Bartosz Rozwarski Co-authored-by: Claude Opus 5.5 --- crates/clear-signing/src/engine.rs | 11 ++- crates/clear-signing/src/types/display.rs | 10 +- crates/clear-signing/tests/spec_compliance.rs | 91 +++++++++++++++++++ 3 files changed, 110 insertions(+), 2 deletions(-) diff --git a/crates/clear-signing/src/engine.rs b/crates/clear-signing/src/engine.rs index f6a7b62..981d1c4 100644 --- a/crates/clear-signing/src/engine.rs +++ b/crates/clear-signing/src/engine.rs @@ -750,18 +750,25 @@ pub(crate) fn expand_display_fields( DisplayField::Reference { reference, path, + label: ref_label, params: ref_params, encryption: ref_encryption, visible, } => { if let Some(resolved) = resolve_reference(descriptor, reference) { - let merged = merge_ref_with_definition( + let mut merged = merge_ref_with_definition( resolved, path, ref_params, ref_encryption, visible, ); + // The reference label overrides the definition label. + if let (Some(ref_label), DisplayField::Simple { label, .. }) = + (ref_label, &mut merged) + { + label.clone_from(ref_label); + } expanded.extend(expand_display_fields(descriptor, &[merged], warnings)); } else { warnings.push(render_warning( @@ -850,12 +857,14 @@ pub fn prepend_scope_path(field: &DisplayField, scope: &str) -> DisplayField { DisplayField::Reference { reference, path, + label, params, encryption, visible, } => DisplayField::Reference { reference: reference.clone(), path: Some(prepend_path(scope, path.as_deref())), + label: label.clone(), params: params.as_ref().map(|p| prepend_params(scope, p)), encryption: encryption.clone(), visible: visible.clone(), diff --git a/crates/clear-signing/src/types/display.rs b/crates/clear-signing/src/types/display.rs index c34939a..d8e7864 100644 --- a/crates/clear-signing/src/types/display.rs +++ b/crates/clear-signing/src/types/display.rs @@ -96,7 +96,8 @@ pub enum DisplayField { /// A reference to a definition: `{ "$ref": "$.display.definitions.foo", "path": "...", ... }`. /// /// Per ERC-7730 spec, a reference object carries `$ref` plus the field's own - /// `path`, optional `params` (which override definition params), and `visible`. + /// `path`, optional `label` and `params` (which override the definition's), + /// and `visible`. Reference { #[serde(rename = "$ref")] reference: String, @@ -105,6 +106,10 @@ pub enum DisplayField { #[serde(skip_serializing_if = "Option::is_none")] path: Option, + /// Label that overrides the definition's label, if set. + #[serde(default, skip_serializing_if = "Option::is_none")] + label: Option, + /// Params that override/extend the definition's params. #[serde(skip_serializing_if = "Option::is_none")] params: Option, @@ -144,6 +149,9 @@ pub enum DisplayField { #[serde(skip_serializing_if = "Option::is_none")] path: Option, + /// Optional in the schema: a definition can omit it, and the + /// referencing field then gives it. Empty when absent. + #[serde(default)] label: String, /// Literal constant value (alternative to `path`). diff --git a/crates/clear-signing/tests/spec_compliance.rs b/crates/clear-signing/tests/spec_compliance.rs index 2254c93..c084298 100644 --- a/crates/clear-signing/tests/spec_compliance.rs +++ b/crates/clear-signing/tests/spec_compliance.rs @@ -7255,3 +7255,94 @@ async fn test_interpolated_intent_array_element_placeholder_calldata_eip712_pari calldata_model.interpolated_intent ); } + +// ─── `$ref` label override and definitions without a label ─── + +/// A definition may omit `label` (the schema does not require it), and a +/// reference's `label` "overrides the label in the referenced definition if +/// set". Calldata and EIP-712 must agree. +#[tokio::test] +async fn test_reference_label_overrides_definition_label_calldata_eip712_parity() { + let definitions = serde_json::json!({ + "noLabel": { "format": "raw" }, + "withLabel": { "label": "Definition label", "format": "raw" } + }); + let fields = serde_json::json!([ + { "path": "a", "label": "First", "$ref": "$.display.definitions.noLabel" }, + { "path": "b", "label": "Second", "$ref": "$.display.definitions.withLabel" }, + { "path": "c", "$ref": "$.display.definitions.withLabel" } + ]); + + let calldata_descriptor = Descriptor::from_json( + &serde_json::json!({ + "context": { "contract": { "deployments": [{"chainId": 1, "address": "0xabc"}] } }, + "metadata": { "owner": "test", "enums": {}, "constants": {}, "maps": {} }, + "display": { + "definitions": definitions.clone(), + "formats": { "f(uint256 a,uint256 b,uint256 c)": { "intent": "F", "fields": fields.clone() } } + } + }) + .to_string(), + ) + .unwrap(); + let calldata = build_calldata( + "f(uint256 a,uint256 b,uint256 c)", + &[uint_word(1), uint_word(2), uint_word(3)], + ); + let tx = TransactionContext { + chain_id: 1, + to: "0xabc", + calldata: &calldata, + value: None, + from: None, + implementation_address: None, + }; + let calldata_model = format_calldata( + &wrap_rd(calldata_descriptor, 1, "0xabc"), + &tx, + &EmptyDataProvider, + ) + .await + .unwrap(); + + let typed_descriptor = Descriptor::from_json( + &serde_json::json!({ + "context": { "eip712": { "deployments": [{"chainId": 1, "address": "0xabc"}] } }, + "metadata": { "owner": "test", "enums": {}, "constants": {}, "maps": {} }, + "display": { + "definitions": definitions, + "formats": { "F(uint256 a,uint256 b,uint256 c)": { "intent": "F", "fields": fields } } + } + }) + .to_string(), + ) + .unwrap(); + let typed_data: TypedData = serde_json::from_value(serde_json::json!({ + "types": {"EIP712Domain": [], "F": [ + {"name": "a", "type": "uint256"}, + {"name": "b", "type": "uint256"}, + {"name": "c", "type": "uint256"} + ]}, + "primaryType": "F", + "domain": {"chainId": 1, "verifyingContract": "0xabc"}, + "message": {"a": 1, "b": 2, "c": 3} + })) + .unwrap(); + let typed_model = format_typed_data( + &wrap_rd(typed_descriptor, 1, "0xabc"), + &typed_data, + &EmptyDataProvider, + ) + .await + .unwrap(); + + assert_eq!( + semantic_item_snapshot(&calldata_model.entries), + vec![ + ("First".to_string(), "1".to_string()), + ("Second".to_string(), "2".to_string()), + ("Definition label".to_string(), "3".to_string()), + ] + ); + assert_semantic_parity(&calldata_model, &typed_model); +} From 05ddcaa798c284ae620dc636e1863a5a6810d72b Mon Sep 17 00:00:00 2001 From: RyukTheCoder <154742563+RyukTheCoder@users.noreply.github.com> Date: Wed, 21 Oct 2026 16:18:20 +0330 Subject: [PATCH 7/7] Render chainId values with EIP-155 reference names (#18) * Render chainId values with EIP-155 reference names (#14) The spec defines the chainId format as converting the value "to a Blockchain name using EIP-155 reference values", with "Ethereum Mainnet" as the example for 1. Use the `name` fields from the chainid.network EIP-155 list, so 137 renders as "Polygon Mainnet" instead of "Polygon" and matches @ethereum-sourcify/clear-signing. Adds a calldata/EIP-712 parity test for the chainId format. * ci: update android-actions/setup-android to v4 (#24) Google no longer serves the legacy SDK package 'tools'. setup-android v3 installs 'tools platform-tools' by default, so sdkmanager fails with "Failed to find package 'tools'" and the Android job is red on every PR. v4 installs only 'platform-tools' (fix in v4.0.2). * fix: take native currency metadata from the EIP-155 chain list (#19) native_token_meta used a short hand-written table. Chain 137 rendered as MATIC (now POL), and chains not in the table, such as Celo (42220) and Gnosis (100), rendered as ETH. Generate the table from chainid.network/chains_mini.json, the source that the Sourcify runner uses. * fix: render calldata fields on array paths as nested calls (#20) A calldata field with an array path (calls.[].data) went through format_value and rendered raw hex, and the resolver did not load the descriptors of the inner calls. Render each element with the nested calldata renderer in the calldata and EIP-712 flows, expand array data paths in the resolver, and scope all element-relative path params (calleePath, amountPath, spenderPath, selectorPath, chainIdPath, collectionPath) to the element, not only tokenPath. * Match an interpolation placeholder for one element of an array field (#22) * fix: match an interpolation placeholder for one element of an array field A placeholder such as {_swapData.[0].fromAmount} did not match the display field _swapData.[].fromAmount, so the whole interpolatedIntent was dropped. When no field matches exactly, match the array field and format the named element with its format and element-scoped params. * ci: update android-actions/setup-android to v4 (#24) Google no longer serves the legacy SDK package 'tools'. setup-android v3 installs 'tools platform-tools' by default, so sdkmanager fails with "Failed to find package 'tools'" and the Android job is red on every PR. v4 installs only 'platform-tools' (fix in v4.0.2). * fix: take native currency metadata from the EIP-155 chain list (#19) native_token_meta used a short hand-written table. Chain 137 rendered as MATIC (now POL), and chains not in the table, such as Celo (42220) and Gnosis (100), rendered as ETH. Generate the table from chainid.network/chains_mini.json, the source that the Sourcify runner uses. * fix: render calldata fields on array paths as nested calls (#20) A calldata field with an array path (calls.[].data) went through format_value and rendered raw hex, and the resolver did not load the descriptors of the inner calls. Render each element with the nested calldata renderer in the calldata and EIP-712 flows, expand array data paths in the resolver, and scope all element-relative path params (calleePath, amountPath, spenderPath, selectorPath, chainIdPath, collectionPath) to the element, not only tokenPath. --------- Co-authored-by: Bartosz Rozwarski * Accept definitions without a label and apply the $ref label override (#23) * fix: accept definitions without a label and apply the $ref label A display definition without label failed to parse ('data did not match any variant of untagged enum DisplayField'), so the whole descriptor was rejected. The schema does not require label, and a reference's label overrides the definition's. Make Simple.label default to empty, and add the optional label to Reference and apply it when the reference expands. * ci: update android-actions/setup-android to v4 (#24) Google no longer serves the legacy SDK package 'tools'. setup-android v3 installs 'tools platform-tools' by default, so sdkmanager fails with "Failed to find package 'tools'" and the Android job is red on every PR. v4 installs only 'platform-tools' (fix in v4.0.2). * fix: take native currency metadata from the EIP-155 chain list (#19) native_token_meta used a short hand-written table. Chain 137 rendered as MATIC (now POL), and chains not in the table, such as Celo (42220) and Gnosis (100), rendered as ETH. Generate the table from chainid.network/chains_mini.json, the source that the Sourcify runner uses. * fix: render calldata fields on array paths as nested calls (#20) A calldata field with an array path (calls.[].data) went through format_value and rendered raw hex, and the resolver did not load the descriptors of the inner calls. Render each element with the nested calldata renderer in the calldata and EIP-712 flows, expand array data paths in the resolver, and scope all element-relative path params (calleePath, amountPath, spenderPath, selectorPath, chainIdPath, collectionPath) to the element, not only tokenPath. * Match an interpolation placeholder for one element of an array field (#22) * fix: match an interpolation placeholder for one element of an array field A placeholder such as {_swapData.[0].fromAmount} did not match the display field _swapData.[].fromAmount, so the whole interpolatedIntent was dropped. When no field matches exactly, match the array field and format the named element with its format and element-scoped params. * ci: update android-actions/setup-android to v4 (#24) Google no longer serves the legacy SDK package 'tools'. setup-android v3 installs 'tools platform-tools' by default, so sdkmanager fails with "Failed to find package 'tools'" and the Android job is red on every PR. v4 installs only 'platform-tools' (fix in v4.0.2). * fix: take native currency metadata from the EIP-155 chain list (#19) native_token_meta used a short hand-written table. Chain 137 rendered as MATIC (now POL), and chains not in the table, such as Celo (42220) and Gnosis (100), rendered as ETH. Generate the table from chainid.network/chains_mini.json, the source that the Sourcify runner uses. * fix: render calldata fields on array paths as nested calls (#20) A calldata field with an array path (calls.[].data) went through format_value and rendered raw hex, and the resolver did not load the descriptors of the inner calls. Render each element with the nested calldata renderer in the calldata and EIP-712 flows, expand array data paths in the resolver, and scope all element-relative path params (calleePath, amountPath, spenderPath, selectorPath, chainIdPath, collectionPath) to the element, not only tokenPath. --------- Co-authored-by: Bartosz Rozwarski --------- Co-authored-by: Bartosz Rozwarski Co-authored-by: Claude Opus 5.5 * style: cargo fmt Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: Manuel Wedler Co-authored-by: Bartosz Rozwarski Co-authored-by: Claude Opus 5.5 --- crates/clear-signing/src/render_shared.rs | 31 ++--- crates/clear-signing/tests/spec_compliance.rs | 106 ++++++++++++++++++ 2 files changed, 124 insertions(+), 13 deletions(-) diff --git a/crates/clear-signing/src/render_shared.rs b/crates/clear-signing/src/render_shared.rs index 4df2997..69a7ab4 100644 --- a/crates/clear-signing/src/render_shared.rs +++ b/crates/clear-signing/src/render_shared.rs @@ -11,21 +11,25 @@ use crate::types::descriptor::Descriptor; use crate::types::display::{DisplayField, FieldFormat, FormatParams}; /// Known chain IDs -> human-readable names. +/// +/// The spec's `chainId` format converts the value "to a Blockchain name using +/// EIP-155 reference values", so these are the `name` fields from the EIP-155 +/// chain list at (e.g. 1 -> "Ethereum Mainnet"). pub(crate) fn chain_name(chain_id: u64) -> String { match chain_id { - 1 => "Ethereum".to_string(), - 10 => "Optimism".to_string(), - 56 => "BNB Chain".to_string(), + 1 => "Ethereum Mainnet".to_string(), + 10 => "OP Mainnet".to_string(), + 56 => "BNB Smart Chain Mainnet".to_string(), 100 => "Gnosis".to_string(), - 137 => "Polygon".to_string(), - 250 => "Fantom".to_string(), - 324 => "zkSync Era".to_string(), + 137 => "Polygon Mainnet".to_string(), + 250 => "Fantom Opera".to_string(), + 324 => "zkSync Mainnet".to_string(), 8453 => "Base".to_string(), 42161 => "Arbitrum One".to_string(), 42170 => "Arbitrum Nova".to_string(), - 43114 => "Avalanche".to_string(), - 14 => "Flare".to_string(), - 19 => "Songbird".to_string(), + 43114 => "Avalanche C-Chain".to_string(), + 14 => "Flare Mainnet".to_string(), + 19 => "Songbird Canary-Network".to_string(), 59144 => "Linea".to_string(), 534352 => "Scroll".to_string(), 7777777 => "Zora".to_string(), @@ -497,10 +501,11 @@ mod tests { #[test] fn test_chain_name() { - assert_eq!(chain_name(1), "Ethereum"); - assert_eq!(chain_name(137), "Polygon"); - assert_eq!(chain_name(14), "Flare"); - assert_eq!(chain_name(19), "Songbird"); + assert_eq!(chain_name(1), "Ethereum Mainnet"); + assert_eq!(chain_name(137), "Polygon Mainnet"); + assert_eq!(chain_name(42161), "Arbitrum One"); + assert_eq!(chain_name(14), "Flare Mainnet"); + assert_eq!(chain_name(19), "Songbird Canary-Network"); assert_eq!(chain_name(99999), "Chain 99999"); } diff --git a/crates/clear-signing/tests/spec_compliance.rs b/crates/clear-signing/tests/spec_compliance.rs index c084298..43e9d4c 100644 --- a/crates/clear-signing/tests/spec_compliance.rs +++ b/crates/clear-signing/tests/spec_compliance.rs @@ -7346,3 +7346,109 @@ async fn test_reference_label_overrides_definition_label_calldata_eip712_parity( ); assert_semantic_parity(&calldata_model, &typed_model); } + +// ─── chainId format uses EIP-155 reference names ─── + +/// The `chainId` format converts the value "to a Blockchain name using EIP-155 +/// reference values" (spec example: 1 -> "Ethereum Mainnet"). Those are the +/// chainid.network `name` fields, so 137 is "Polygon Mainnet", not "Polygon". +/// Calldata and EIP-712 must agree. +#[tokio::test] +async fn test_chain_id_format_uses_eip155_reference_names_calldata_eip712_parity() { + let fields = serde_json::json!([ + { "path": "sourceChain", "label": "Source Chain", "format": "chainId" }, + { "path": "destChain", "label": "Destination Chain", "format": "chainId" }, + { "path": "otherChain", "label": "Other Chain", "format": "chainId" } + ]); + + let calldata_descriptor = Descriptor::from_json( + &serde_json::json!({ + "context": { "contract": { "deployments": [{"chainId": 1, "address": "0xabc"}] } }, + "metadata": { "owner": "test", "enums": {}, "constants": {}, "maps": {} }, + "display": { + "definitions": {}, + "formats": { + "bridge(uint256 sourceChain,uint256 destChain,uint256 otherChain)": { + "intent": "Bridge", + "fields": fields.clone() + } + } + } + }) + .to_string(), + ) + .unwrap(); + + let typed_descriptor = Descriptor::from_json( + &serde_json::json!({ + "context": { "eip712": { "deployments": [{"chainId": 1, "address": "0xabc"}] } }, + "metadata": { "owner": "test", "enums": {}, "constants": {}, "maps": {} }, + "display": { + "definitions": {}, + "formats": { + "Bridge(uint256 sourceChain,uint256 destChain,uint256 otherChain)": { + "intent": "Bridge", + "fields": fields + } + } + } + }) + .to_string(), + ) + .unwrap(); + + let calldata = build_calldata( + "bridge(uint256 sourceChain,uint256 destChain,uint256 otherChain)", + &[uint_word(1), uint_word(137), uint_word(42161)], + ); + let tx = TransactionContext { + chain_id: 1, + to: "0xabc", + calldata: &calldata, + value: None, + from: None, + implementation_address: None, + }; + let calldata_result = format_calldata( + &wrap_rd(calldata_descriptor, 1, "0xabc"), + &tx, + &EmptyDataProvider, + ) + .await + .unwrap(); + + let typed_data: TypedData = serde_json::from_value(serde_json::json!({ + "types": { + "EIP712Domain": [], + "Bridge": [ + { "name": "sourceChain", "type": "uint256" }, + { "name": "destChain", "type": "uint256" }, + { "name": "otherChain", "type": "uint256" } + ] + }, + "primaryType": "Bridge", + "domain": { "chainId": 1, "verifyingContract": "0xabc" }, + "message": { "sourceChain": 1, "destChain": 137, "otherChain": 42161 } + })) + .unwrap(); + let typed_result = format_typed_data( + &wrap_rd(typed_descriptor, 1, "0xabc"), + &typed_data, + &EmptyDataProvider, + ) + .await + .unwrap(); + + assert_eq!( + semantic_item_snapshot(&calldata_result.entries), + vec![ + ("Source Chain".to_string(), "Ethereum Mainnet".to_string()), + ( + "Destination Chain".to_string(), + "Polygon Mainnet".to_string() + ), + ("Other Chain".to_string(), "Arbitrum One".to_string()), + ] + ); + assert_semantic_parity(&calldata_result, &typed_result); +}