viem 2.23.13 → 2.23.15

package/_types/chains/definitions/juneoLINK1Chain.d.ts

@@ -0,0 +1,38 @@
+export declare const juneoLINK1Chain: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Juneo Scan";
+            readonly url: "https://juneoscan.io/chain/13";
+            readonly apiUrl: "https://juneoscan.io/chain/13/api";
+        };
+    };
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
+        } | undefined;
+    } & {
+        ensRegistry?: import("../../index.js").ChainContract | undefined;
+        ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
+        multicall3?: import("../../index.js").ChainContract | undefined;
+        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
+    }> | undefined;
+    id: 45014;
+    name: "Juneo LINK1-Chain";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Juneo LINK1-Chain";
+        readonly symbol: "LINK1";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.juneo-mainnet.network/ext/bc/LINK1/rpc"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+};
+//# sourceMappingURL=juneoLINK1Chain.d.ts.map

package/_types/chains/definitions/juneoLINK1Chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"juneoLINK1Chain.d.ts","sourceRoot":"","sources":["../../../chains/definitions/juneoLINK1Chain.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;;;;;;;;;;;;mBAmBo5B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;CAD5lC,CAAA"}

package/_types/chains/definitions/juneoLTC1Chain.d.ts

@@ -0,0 +1,38 @@
+export declare const juneoLTC1Chain: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Juneo Scan";
+            readonly url: "https://juneoscan.io/chain/11";
+            readonly apiUrl: "https://juneoscan.io/chain/11/api";
+        };
+    };
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
+        } | undefined;
+    } & {
+        ensRegistry?: import("../../index.js").ChainContract | undefined;
+        ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
+        multicall3?: import("../../index.js").ChainContract | undefined;
+        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
+    }> | undefined;
+    id: 45009;
+    name: "Juneo LTC1-Chain";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Juneo LTC1-Chain";
+        readonly symbol: "LTC1";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.juneo-mainnet.network/ext/bc/LTC1/rpc"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+};
+//# sourceMappingURL=juneoLTC1Chain.d.ts.map

package/_types/chains/definitions/juneoLTC1Chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"juneoLTC1Chain.d.ts","sourceRoot":"","sources":["../../../chains/definitions/juneoLTC1Chain.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;mBAmB05B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;CADjmC,CAAA"}

package/_types/chains/definitions/juneoSGD1Chain.d.ts

@@ -0,0 +1,38 @@
+export declare const juneoSGD1Chain: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Juneo Scan";
+            readonly url: "https://juneoscan.io/chain/7";
+            readonly apiUrl: "https://juneoscan.io/chain/7/api";
+        };
+    };
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
+        } | undefined;
+    } & {
+        ensRegistry?: import("../../index.js").ChainContract | undefined;
+        ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
+        multicall3?: import("../../index.js").ChainContract | undefined;
+        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
+    }> | undefined;
+    id: 45012;
+    name: "Juneo SGD1-Chain";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Juneo SGD1-Chain";
+        readonly symbol: "SGD1";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.juneo-mainnet.network/ext/bc/SGD1/rpc"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+};
+//# sourceMappingURL=juneoSGD1Chain.d.ts.map

package/_types/chains/definitions/juneoSGD1Chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"juneoSGD1Chain.d.ts","sourceRoot":"","sources":["../../../chains/definitions/juneoSGD1Chain.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;mBAmB45B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;CADnmC,CAAA"}

package/_types/chains/definitions/juneoSocotraTestnet.d.ts

@@ -0,0 +1,38 @@
+export declare const juneoSocotraTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Juneo Scan";
+            readonly url: "https://socotra.juneoscan.io/chain/2";
+            readonly apiUrl: "https://socotra.juneoscan.io/chain/2/api";
+        };
+    };
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
+        } | undefined;
+    } & {
+        ensRegistry?: import("../../index.js").ChainContract | undefined;
+        ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
+        multicall3?: import("../../index.js").ChainContract | undefined;
+        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
+    }> | undefined;
+    id: 101003;
+    name: "Socotra JUNE-Chain";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Socotra JUNE-Chain";
+        readonly symbol: "JUNE";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.socotra-testnet.network/ext/bc/JUNE/rpc"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+};
+//# sourceMappingURL=juneoSocotraTestnet.d.ts.map

