@luxexchange/config 1.0.0

package/dist/contracts.js

@@ -0,0 +1,68 @@
+/**
+ * Contract addresses for Lux Mainnet (96369)
+ */
+export const LUX_MAINNET_CONTRACTS = {
+    // Core
+    WLUX: '0x55750d6CA62a041c06a8E28626b10Be6c688f471',
+    MULTICALL: '0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F',
+    // Bridge tokens
+    LETH: '0xAA3AE95816a4A6FbC6b8Ed5a6C06f22A96A80C8C',
+    LBTC: '0x526903E35E7106D62ED3B5d77E14e51d024Aa1D3',
+    LUSD: '0x4B1BfA76eD63F1A0aD2E4f40b3F46C45E8F7A4E2',
+    // AMM V2 (QuantumSwap)
+    V2_FACTORY: '0xd9a95609DbB228A13568Bd9f9A285105E7596970',
+    V2_ROUTER: '0x1F6cbC7d3bc7D803ee76D80F0eEE25767431e674',
+    // AMM V3 (Concentrated Liquidity)
+    V3_FACTORY: '0xb732BD88F25EdD9C3456638671fB37685D4B4e3f',
+    V3_SWAP_ROUTER: '0xE8fb25086C8652c92f5AF90D730Bac7C63Fc9A58',
+    V3_SWAP_ROUTER_02: '0x939bC0Bca6F9B9c52E6e3AD8A3C590b5d9B9D10E',
+    V3_QUOTER: '0x12e2B76FaF4dDA5a173a4532916bb6Bfa3645275',
+    V3_QUOTER_V2: '0x15C729fdd833Ba675edd466Dfc63E1B737925A4c',
+    V3_TICK_LENS: '0x57A22965AdA0e52D785A9Aa155beF423D573b879',
+    V3_NFT_POSITION_MANAGER: '0x7a4C48B9dae0b7c396569b34042fcA604150Ee28',
+    V3_NFT_DESCRIPTOR: '0x53B1aAA5b6DDFD4eD00D0A7b5Ef333dc74B605b5',
+};
+/**
+ * Contract addresses for Lux Testnet (96368)
+ */
+export const LUX_TESTNET_CONTRACTS = {
+    // Core
+    WLUX: '0x732740c5c895C9FCF619930ed4293fc858eb44c7',
+    WETH: '0xd9956542B51032d940ef076d70B69410667277A3',
+    MULTICALL: '0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F',
+    // AMM V2
+    V2_FACTORY: '0x81C3669B139D92909AA67DbF74a241b10540d919',
+    V2_ROUTER: '0xDB6c703c80BFaE5F9a56482d3c8535f27E1136EB',
+    // AMM V3
+    V3_FACTORY: '0x80bBc7C4C7a59C899D1B37BC14539A22D5830a84',
+    V3_SWAP_ROUTER: '0xE8fb25086C8652c92f5AF90D730Bac7C63Fc9A58',
+    V3_SWAP_ROUTER_02: '0x939bC0Bca6F9B9c52E6e3AD8A3C590b5d9B9D10E',
+    V3_QUOTER: '0x12e2B76FaF4dDA5a173a4532916bb6Bfa3645275',
+    V3_QUOTER_V2: '0x15C729fdd833Ba675edd466Dfc63E1B737925A4c',
+    V3_TICK_LENS: '0x57A22965AdA0e52D785A9Aa155beF423D573b879',
+    V3_NFT_POSITION_MANAGER: '0x7a4C48B9dae0b7c396569b34042fcA604150Ee28',
+    V3_NFT_DESCRIPTOR: '0x53B1aAA5b6DDFD4eD00D0A7b5Ef333dc74B605b5',
+};
+/**
+ * DEX Precompile addresses (native AMM)
+ * These provide sub-microsecond execution
+ */
+export const DEX_PRECOMPILES = {
+    POOL_MANAGER: '0x0000000000000000000000000000000000000400',
+    SWAP_ROUTER: '0x0000000000000000000000000000000000000401',
+    HOOKS_REGISTRY: '0x0000000000000000000000000000000000000402',
+    FLASH_LOAN: '0x0000000000000000000000000000000000000403',
+};
+/**
+ * Get contracts for a specific chain
+ */
+export function getContracts(chainId) {
+    switch (chainId) {
+        case 96369:
+            return LUX_MAINNET_CONTRACTS;
+        case 96368:
+            return LUX_TESTNET_CONTRACTS;
+        default:
+            return LUX_TESTNET_CONTRACTS;
+    }
+}

