@luxfi/exchange 0.1.0

package/dist/chains/lux.d.ts

@@ -0,0 +1,508 @@
+/**
+ * Lux Mainnet Chain Definition
+ */
+export declare const luxMainnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Lux Explorer";
+            readonly url: "https://explore.lux.network";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F";
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 96369;
+    name: "Lux Mainnet";
+    nativeCurrency: {
+        readonly name: "LUX";
+        readonly symbol: "LUX";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.lux.network/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://api.lux.network/rpc"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};
+/**
+ * Lux Testnet Chain Definition
+ */
+export declare const luxTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Lux Testnet Explorer";
+            readonly url: "https://explore.lux-test.network";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F";
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 96368;
+    name: "Lux Testnet";
+    nativeCurrency: {
+        readonly name: "LUX";
+        readonly symbol: "LUX";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.lux-test.network/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://api.lux-test.network/rpc"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};
+/**
+ * Zoo Mainnet Chain Definition
+ */
+export declare const zooMainnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Zoo Explorer";
+            readonly url: "https://explore.zoo.network";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 200200;
+    name: "Zoo Network";
+    nativeCurrency: {
+        readonly name: "ZOO";
+        readonly symbol: "ZOO";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.zoo.network/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://api.zoo.network/rpc"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};
+/**
+ * Zoo Testnet Chain Definition
+ */
+export declare const zooTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Zoo Testnet Explorer";
+            readonly url: "https://explore.zoo-test.network";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 200201;
+    name: "Zoo Testnet";
+    nativeCurrency: {
+        readonly name: "ZOO";
+        readonly symbol: "ZOO";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.zoo-test.network/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://api.zoo-test.network/rpc"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};
+/**
+ * Dev Chain Definition (for running local node with --dev)
+ */
+export declare const luxDev: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Dev";
+            readonly url: "http://localhost:8545";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 1337;
+    name: "Lux Dev";
+    nativeCurrency: {
+        readonly name: "LUX";
+        readonly symbol: "LUX";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["http://localhost:8545/ext/bc/C/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["http://localhost:8545/ext/bc/C/rpc"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};
+/**
+ * Chain IDs
+ */
+export declare const LUX_MAINNET_ID = 96369;
+export declare const LUX_TESTNET_ID = 96368;
+export declare const ZOO_MAINNET_ID = 200200;
+export declare const ZOO_TESTNET_ID = 200201;
+export declare const LUX_DEV_ID = 1337;
+/**
+ * All supported chains
+ */
+export declare const supportedChains: readonly [{
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Lux Explorer";
+            readonly url: "https://explore.lux.network";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F";
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 96369;
+    name: "Lux Mainnet";
+    nativeCurrency: {
+        readonly name: "LUX";
+        readonly symbol: "LUX";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.lux.network/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://api.lux.network/rpc"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Lux Testnet Explorer";
+            readonly url: "https://explore.lux-test.network";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F";
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 96368;
+    name: "Lux Testnet";
+    nativeCurrency: {
+        readonly name: "LUX";
+        readonly symbol: "LUX";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.lux-test.network/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://api.lux-test.network/rpc"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Zoo Explorer";
+            readonly url: "https://explore.zoo.network";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 200200;
+    name: "Zoo Network";
+    nativeCurrency: {
+        readonly name: "ZOO";
+        readonly symbol: "ZOO";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.zoo.network/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://api.zoo.network/rpc"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Zoo Testnet Explorer";
+            readonly url: "https://explore.zoo-test.network";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 200201;
+    name: "Zoo Testnet";
+    nativeCurrency: {
+        readonly name: "ZOO";
+        readonly symbol: "ZOO";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.zoo-test.network/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["https://api.zoo-test.network/rpc"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Dev";
+            readonly url: "http://localhost:8545";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 1337;
+    name: "Lux Dev";
+    nativeCurrency: {
+        readonly name: "LUX";
+        readonly symbol: "LUX";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["http://localhost:8545/ext/bc/C/rpc"];
+        };
+        readonly public: {
+            readonly http: readonly ["http://localhost:8545/ext/bc/C/rpc"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+}];
+export type SupportedChainId = typeof supportedChains[number]['id'];
+//# sourceMappingURL=lux.d.ts.map

package/dist/chains/lux.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lux.d.ts","sourceRoot":"","sources":["../../src/chains/lux.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBrB,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqBrB,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAerB,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBrB,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBjB,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,QAAQ,CAAA;AACnC,eAAO,MAAM,cAAc,QAAQ,CAAA;AACnC,eAAO,MAAM,cAAc,SAAS,CAAA;AACpC,eAAO,MAAM,cAAc,SAAS,CAAA;AACpC,eAAO,MAAM,UAAU,OAAO,CAAA;AAE9B;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMlB,CAAA;AAEV,MAAM,MAAM,gBAAgB,GAAG,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAA"}

package/dist/chains/lux.js

@@ -0,0 +1,131 @@
+/**
+ * Lux Chain Definitions
+ * Native chain definitions for Lux Exchange
+ */
+import { defineChain } from 'viem';
+/**
+ * Lux Mainnet Chain Definition
+ */
+export const luxMainnet = defineChain({
+    id: 96369,
+    name: 'Lux Mainnet',
+    nativeCurrency: {
+        name: 'LUX',
+        symbol: 'LUX',
+        decimals: 18,
+    },
+    rpcUrls: {
+        default: { http: ['https://api.lux.network/rpc'] },
+        public: { http: ['https://api.lux.network/rpc'] },
+    },
+    blockExplorers: {
+        default: { name: 'Lux Explorer', url: 'https://explore.lux.network' },
+    },
+    contracts: {
+        multicall3: {
+            address: '0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F',
+        },
+    },
+});
+/**
+ * Lux Testnet Chain Definition
+ */
+export const luxTestnet = defineChain({
+    id: 96368,
+    name: 'Lux Testnet',
+    nativeCurrency: {
+        name: 'LUX',
+        symbol: 'LUX',
+        decimals: 18,
+    },
+    rpcUrls: {
+        default: { http: ['https://api.lux-test.network/rpc'] },
+        public: { http: ['https://api.lux-test.network/rpc'] },
+    },
+    blockExplorers: {
+        default: { name: 'Lux Testnet Explorer', url: 'https://explore.lux-test.network' },
+    },
+    contracts: {
+        multicall3: {
+            address: '0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F',
+        },
+    },
+    testnet: true,
+});
+/**
+ * Zoo Mainnet Chain Definition
+ */
+export const zooMainnet = defineChain({
+    id: 200200,
+    name: 'Zoo Network',
+    nativeCurrency: {
+        name: 'ZOO',
+        symbol: 'ZOO',
+        decimals: 18,
+    },
+    rpcUrls: {
+        default: { http: ['https://api.zoo.network/rpc'] },
+        public: { http: ['https://api.zoo.network/rpc'] },
+    },
+    blockExplorers: {
+        default: { name: 'Zoo Explorer', url: 'https://explore.zoo.network' },
+    },
+});
+/**
+ * Zoo Testnet Chain Definition
+ */
+export const zooTestnet = defineChain({
+    id: 200201,
+    name: 'Zoo Testnet',
+    nativeCurrency: {
+        name: 'ZOO',
+        symbol: 'ZOO',
+        decimals: 18,
+    },
+    rpcUrls: {
+        default: { http: ['https://api.zoo-test.network/rpc'] },
+        public: { http: ['https://api.zoo-test.network/rpc'] },
+    },
+    blockExplorers: {
+        default: { name: 'Zoo Testnet Explorer', url: 'https://explore.zoo-test.network' },
+    },
+    testnet: true,
+});
+/**
+ * Dev Chain Definition (for running local node with --dev)
+ */
+export const luxDev = defineChain({
+    id: 1337,
+    name: 'Lux Dev',
+    nativeCurrency: {
+        name: 'LUX',
+        symbol: 'LUX',
+        decimals: 18,
+    },
+    rpcUrls: {
+        default: { http: ['http://localhost:8545/ext/bc/C/rpc'] },
+        public: { http: ['http://localhost:8545/ext/bc/C/rpc'] },
+    },
+    blockExplorers: {
+        default: { name: 'Dev', url: 'http://localhost:8545' },
+    },
+    testnet: false,
+});
+/**
+ * Chain IDs
+ */
+export const LUX_MAINNET_ID = 96369;
+export const LUX_TESTNET_ID = 96368;
+export const ZOO_MAINNET_ID = 200200;
+export const ZOO_TESTNET_ID = 200201;
+export const LUX_DEV_ID = 1337;
+/**
+ * All supported chains
+ */
+export const supportedChains = [
+    luxMainnet,
+    luxTestnet,
+    zooMainnet,
+    zooTestnet,
+    luxDev,
+];