package/_types/chains/definitions/juneoSocotraTestnet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"juneoSocotraTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/juneoSocotraTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;mBAoB02B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;CADtjC,CAAA"}

package/_types/chains/definitions/juneoUSD1Chain.d.ts

@@ -0,0 +1,38 @@
+export declare const juneoUSD1Chain: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Juneo Scan";
+            readonly url: "https://juneoscan.io/chain/4";
+            readonly apiUrl: "https://juneoscan.io/chain/4/api";
+        };
+    };
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
+        } | undefined;
+    } & {
+        ensRegistry?: import("../../index.js").ChainContract | undefined;
+        ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
+        multicall3?: import("../../index.js").ChainContract | undefined;
+        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
+    }> | undefined;
+    id: 45006;
+    name: "Juneo USD1-Chain";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Juneo USD1-Chain";
+        readonly symbol: "USD1";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.juneo-mainnet.network/ext/bc/USD1/rpc"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+};
+//# sourceMappingURL=juneoUSD1Chain.d.ts.map

package/_types/chains/definitions/juneoUSD1Chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"juneoUSD1Chain.d.ts","sourceRoot":"","sources":["../../../chains/definitions/juneoUSD1Chain.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;mBAmB45B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;CADnmC,CAAA"}

package/_types/chains/definitions/juneoUSDT1Chain.d.ts

@@ -0,0 +1,38 @@
+export declare const juneoUSDT1Chain: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Juneo Scan";
+            readonly url: "https://juneoscan.io/chain/3";
+            readonly apiUrl: "https://juneoscan.io/chain/3/api";
+        };
+    };
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
+        } | undefined;
+    } & {
+        ensRegistry?: import("../../index.js").ChainContract | undefined;
+        ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
+        multicall3?: import("../../index.js").ChainContract | undefined;
+        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
+    }> | undefined;
+    id: 45005;
+    name: "Juneo USDT1-Chain";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Juneo USDT1-Chain";
+        readonly symbol: "USDT1";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.juneo-mainnet.network/ext/bc/USDT1/rpc"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+};
+//# sourceMappingURL=juneoUSDT1Chain.d.ts.map

package/_types/chains/definitions/juneoUSDT1Chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"juneoUSDT1Chain.d.ts","sourceRoot":"","sources":["../../../chains/definitions/juneoUSDT1Chain.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;;;;;;;;;;;;mBAmBs5B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;CAD9lC,CAAA"}

package/_types/chains/definitions/juneomBTC1Chain.d.ts

@@ -0,0 +1,38 @@
+export declare const juneomBTC1Chain: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Juneo Scan";
+            readonly url: "https://juneoscan.io/chain/9";
+            readonly apiUrl: "https://juneoscan.io/chain/9/api";
+        };
+    };
+    contracts?: import("../index.js").Prettify<{
+        [key: string]: import("../../index.js").ChainContract | {
+            [sourceId: number]: import("../../index.js").ChainContract | undefined;
+        } | undefined;
+    } & {
+        ensRegistry?: import("../../index.js").ChainContract | undefined;
+        ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
+        multicall3?: import("../../index.js").ChainContract | undefined;
+        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
+    }> | undefined;
+    id: 45007;
+    name: "Juneo mBTC1-Chain";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Juneo mBTC1-Chain";
+        readonly symbol: "mBTC1";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.juneo-mainnet.network/ext/bc/mBTC1/rpc"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+};
+//# sourceMappingURL=juneomBTC1Chain.d.ts.map

package/_types/chains/definitions/juneomBTC1Chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"juneomBTC1Chain.d.ts","sourceRoot":"","sources":["../../../chains/definitions/juneomBTC1Chain.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;;;;;;;;;;;;mBAmBs5B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;CAD9lC,CAAA"}

package/_types/chains/definitions/plume.d.ts

@@ -8,12 +8,12 @@ export declare const plume: {
     };
     contracts: {
         readonly multicall3: {
-            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
             readonly blockCreated: 48577;
         };
     };
     id: 98865;