package/dist/env.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Environment configuration
+ */
+export declare const ENV: {
+    readonly DEFAULT_CHAIN_ID: number;
+    readonly API_URL: string;
+    readonly LUX_MAINNET_RPC: string;
+    readonly LUX_TESTNET_RPC: string;
+    readonly ZOO_MAINNET_RPC: string;
+    readonly ZOO_TESTNET_RPC: string;
+    readonly ENABLE_TESTNET: boolean;
+    readonly ENABLE_DEX_PRECOMPILES: boolean;
+    readonly ENABLE_CROSS_CHAIN: boolean;
+    readonly WALLETCONNECT_PROJECT_ID: string;
+};
+export type Env = typeof ENV;
+//# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,GAAG;;;;;;;;;;;CAoBN,CAAA;AAEV,MAAM,MAAM,GAAG,GAAG,OAAO,GAAG,CAAA"}

package/dist/env.js

@@ -0,0 +1,20 @@
+/**
+ * Environment configuration
+ */
+export const ENV = {
+    // Chain IDs
+    DEFAULT_CHAIN_ID: parseInt(process.env.NEXT_PUBLIC_DEFAULT_CHAIN_ID || '96369'),
+    // API URLs
+    API_URL: process.env.NEXT_PUBLIC_API_URL || 'https://api.lux.exchange',
+    // RPC URLs
+    LUX_MAINNET_RPC: process.env.NEXT_PUBLIC_LUX_MAINNET_RPC || 'https://api.lux.network/rpc',
+    LUX_TESTNET_RPC: process.env.NEXT_PUBLIC_LUX_TESTNET_RPC || 'https://api.lux-test.network/rpc',
+    ZOO_MAINNET_RPC: process.env.NEXT_PUBLIC_ZOO_MAINNET_RPC || 'https://api.zoo.network/rpc',
+    ZOO_TESTNET_RPC: process.env.NEXT_PUBLIC_ZOO_TESTNET_RPC || 'https://api.zoo-test.network/rpc',
+    // Feature flags
+    ENABLE_TESTNET: process.env.NEXT_PUBLIC_ENABLE_TESTNET === 'true',
+    ENABLE_DEX_PRECOMPILES: process.env.NEXT_PUBLIC_ENABLE_DEX_PRECOMPILES === 'true',
+    ENABLE_CROSS_CHAIN: process.env.NEXT_PUBLIC_ENABLE_CROSS_CHAIN === 'true',
+    // WalletConnect
+    WALLETCONNECT_PROJECT_ID: process.env.NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID || '',
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @luxfi/config - Shared configuration for Lux Exchange
+ */
+export * from './chains';
+export * from './contracts';
+export * from './wagmi';
+export * from './env';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA;AACvB,cAAc,OAAO,CAAA"}

package/dist/index.js

@@ -0,0 +1,7 @@
+/**
+ * @luxfi/config - Shared configuration for Lux Exchange
+ */
+export * from './chains';
+export * from './contracts';
+export * from './wagmi';
+export * from './env';

package/dist/wagmi.d.ts

@@ -0,0 +1,297 @@
+/**
+ * Wagmi configuration for Lux Exchange
+ */
+export declare const wagmiConfig: import("wagmi").Config<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: "Etherscan";
+            readonly url: "https://etherscan.io";
+            readonly apiUrl: "https://api.etherscan.io/api";
+        };
+    };
+    blockTime: 12000;
+    contracts: {
+        readonly ensUniversalResolver: {
+            readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+            readonly blockCreated: 23085558;
+        };
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 14353601;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 1;
+    name: "Ethereum";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://eth.merkle.io"];
+        };
+    };
+    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: "Etherscan";
+            readonly url: "https://sepolia.etherscan.io";
+            readonly apiUrl: "https://api-sepolia.etherscan.io/api";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 751532;
+        };
+        readonly ensUniversalResolver: {
+            readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+            readonly blockCreated: 8928790;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 11155111;
+    name: "Sepolia";
+    nativeCurrency: {
+        readonly name: "Sepolia Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
+        };
+    };
+    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;
+}], {
+    96369: import("viem").HttpTransport<undefined, false>;
+    96368: import("viem").HttpTransport<undefined, false>;
+    200200: import("viem").HttpTransport<undefined, false>;
+    200201: import("viem").HttpTransport<undefined, false>;
+    1: import("viem").HttpTransport<undefined, false>;
+    11155111: import("viem").HttpTransport<undefined, false>;
+}, readonly import("wagmi").CreateConnectorFn[]>;
+export type WagmiConfig = typeof wagmiConfig;
+//# sourceMappingURL=wagmi.d.ts.map

