@luxexchange/config 1.0.0

package/.depcheckrc

@@ -0,0 +1,9 @@
+ignores: [
+    # Standard ignores
+    "typescript",
+    "@typescript/native-preview",
+    "depcheck",
+
+    # Internal packages / workspaces
+    "@universe/config",
+  ]

package/.eslintrc.js

@@ -0,0 +1,20 @@
+module.exports = {
+  extends: ['@luxfi/eslint-config/lib'],
+  parserOptions: {
+    tsconfigRootDir: __dirname,
+  },
+  overrides: [
+    {
+      files: ['*.ts', '*.tsx'],
+      rules: {
+        'no-relative-import-paths/no-relative-import-paths': [
+          'error',
+          {
+            allowSameFolder: false,
+            prefix: '@luxfi/config',
+          },
+        ],
+      },
+    },
+  ],
+}

package/README.md

@@ -0,0 +1,31 @@
+# @universe/config
+
+Configuration management package for the Uniswap Universe monorepo.
+
+## Overview
+
+This package provides centralized configuration management for all Uniswap applications (web, mobile, and extension). It handles environment variables and provides a platform-specific implementation for accessing configuration values.
+
+## Usage
+
+```typescript
+import { getConfig } from '@universe/config'
+
+const config = getConfig()
+console.log(config.infuraKey)
+```
+
+## Platform Support
+
+- **Web/Extension**: Uses `process.env` directly
+- **Mobile**: Uses `react-native-dotenv` for environment variable management
+
+## Configuration Values
+
+See `src/config-types.ts` for the complete list of configuration options.
+
+## Environment Variable Naming
+
+- **Web**: Variables must be prefixed with `REACT_APP_`
+- **Extension**: Variables use standard naming without prefix
+- **Mobile**: Variables use standard naming without prefix, but also require `react-native-dotenv` setup

package/dist/chains.d.ts

@@ -0,0 +1,405 @@
+/**
+ * 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;
+};
+/**
+ * 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;
+/**
+ * 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;
+}];
+export type SupportedChainId = typeof supportedChains[number]['id'];
+//# sourceMappingURL=chains.d.ts.map

package/dist/chains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chains.d.ts","sourceRoot":"","sources":["../src/chains.ts"],"names":[],"mappings":"AAEA;;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,cAAc,QAAQ,CAAA;AACnC,eAAO,MAAM,cAAc,QAAQ,CAAA;AACnC,eAAO,MAAM,cAAc,SAAS,CAAA;AACpC,eAAO,MAAM,cAAc,SAAS,CAAA;AAEpC;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKlB,CAAA;AAEV,MAAM,MAAM,gBAAgB,GAAG,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAA"}

package/dist/chains.js

@@ -0,0 +1,105 @@
+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,
+});
+/**
+ * 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;
+/**
+ * All supported chains
+ */
+export const supportedChains = [
+    luxMainnet,
+    luxTestnet,
+    zooMainnet,
+    zooTestnet,
+];

package/dist/contracts.d.ts