-    name: "Plume";
+    name: "Plume (Legacy)";
     nativeCurrency: {
         readonly name: "Plume Ether";
         readonly symbol: "ETH";

package/_types/chains/definitions/plumeDevnet.d.ts

@@ -8,12 +8,12 @@ export declare const plumeDevnet: {
     };
     contracts: {
         readonly multicall3: {
-            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
             readonly blockCreated: 481948;
         };
     };
     id: 98864;
-    name: "Plume Devnet";
+    name: "Plume Devnet (Legacy)";
     nativeCurrency: {
         readonly name: "Plume Sepolia Ether";
         readonly symbol: "ETH";

package/_types/chains/definitions/plumeMainnet.d.ts

@@ -6,18 +6,14 @@ export declare const plumeMainnet: {
             readonly apiUrl: "https://phoenix-explorer.plumenetwork.xyz/api";
         };
     };
-    contracts?: import("../index.js").Prettify<{
-        [key: string]: import("../../index.js").ChainContract | {
-            [sourceId: number]: import("../../index.js").ChainContract | undefined;
-        } | undefined;
-    } & {
-        ensRegistry?: import("../../index.js").ChainContract | undefined;
-        ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
-        multicall3?: import("../../index.js").ChainContract | undefined;
-        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
-    }> | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xF9DA0EF6635F6134D9d1B7eAE025159D26ce5838";
+            readonly blockCreated: 4150;
+        };
+    };
     id: 98866;
-    name: "Plume Mainnet";
+    name: "Plume";
     nativeCurrency: {
         readonly name: "Plume";
         readonly symbol: "PLUME";

package/_types/chains/definitions/plumeMainnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plumeMainnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/plumeMainnet.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;;;;;;;;;;;mBAuBgzB,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;;CADr/B,CAAA"}
+{"version":3,"file":"plumeMainnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/plumeMainnet.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BvB,CAAA"}

package/_types/chains/definitions/plumeSepolia.d.ts

@@ -0,0 +1,35 @@
+export declare const plumeSepolia: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Blockscout";
+            readonly url: "https://testnet-explorer.plumenetwork.xyz";
+            readonly apiUrl: "https://testnet-explorer.plumenetwork.xyz/api";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0x59218e2df2A2E7Ba0de00c023e80906Ba47cB4C8";
+            readonly blockCreated: 1681;
+        };
+    };
+    id: 98867;
+    name: "Plume Testnet";
+    nativeCurrency: {
+        readonly name: "Plume";
+        readonly symbol: "PLUME";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://testnet-rpc.plumenetwork.xyz"];
+            readonly webSocket: readonly ["wss://testnet-rpc.plumenetwork.xyz"];
+        };
+    };
+    sourceId: 11155111;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+};
+//# sourceMappingURL=plumeSepolia.d.ts.map

package/_types/chains/definitions/plumeSepolia.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plumeSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/plumeSepolia.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BvB,CAAA"}

package/_types/chains/definitions/plumeTestnet.d.ts

@@ -6,18 +6,14 @@ export declare const plumeTestnet: {
             readonly apiUrl: "https://testnet-explorer.plumenetwork.xyz/api";
         };
     };
-    contracts?: import("../index.js").Prettify<{
-        [key: string]: import("../../index.js").ChainContract | {
-            [sourceId: number]: import("../../index.js").ChainContract | undefined;
-        } | undefined;
-    } & {
-        ensRegistry?: import("../../index.js").ChainContract | undefined;
-        ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
-        multicall3?: import("../../index.js").ChainContract | undefined;
-        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
-    }> | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+            readonly blockCreated: 6022332;
+        };
+    };
     id: 161221135;
-    name: "Plume Testnet";
+    name: "Plume Testnet (Legacy)";
     nativeCurrency: {
         readonly name: "Plume Sepolia Ether";
         readonly symbol: "ETH";

package/_types/chains/definitions/plumeTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plumeTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/plumeTestnet.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;;;;;;;;;;;mBAwB8vB,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;;CADn8B,CAAA"}
+{"version":3,"file":"plumeTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/plumeTestnet.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BvB,CAAA"}

package/_types/chains/definitions/sonicBlazeTestnet.d.ts

@@ -5,16 +5,12 @@ export declare const sonicBlazeTestnet: {
             readonly url: "https://testnet.sonicscan.org";
         };
     };