package/dist/wagmi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wagmi.d.ts","sourceRoot":"","sources":["../src/wagmi.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAYtB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAA"}

package/dist/wagmi.js

@@ -0,0 +1,19 @@
+import { http, createConfig } from 'wagmi';
+import { mainnet, sepolia } from 'wagmi/chains';
+import { luxMainnet, luxTestnet, zooMainnet, zooTestnet } from './chains';
+/**
+ * Wagmi configuration for Lux Exchange
+ */
+export const wagmiConfig = createConfig({
+    chains: [luxMainnet, luxTestnet, zooMainnet, zooTestnet, mainnet, sepolia],
+    transports: {
+        // Lux chains
+        [luxMainnet.id]: http('https://api.lux.network/rpc'),
+        [luxTestnet.id]: http('https://api.lux-test.network/rpc'),
+        [zooMainnet.id]: http('https://api.zoo.network/rpc'),
+        [zooTestnet.id]: http('https://api.zoo-test.network/rpc'),
+        // Ethereum (for bridging)
+        [mainnet.id]: http(),
+        [sepolia.id]: http(),
+    },
+});

package/env.d.ts

@@ -0,0 +1,64 @@
+/** biome-ignore-all lint/style/noNamespace: required to define process.env type */
+
+declare global {
+  namespace NodeJS {
+    // All process.env values used by this package should be listed here
+    interface ProcessEnv {
+      NODE_ENV?: 'development' | 'production' | 'test'
+      ALCHEMY_API_KEY?: string
+      AMPLITUDE_PROXY_URL_OVERRIDE?: string
+      API_BASE_URL_OVERRIDE?: string
+      API_BASE_URL_V2_OVERRIDE?: string
+      APPSFLYER_API_KEY?: string
+      APPSFLYER_APP_ID?: string
+      BLOCKAID_PROXY_URL?: string
+      CI?: string
+      DATADOG_CLIENT_TOKEN?: string
+      DATADOG_PROJECT_ID?: string
+      ENABLE_ENTRY_GATEWAY_PROXY?: string
+      ENABLE_SESSION_SERVICE?: string
+      ENABLE_SESSION_UPGRADE_AUTO?: string
+      ENTRY_GATEWAY_API_URL_OVERRIDE?: string
+      FOR_API_URL_OVERRIDE?: string
+      GRAPHQL_URL_OVERRIDE?: string
+      INCLUDE_PROTOTYPE_FEATURES?: string
+      IS_E2E_TEST?: string
+      JUPITER_PROXY_URL?: string
+      LIQUIDITY_SERVICE_URL_OVERRIDE?: string
+      ONESIGNAL_APP_ID?: string
+      QUICKNODE_ENDPOINT_NAME?: string
+      QUICKNODE_ENDPOINT_TOKEN?: string
+      REACT_APP_ALCHEMY_API_KEY?: string
+      REACT_APP_BLOCKAID_PROXY_URL?: string
+      REACT_APP_DATADOG_CLIENT_TOKEN?: string
+      REACT_APP_DATADOG_PROJECT_ID?: string
+      REACT_APP_ENABLE_SESSION_UPGRADE_AUTO?: string
+      REACT_APP_INFURA_KEY?: string
+      REACT_APP_JUPITER_PROXY_URL?: string
+      REACT_APP_LIQUIDITY_SERVICE_URL_OVERRIDE?: string
+      REACT_APP_QUICKNODE_ENDPOINT_NAME?: string
+      REACT_APP_QUICKNODE_ENDPOINT_TOKEN?: string
+      REACT_APP_STATSIG_API_KEY?: string
+      REACT_APP_TRADING_API_KEY?: string
+      REACT_APP_TRADING_API_TEST_ENV?: string
+      REACT_APP_TRADING_API_URL_OVERRIDE?: string
+      REACT_APP_WALLET_CONNECT_PROJECT_ID?: string
+      SCANTASTIC_API_URL_OVERRIDE?: string
+      STATSIG_API_KEY?: string
+      STATSIG_PROXY_URL_OVERRIDE?: string
+      TRADING_API_KEY?: string
+      TRADING_API_URL_OVERRIDE?: string
+      LUX_API_KEY?: string
+      LUX_NOTIF_API_BASE_URL_OVERRIDE?: string
+      UNITAGS_API_URL_OVERRIDE?: string
+      VERSION?: string
+      VERCEL?: string
+      VITE_ENABLE_ENTRY_GATEWAY_PROXY?: string
+      WALLETCONNECT_PROJECT_ID?: string
+      WALLETCONNECT_PROJECT_ID_BETA?: string
+      WALLETCONNECT_PROJECT_ID_DEV?: string
+    }
+  }
+}
+
+export {}