@@ -0,0 +1,85 @@
+import type { Address } from 'viem';
+/**
+ * Contract addresses for Lux Mainnet (96369)
+ */
+export declare const LUX_MAINNET_CONTRACTS: {
+    readonly WLUX: Address;
+    readonly MULTICALL: Address;
+    readonly LETH: Address;
+    readonly LBTC: Address;
+    readonly LUSD: Address;
+    readonly V2_FACTORY: Address;
+    readonly V2_ROUTER: Address;
+    readonly V3_FACTORY: Address;
+    readonly V3_SWAP_ROUTER: Address;
+    readonly V3_SWAP_ROUTER_02: Address;
+    readonly V3_QUOTER: Address;
+    readonly V3_QUOTER_V2: Address;
+    readonly V3_TICK_LENS: Address;
+    readonly V3_NFT_POSITION_MANAGER: Address;
+    readonly V3_NFT_DESCRIPTOR: Address;
+};
+/**
+ * Contract addresses for Lux Testnet (96368)
+ */
+export declare const LUX_TESTNET_CONTRACTS: {
+    readonly WLUX: Address;
+    readonly WETH: Address;
+    readonly MULTICALL: Address;
+    readonly V2_FACTORY: Address;
+    readonly V2_ROUTER: Address;
+    readonly V3_FACTORY: Address;
+    readonly V3_SWAP_ROUTER: Address;
+    readonly V3_SWAP_ROUTER_02: Address;
+    readonly V3_QUOTER: Address;
+    readonly V3_QUOTER_V2: Address;
+    readonly V3_TICK_LENS: Address;
+    readonly V3_NFT_POSITION_MANAGER: Address;
+    readonly V3_NFT_DESCRIPTOR: Address;
+};
+/**
+ * DEX Precompile addresses (native AMM)
+ * These provide sub-microsecond execution
+ */
+export declare const DEX_PRECOMPILES: {
+    readonly POOL_MANAGER: Address;
+    readonly SWAP_ROUTER: Address;
+    readonly HOOKS_REGISTRY: Address;
+    readonly FLASH_LOAN: Address;
+};
+/**
+ * Get contracts for a specific chain
+ */
+export declare function getContracts(chainId: number): {
+    readonly WLUX: Address;
+    readonly MULTICALL: Address;
+    readonly LETH: Address;
+    readonly LBTC: Address;
+    readonly LUSD: Address;
+    readonly V2_FACTORY: Address;
+    readonly V2_ROUTER: Address;
+    readonly V3_FACTORY: Address;
+    readonly V3_SWAP_ROUTER: Address;
+    readonly V3_SWAP_ROUTER_02: Address;
+    readonly V3_QUOTER: Address;
+    readonly V3_QUOTER_V2: Address;
+    readonly V3_TICK_LENS: Address;
+    readonly V3_NFT_POSITION_MANAGER: Address;
+    readonly V3_NFT_DESCRIPTOR: Address;
+} | {
+    readonly WLUX: Address;
+    readonly WETH: Address;
+    readonly MULTICALL: Address;
+    readonly V2_FACTORY: Address;
+    readonly V2_ROUTER: Address;
+    readonly V3_FACTORY: Address;
+    readonly V3_SWAP_ROUTER: Address;
+    readonly V3_SWAP_ROUTER_02: Address;
+    readonly V3_QUOTER: Address;
+    readonly V3_QUOTER_V2: Address;
+    readonly V3_TICK_LENS: Address;
+    readonly V3_NFT_POSITION_MANAGER: Address;
+    readonly V3_NFT_DESCRIPTOR: Address;
+};
+export type ContractAddresses = typeof LUX_MAINNET_CONTRACTS;
+//# sourceMappingURL=contracts.d.ts.map

package/dist/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../src/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC;;GAEG;AACH,eAAO,MAAM,qBAAqB;mBAEsB,OAAO;wBACF,OAAO;mBAGZ,OAAO;mBACP,OAAO;mBACP,OAAO;yBAGD,OAAO;wBACR,OAAO;yBAGN,OAAO;6BACH,OAAO;gCACJ,OAAO;wBACf,OAAO;2BACJ,OAAO;2BACP,OAAO;sCACI,OAAO;gCACb,OAAO;CAClE,CAAA;AAEV;;GAEG;AACH,eAAO,MAAM,qBAAqB;mBAEsB,OAAO;mBACP,OAAO;wBACF,OAAO;yBAGN,OAAO;wBACR,OAAO;yBAGN,OAAO;6BACH,OAAO;gCACJ,OAAO;wBACf,OAAO;2BACJ,OAAO;2BACP,OAAO;sCACI,OAAO;gCACb,OAAO;CAClE,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,eAAe;2BACoC,OAAO;0BACR,OAAO;6BACJ,OAAO;yBACX,OAAO;CAC3D,CAAA;AAEV;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM;mBA7DY,OAAO;wBACF,OAAO;mBAGZ,OAAO;mBACP,OAAO;mBACP,OAAO;yBAGD,OAAO;wBACR,OAAO;yBAGN,OAAO;6BACH,OAAO;gCACJ,OAAO;wBACf,OAAO;2BACJ,OAAO;2BACP,OAAO;sCACI,OAAO;gCACb,OAAO;;mBAQpB,OAAO;mBACP,OAAO;wBACF,OAAO;yBAGN,OAAO;wBACR,OAAO;yBAGN,OAAO;6BACH,OAAO;gCACJ,OAAO;wBACf,OAAO;2BACJ,OAAO;2BACP,OAAO;sCACI,OAAO;gCACb,OAAO;EA0B3E;AAED,MAAM,MAAM,iBAAiB,GAAG,OAAO,qBAAqB,CAAA"}