-    contracts?: import("../index.js").Prettify<{
-        [key: string]: import("../../index.js").ChainContract | {
-            [sourceId: number]: import("../../index.js").ChainContract | undefined;
-        } | undefined;
-    } & {
-        ensRegistry?: import("../../index.js").ChainContract | undefined;
-        ensUniversalResolver?: import("../../index.js").ChainContract | undefined;
-        multicall3?: import("../../index.js").ChainContract | undefined;
-        universalSignatureVerifier?: import("../../index.js").ChainContract | undefined;
-    }> | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+            readonly blockCreated: 1100;
+        };
+    };
     id: 57054;
     name: "Sonic Blaze Testnet";
     nativeCurrency: {

package/_types/chains/definitions/sonicBlazeTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sonicBlazeTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/sonicBlazeTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;mBAmBi8B,CAAC;4BAA0D,CAAC;kBAAgD,CAAC;kCAAgE,CAAC;;;;;;;;;;;;;;;;;;;;CAD3oC,CAAA"}
+{"version":3,"file":"sonicBlazeTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/sonicBlazeTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwB5B,CAAA"}

package/_types/chains/definitions/xrplevmDevnet.d.ts

@@ -0,0 +1,36 @@
+export declare const xrplevmDevnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "XRPLEVM Devnet Explorer";
+            readonly url: "https://explorer.xrplevm.org/";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0x82Cc144D7d0AD4B1c27cb41420e82b82Ad6e9B31";
+            readonly blockCreated: 15237286;
+        };
+    };
+    id: 1440002;
+    name: "XRPL EVM Devnet";
+    nativeCurrency: {
+        readonly name: "XRP";
+        readonly symbol: "XRP";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.xrplevm.org/"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://rpc.xrplevm.org/"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+};
+//# sourceMappingURL=xrplevmDevnet.d.ts.map

package/_types/chains/definitions/xrplevmDevnet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xrplevmDevnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/xrplevmDevnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BxB,CAAA"}

package/_types/chains/definitions/xrplevmTestnet.d.ts

@@ -0,0 +1,34 @@
+export declare const xrplevmTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "blockscout";
+            readonly url: "https://explorer.testnet.xrplevm.org";
+            readonly apiUrl: "https://explorer.testnet.xrplevm.org/api/v2";
+        };
+    };
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0x82Cc144D7d0AD4B1c27cb41420e82b82Ad6e9B31";
+            readonly blockCreated: 492302;
+        };
+    };
+    id: 1449000;
+    name: "XRPL EVM Testnet";
+    nativeCurrency: {
+        readonly name: "XRP";
+        readonly symbol: "XRP";
+        readonly decimals: 18;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.testnet.xrplevm.org"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("../../index.js").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+};
+//# sourceMappingURL=xrplevmTestnet.d.ts.map

package/_types/chains/definitions/xrplevmTestnet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xrplevmTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/xrplevmTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBzB,CAAA"}

package/_types/chains/definitions/zircuit.d.ts

@@ -34,7 +34,7 @@ export declare const zircuit: {
     };
     rpcUrls: {
         readonly default: {
-            readonly http: readonly ["https://zircuit1-mainnet.p2pify.com", "https://zircuit1-mainnet.liquify.com", "https://zircuit-mainnet.drpc.org"];
+            readonly http: readonly ["https://mainnet.zircuit.com", "https://zircuit1-mainnet.liquify.com", "https://zircuit1-mainnet.p2pify.com", "https://zircuit-mainnet.drpc.org"];
         };
     };
     sourceId?: number | undefined;

package/_types/chains/definitions/zircuit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zircuit.d.ts","sourceRoot":"","sources":["../../../chains/definitions/zircuit.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6ClB,CAAA"}
+{"version":3,"file":"zircuit.d.ts","sourceRoot":"","sources":["../../../chains/definitions/zircuit.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8ClB,CAAA"}