package/env.native.d.ts

@@ -0,0 +1,40 @@
+// Adds typing for react-native-dotenv
+// Must be kept separately from env.d.ts as due to issue with global
+// namespace vs module declarations
+declare module 'react-native-dotenv' {
+  export const ALCHEMY_API_KEY: string
+  export const AMPLITUDE_PROXY_URL_OVERRIDE: string
+  export const API_BASE_URL_OVERRIDE: string
+  export const API_BASE_URL_V2_OVERRIDE: string
+  export const APPSFLYER_API_KEY: string
+  export const APPSFLYER_APP_ID: string
+  export const BLOCKAID_PROXY_URL: string
+  export const DATADOG_CLIENT_TOKEN: string
+  export const DATADOG_PROJECT_ID: string
+  export const ENABLE_ENTRY_GATEWAY_PROXY: string
+  export const ENABLE_SESSION_SERVICE: string
+  export const ENABLE_SESSION_UPGRADE_AUTO: string
+  export const ENTRY_GATEWAY_API_URL_OVERRIDE: string
+  export const FOR_API_URL_OVERRIDE: string
+  export const GRAPHQL_URL_OVERRIDE: string
+  export const INCLUDE_PROTOTYPE_FEATURES: string
+  export const INFURA_KEY: string
+  export const IS_E2E_TEST: string
+  export const JUPITER_PROXY_URL: string
+  export const LIQUIDITY_SERVICE_URL_OVERRIDE: string
+  export const LUX_GATEWAY_URL: string
+  export const ONESIGNAL_APP_ID: string
+  export const QUICKNODE_ENDPOINT_NAME: string
+  export const QUICKNODE_ENDPOINT_TOKEN: string
+  export const SCANTASTIC_API_URL_OVERRIDE: string
+  export const STATSIG_API_KEY: string
+  export const STATSIG_PROXY_URL_OVERRIDE: string
+  export const TRADING_API_KEY: string
+  export const TRADING_API_URL_OVERRIDE: string
+  export const LUX_API_KEY: string
+  export const LUX_NOTIF_API_BASE_URL_OVERRIDE: string
+  export const UNITAGS_API_URL_OVERRIDE: string
+  export const WALLETCONNECT_PROJECT_ID: string
+  export const WALLETCONNECT_PROJECT_ID_BETA: string
+  export const WALLETCONNECT_PROJECT_ID_DEV: string
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@luxexchange/config",
+  "version": "1.0.0",
+  "dependencies": {
+    "react-native-dotenv": "3.2.0",
+    "@luxfi/utilities": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "22.13.1",
+    "@typescript/native-preview": "7.0.0-dev.20260108.1",
+    "@luxfi/eslint-config": "^1.0.0",
+    "depcheck": "1.4.7",
+    "eslint": "8.57.1",
+    "typescript": "5.8.3"
+  },
+  "scripts": {
+    "typecheck": "nx typecheck config",
+    "typecheck:tsgo": "nx typecheck:tsgo config",
+    "lint": "nx lint config",
+    "lint:fix": "nx lint:fix config",
+    "lint:biome": "nx lint:biome config",
+    "lint:biome:fix": "nx lint:biome:fix config",
+    "lint:eslint": "nx lint:eslint config",
+    "lint:eslint:fix": "nx lint:eslint:fix config",
+    "check:deps:usage": "nx check:deps:usage config"
+  },
+  "nx": {
+    "includedScripts": []
+  },
+  "main": "src/index.ts",
+  "private": false,
+  "sideEffects": false
+}

package/project.json

@@ -0,0 +1,18 @@
+{
+  "name": "@luxfi/config",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "pkgs/config/src",
+  "projectType": "library",
+  "tags": ["scope:config", "type:lib"],
+  "targets": {
+    "typecheck": {},
+    "typecheck:tsgo": {},
+    "lint:biome": {},
+    "lint:biome:fix": {},
+    "lint:eslint": {},
+    "lint:eslint:fix": {},
+    "lint": {},
+    "lint:fix": {},
+    "check:deps:usage": {}
+  }
+}