@luxexchange/config 1.0.2 → 1.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (33) hide show
  1. package/.depcheckrc +9 -0
  2. package/.eslintrc.js +20 -0
  3. package/env.d.ts +2 -2
  4. package/env.native.d.ts +2 -3
  5. package/package.json +1 -1
  6. package/project.json +1 -1
  7. package/src/brand.ts +165 -0
  8. package/src/config-types.ts +2 -4
  9. package/src/getConfig.native.ts +7 -13
  10. package/src/getConfig.ts +2 -2
  11. package/src/getConfig.web.ts +4 -12
  12. package/src/index.ts +2 -35
  13. package/src/legal.ts +55 -0
  14. package/tsconfig.json +17 -3
  15. package/dist/chains.d.ts +0 -405
  16. package/dist/chains.d.ts.map +0 -1
  17. package/dist/chains.js +0 -105
  18. package/dist/contracts.d.ts +0 -85
  19. package/dist/contracts.d.ts.map +0 -1
  20. package/dist/contracts.js +0 -68
  21. package/dist/env.d.ts +0 -17
  22. package/dist/env.d.ts.map +0 -1
  23. package/dist/env.js +0 -20
  24. package/dist/index.d.ts +0 -8
  25. package/dist/index.d.ts.map +0 -1
  26. package/dist/index.js +0 -7
  27. package/dist/wagmi.d.ts +0 -297
  28. package/dist/wagmi.d.ts.map +0 -1
  29. package/dist/wagmi.js +0 -19
  30. package/src/chains.ts +0 -224
  31. package/src/contracts.ts +0 -193
  32. package/src/env.ts +0 -27
  33. package/src/wagmi.ts +0 -27
package/dist/chains.d.ts DELETED
@@ -1,405 +0,0 @@
1
- /**
2
- * Lux Mainnet Chain Definition
3
- */
4
- export declare const luxMainnet: {
5
- blockExplorers: {
6
- readonly default: {
7
- readonly name: "Lux Explorer";
8
- readonly url: "https://explore.lux.network";
9
- };
10
- };
11
- blockTime?: number | undefined | undefined;
12
- contracts: {
13
- readonly multicall3: {
14
- readonly address: "0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F";
15
- };
16
- };
17
- ensTlds?: readonly string[] | undefined;
18
- id: 96369;
19
- name: "Lux Mainnet";
20
- nativeCurrency: {
21
- readonly name: "LUX";
22
- readonly symbol: "LUX";
23
- readonly decimals: 18;
24
- };
25
- experimental_preconfirmationTime?: number | undefined | undefined;
26
- rpcUrls: {
27
- readonly default: {
28
- readonly http: readonly ["https://api.lux.network/rpc"];
29
- };
30
- readonly public: {
31
- readonly http: readonly ["https://api.lux.network/rpc"];
32
- };
33
- };
34
- sourceId?: number | undefined | undefined;
35
- testnet?: boolean | undefined | undefined;
36
- custom?: Record<string, unknown> | undefined;
37
- extendSchema?: Record<string, unknown> | undefined;
38
- fees?: import("viem").ChainFees<undefined> | undefined;
39
- formatters?: undefined;
40
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
41
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
42
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
43
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
44
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
45
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
46
- }] | undefined;
47
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
48
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
49
- };
50
- /**
51
- * Lux Testnet Chain Definition
52
- */
53
- export declare const luxTestnet: {
54
- blockExplorers: {
55
- readonly default: {
56
- readonly name: "Lux Testnet Explorer";
57
- readonly url: "https://explore.lux-test.network";
58
- };
59
- };
60
- blockTime?: number | undefined | undefined;
61
- contracts: {
62
- readonly multicall3: {
63
- readonly address: "0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F";
64
- };
65
- };
66
- ensTlds?: readonly string[] | undefined;
67
- id: 96368;
68
- name: "Lux Testnet";
69
- nativeCurrency: {
70
- readonly name: "LUX";
71
- readonly symbol: "LUX";
72
- readonly decimals: 18;
73
- };
74
- experimental_preconfirmationTime?: number | undefined | undefined;
75
- rpcUrls: {
76
- readonly default: {
77
- readonly http: readonly ["https://api.lux-test.network/rpc"];
78
- };
79
- readonly public: {
80
- readonly http: readonly ["https://api.lux-test.network/rpc"];
81
- };
82
- };
83
- sourceId?: number | undefined | undefined;
84
- testnet: true;
85
- custom?: Record<string, unknown> | undefined;
86
- extendSchema?: Record<string, unknown> | undefined;
87
- fees?: import("viem").ChainFees<undefined> | undefined;
88
- formatters?: undefined;
89
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
90
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
91
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
92
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
93
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
94
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
95
- }] | undefined;
96
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
97
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
98
- };
99
- /**
100
- * Zoo Mainnet Chain Definition
101
- */
102
- export declare const zooMainnet: {
103
- blockExplorers: {
104
- readonly default: {
105
- readonly name: "Zoo Explorer";
106
- readonly url: "https://explore.zoo.network";
107
- };
108
- };
109
- blockTime?: number | undefined | undefined;
110
- contracts?: {
111
- [x: string]: import("viem").ChainContract | {
112
- [sourceId: number]: import("viem").ChainContract | undefined;
113
- } | undefined;
114
- ensRegistry?: import("viem").ChainContract | undefined;
115
- ensUniversalResolver?: import("viem").ChainContract | undefined;
116
- multicall3?: import("viem").ChainContract | undefined;
117
- erc6492Verifier?: import("viem").ChainContract | undefined;
118
- } | undefined;
119
- ensTlds?: readonly string[] | undefined;
120
- id: 200200;
121
- name: "Zoo Network";
122
- nativeCurrency: {
123
- readonly name: "ZOO";
124
- readonly symbol: "ZOO";
125
- readonly decimals: 18;
126
- };
127
- experimental_preconfirmationTime?: number | undefined | undefined;
128
- rpcUrls: {
129
- readonly default: {
130
- readonly http: readonly ["https://api.zoo.network/rpc"];
131
- };
132
- readonly public: {
133
- readonly http: readonly ["https://api.zoo.network/rpc"];
134
- };
135
- };
136
- sourceId?: number | undefined | undefined;
137
- testnet?: boolean | undefined | undefined;
138
- custom?: Record<string, unknown> | undefined;
139
- extendSchema?: Record<string, unknown> | undefined;
140
- fees?: import("viem").ChainFees<undefined> | undefined;
141
- formatters?: undefined;
142
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
143
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
144
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
145
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
146
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
147
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
148
- }] | undefined;
149
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
150
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
151
- };
152
- /**
153
- * Zoo Testnet Chain Definition
154
- */
155
- export declare const zooTestnet: {
156
- blockExplorers: {
157
- readonly default: {
158
- readonly name: "Zoo Testnet Explorer";
159
- readonly url: "https://explore.zoo-test.network";
160
- };
161
- };
162
- blockTime?: number | undefined | undefined;
163
- contracts?: {
164
- [x: string]: import("viem").ChainContract | {
165
- [sourceId: number]: import("viem").ChainContract | undefined;
166
- } | undefined;
167
- ensRegistry?: import("viem").ChainContract | undefined;
168
- ensUniversalResolver?: import("viem").ChainContract | undefined;
169
- multicall3?: import("viem").ChainContract | undefined;
170
- erc6492Verifier?: import("viem").ChainContract | undefined;
171
- } | undefined;
172
- ensTlds?: readonly string[] | undefined;
173
- id: 200201;
174
- name: "Zoo Testnet";
175
- nativeCurrency: {
176
- readonly name: "ZOO";
177
- readonly symbol: "ZOO";
178
- readonly decimals: 18;
179
- };
180
- experimental_preconfirmationTime?: number | undefined | undefined;
181
- rpcUrls: {
182
- readonly default: {
183
- readonly http: readonly ["https://api.zoo-test.network/rpc"];
184
- };
185
- readonly public: {
186
- readonly http: readonly ["https://api.zoo-test.network/rpc"];
187
- };
188
- };
189
- sourceId?: number | undefined | undefined;
190
- testnet: true;
191
- custom?: Record<string, unknown> | undefined;
192
- extendSchema?: Record<string, unknown> | undefined;
193
- fees?: import("viem").ChainFees<undefined> | undefined;
194
- formatters?: undefined;
195
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
196
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
197
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
198
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
199
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
200
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
201
- }] | undefined;
202
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
203
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
204
- };
205
- /**
206
- * Chain IDs
207
- */
208
- export declare const LUX_MAINNET_ID = 96369;
209
- export declare const LUX_TESTNET_ID = 96368;
210
- export declare const ZOO_MAINNET_ID = 200200;
211
- export declare const ZOO_TESTNET_ID = 200201;
212
- /**
213
- * All supported chains
214
- */
215
- export declare const supportedChains: readonly [{
216
- blockExplorers: {
217
- readonly default: {
218
- readonly name: "Lux Explorer";
219
- readonly url: "https://explore.lux.network";
220
- };
221
- };
222
- blockTime?: number | undefined | undefined;
223
- contracts: {
224
- readonly multicall3: {
225
- readonly address: "0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F";
226
- };
227
- };
228
- ensTlds?: readonly string[] | undefined;
229
- id: 96369;
230
- name: "Lux Mainnet";
231
- nativeCurrency: {
232
- readonly name: "LUX";
233
- readonly symbol: "LUX";
234
- readonly decimals: 18;
235
- };
236
- experimental_preconfirmationTime?: number | undefined | undefined;
237
- rpcUrls: {
238
- readonly default: {
239
- readonly http: readonly ["https://api.lux.network/rpc"];
240
- };
241
- readonly public: {
242
- readonly http: readonly ["https://api.lux.network/rpc"];
243
- };
244
- };
245
- sourceId?: number | undefined | undefined;
246
- testnet?: boolean | undefined | undefined;
247
- custom?: Record<string, unknown> | undefined;
248
- extendSchema?: Record<string, unknown> | undefined;
249
- fees?: import("viem").ChainFees<undefined> | undefined;
250
- formatters?: undefined;
251
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
252
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
253
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
254
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
255
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
256
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
257
- }] | undefined;
258
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
259
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
260
- }, {
261
- blockExplorers: {
262
- readonly default: {
263
- readonly name: "Lux Testnet Explorer";
264
- readonly url: "https://explore.lux-test.network";
265
- };
266
- };
267
- blockTime?: number | undefined | undefined;
268
- contracts: {
269
- readonly multicall3: {
270
- readonly address: "0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F";
271
- };
272
- };
273
- ensTlds?: readonly string[] | undefined;
274
- id: 96368;
275
- name: "Lux Testnet";
276
- nativeCurrency: {
277
- readonly name: "LUX";
278
- readonly symbol: "LUX";
279
- readonly decimals: 18;
280
- };
281
- experimental_preconfirmationTime?: number | undefined | undefined;
282
- rpcUrls: {
283
- readonly default: {
284
- readonly http: readonly ["https://api.lux-test.network/rpc"];
285
- };
286
- readonly public: {
287
- readonly http: readonly ["https://api.lux-test.network/rpc"];
288
- };
289
- };
290
- sourceId?: number | undefined | undefined;
291
- testnet: true;
292
- custom?: Record<string, unknown> | undefined;
293
- extendSchema?: Record<string, unknown> | undefined;
294
- fees?: import("viem").ChainFees<undefined> | undefined;
295
- formatters?: undefined;
296
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
297
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
298
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
299
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
300
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
301
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
302
- }] | undefined;
303
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
304
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
305
- }, {
306
- blockExplorers: {
307
- readonly default: {
308
- readonly name: "Zoo Explorer";
309
- readonly url: "https://explore.zoo.network";
310
- };
311
- };
312
- blockTime?: number | undefined | undefined;
313
- contracts?: {
314
- [x: string]: import("viem").ChainContract | {
315
- [sourceId: number]: import("viem").ChainContract | undefined;
316
- } | undefined;
317
- ensRegistry?: import("viem").ChainContract | undefined;
318
- ensUniversalResolver?: import("viem").ChainContract | undefined;
319
- multicall3?: import("viem").ChainContract | undefined;
320
- erc6492Verifier?: import("viem").ChainContract | undefined;
321
- } | undefined;
322
- ensTlds?: readonly string[] | undefined;
323
- id: 200200;
324
- name: "Zoo Network";
325
- nativeCurrency: {
326
- readonly name: "ZOO";
327
- readonly symbol: "ZOO";
328
- readonly decimals: 18;
329
- };
330
- experimental_preconfirmationTime?: number | undefined | undefined;
331
- rpcUrls: {
332
- readonly default: {
333
- readonly http: readonly ["https://api.zoo.network/rpc"];
334
- };
335
- readonly public: {
336
- readonly http: readonly ["https://api.zoo.network/rpc"];
337
- };
338
- };
339
- sourceId?: number | undefined | undefined;
340
- testnet?: boolean | undefined | undefined;
341
- custom?: Record<string, unknown> | undefined;
342
- extendSchema?: Record<string, unknown> | undefined;
343
- fees?: import("viem").ChainFees<undefined> | undefined;
344
- formatters?: undefined;
345
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
346
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
347
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
348
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
349
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
350
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
351
- }] | undefined;
352
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
353
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
354
- }, {
355
- blockExplorers: {
356
- readonly default: {
357
- readonly name: "Zoo Testnet Explorer";
358
- readonly url: "https://explore.zoo-test.network";
359
- };
360
- };
361
- blockTime?: number | undefined | undefined;
362
- contracts?: {
363
- [x: string]: import("viem").ChainContract | {
364
- [sourceId: number]: import("viem").ChainContract | undefined;
365
- } | undefined;
366
- ensRegistry?: import("viem").ChainContract | undefined;
367
- ensUniversalResolver?: import("viem").ChainContract | undefined;
368
- multicall3?: import("viem").ChainContract | undefined;
369
- erc6492Verifier?: import("viem").ChainContract | undefined;
370
- } | undefined;
371
- ensTlds?: readonly string[] | undefined;
372
- id: 200201;
373
- name: "Zoo Testnet";
374
- nativeCurrency: {
375
- readonly name: "ZOO";
376
- readonly symbol: "ZOO";
377
- readonly decimals: 18;
378
- };
379
- experimental_preconfirmationTime?: number | undefined | undefined;
380
- rpcUrls: {
381
- readonly default: {
382
- readonly http: readonly ["https://api.zoo-test.network/rpc"];
383
- };
384
- readonly public: {
385
- readonly http: readonly ["https://api.zoo-test.network/rpc"];
386
- };
387
- };
388
- sourceId?: number | undefined | undefined;
389
- testnet: true;
390
- custom?: Record<string, unknown> | undefined;
391
- extendSchema?: Record<string, unknown> | undefined;
392
- fees?: import("viem").ChainFees<undefined> | undefined;
393
- formatters?: undefined;
394
- prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
395
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
396
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
397
- phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
398
- }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
399
- runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
400
- }] | undefined;
401
- serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
402
- verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
403
- }];
404
- export type SupportedChainId = typeof supportedChains[number]['id'];
405
- //# sourceMappingURL=chains.d.ts.map
package/dist/chains.d.ts.map DELETED
@@ -1 +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 DELETED
@@ -1,105 +0,0 @@
1
- import { defineChain } from 'viem';
2
- /**
3
- * Lux Mainnet Chain Definition
4
- */
5
- export const luxMainnet = defineChain({
6
- id: 96369,
7
- name: 'Lux Mainnet',
8
- nativeCurrency: {
9
- name: 'LUX',
10
- symbol: 'LUX',
11
- decimals: 18,
12
- },
13
- rpcUrls: {
14
- default: { http: ['https://api.lux.network/rpc'] },
15
- public: { http: ['https://api.lux.network/rpc'] },
16
- },
17
- blockExplorers: {
18
- default: { name: 'Lux Explorer', url: 'https://explore.lux.network' },
19
- },
20
- contracts: {
21
- multicall3: {
22
- address: '0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F',
23
- },
24
- },
25
- });
26
- /**
27
- * Lux Testnet Chain Definition
28
- */
29
- export const luxTestnet = defineChain({
30
- id: 96368,
31
- name: 'Lux Testnet',
32
- nativeCurrency: {
33
- name: 'LUX',
34
- symbol: 'LUX',
35
- decimals: 18,
36
- },
37
- rpcUrls: {
38
- default: { http: ['https://api.lux-test.network/rpc'] },
39
- public: { http: ['https://api.lux-test.network/rpc'] },
40
- },
41
- blockExplorers: {
42
- default: { name: 'Lux Testnet Explorer', url: 'https://explore.lux-test.network' },
43
- },
44
- contracts: {
45
- multicall3: {
46
- address: '0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F',
47
- },
48
- },
49
- testnet: true,
50
- });
51
- /**
52
- * Zoo Mainnet Chain Definition
53
- */
54
- export const zooMainnet = defineChain({
55
- id: 200200,
56
- name: 'Zoo Network',
57
- nativeCurrency: {
58
- name: 'ZOO',
59
- symbol: 'ZOO',
60
- decimals: 18,
61
- },
62
- rpcUrls: {
63
- default: { http: ['https://api.zoo.network/rpc'] },
64
- public: { http: ['https://api.zoo.network/rpc'] },
65
- },
66
- blockExplorers: {
67
- default: { name: 'Zoo Explorer', url: 'https://explore.zoo.network' },
68
- },
69
- });
70
- /**
71
- * Zoo Testnet Chain Definition
72
- */
73
- export const zooTestnet = defineChain({
74
- id: 200201,
75
- name: 'Zoo Testnet',
76
- nativeCurrency: {
77
- name: 'ZOO',
78
- symbol: 'ZOO',
79
- decimals: 18,
80
- },
81
- rpcUrls: {
82
- default: { http: ['https://api.zoo-test.network/rpc'] },
83
- public: { http: ['https://api.zoo-test.network/rpc'] },
84
- },
85
- blockExplorers: {
86
- default: { name: 'Zoo Testnet Explorer', url: 'https://explore.zoo-test.network' },
87
- },
88
- testnet: true,
89
- });
90
- /**
91
- * Chain IDs
92
- */
93
- export const LUX_MAINNET_ID = 96369;
94
- export const LUX_TESTNET_ID = 96368;
95
- export const ZOO_MAINNET_ID = 200200;
96
- export const ZOO_TESTNET_ID = 200201;
97
- /**
98
- * All supported chains
99
- */
100
- export const supportedChains = [
101
- luxMainnet,
102
- luxTestnet,
103
- zooMainnet,
104
- zooTestnet,
105
- ];
package/dist/contracts.d.ts DELETED
@@ -1,85 +0,0 @@
1
- import type { Address } from 'viem';
2
- /**
3
- * Contract addresses for Lux Mainnet (96369)
4
- */
5
- export declare const LUX_MAINNET_CONTRACTS: {
6
- readonly WLUX: Address;
7
- readonly MULTICALL: Address;
8
- readonly LETH: Address;
9
- readonly LBTC: Address;
10
- readonly LUSD: Address;
11
- readonly V2_FACTORY: Address;
12
- readonly V2_ROUTER: Address;
13
- readonly V3_FACTORY: Address;
14
- readonly V3_SWAP_ROUTER: Address;
15
- readonly V3_SWAP_ROUTER_02: Address;
16
- readonly V3_QUOTER: Address;
17
- readonly V3_QUOTER_V2: Address;
18
- readonly V3_TICK_LENS: Address;
19
- readonly V3_NFT_POSITION_MANAGER: Address;
20
- readonly V3_NFT_DESCRIPTOR: Address;
21
- };
22
- /**
23
- * Contract addresses for Lux Testnet (96368)
24
- */
25
- export declare const LUX_TESTNET_CONTRACTS: {
26
- readonly WLUX: Address;
27
- readonly WETH: Address;
28
- readonly MULTICALL: Address;
29
- readonly V2_FACTORY: Address;
30
- readonly V2_ROUTER: Address;
31
- readonly V3_FACTORY: Address;
32
- readonly V3_SWAP_ROUTER: Address;
33
- readonly V3_SWAP_ROUTER_02: Address;
34
- readonly V3_QUOTER: Address;
35
- readonly V3_QUOTER_V2: Address;
36
- readonly V3_TICK_LENS: Address;
37
- readonly V3_NFT_POSITION_MANAGER: Address;
38
- readonly V3_NFT_DESCRIPTOR: Address;
39
- };
40
- /**
41
- * DEX Precompile addresses (native AMM)
42
- * These provide sub-microsecond execution
43
- */
44
- export declare const DEX_PRECOMPILES: {
45
- readonly POOL_MANAGER: Address;
46
- readonly SWAP_ROUTER: Address;
47
- readonly HOOKS_REGISTRY: Address;
48
- readonly FLASH_LOAN: Address;
49
- };
50
- /**
51
- * Get contracts for a specific chain
52
- */
53
- export declare function getContracts(chainId: number): {
54
- readonly WLUX: Address;
55
- readonly MULTICALL: Address;
56
- readonly LETH: Address;
57
- readonly LBTC: Address;
58
- readonly LUSD: Address;
59
- readonly V2_FACTORY: Address;
60
- readonly V2_ROUTER: Address;
61
- readonly V3_FACTORY: Address;
62
- readonly V3_SWAP_ROUTER: Address;
63
- readonly V3_SWAP_ROUTER_02: Address;
64
- readonly V3_QUOTER: Address;
65
- readonly V3_QUOTER_V2: Address;
66
- readonly V3_TICK_LENS: Address;
67
- readonly V3_NFT_POSITION_MANAGER: Address;
68
- readonly V3_NFT_DESCRIPTOR: Address;
69
- } | {
70
- readonly WLUX: Address;
71
- readonly WETH: Address;
72
- readonly MULTICALL: Address;
73
- readonly V2_FACTORY: Address;
74
- readonly V2_ROUTER: Address;
75
- readonly V3_FACTORY: Address;
76
- readonly V3_SWAP_ROUTER: Address;
77
- readonly V3_SWAP_ROUTER_02: Address;
78
- readonly V3_QUOTER: Address;
79
- readonly V3_QUOTER_V2: Address;
80
- readonly V3_TICK_LENS: Address;
81
- readonly V3_NFT_POSITION_MANAGER: Address;
82
- readonly V3_NFT_DESCRIPTOR: Address;
83
- };
84
- export type ContractAddresses = typeof LUX_MAINNET_CONTRACTS;
85
- //# sourceMappingURL=contracts.d.ts.map
package/dist/contracts.d.ts.map DELETED
@@ -1 +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"}
package/dist/contracts.js DELETED
@@ -1,68 +0,0 @@
1
- /**
2
- * Contract addresses for Lux Mainnet (96369)
3
- */
4
- export const LUX_MAINNET_CONTRACTS = {
5
- // Core
6
- WLUX: '0x55750d6CA62a041c06a8E28626b10Be6c688f471',
7
- MULTICALL: '0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F',
8
- // Bridge tokens
9
- LETH: '0xAA3AE95816a4A6FbC6b8Ed5a6C06f22A96A80C8C',
10
- LBTC: '0x526903E35E7106D62ED3B5d77E14e51d024Aa1D3',
11
- LUSD: '0x4B1BfA76eD63F1A0aD2E4f40b3F46C45E8F7A4E2',
12
- // AMM V2 (QuantumSwap)
13
- V2_FACTORY: '0xd9a95609DbB228A13568Bd9f9A285105E7596970',
14
- V2_ROUTER: '0x1F6cbC7d3bc7D803ee76D80F0eEE25767431e674',
15
- // AMM V3 (Concentrated Liquidity)
16
- V3_FACTORY: '0xb732BD88F25EdD9C3456638671fB37685D4B4e3f',
17
- V3_SWAP_ROUTER: '0xE8fb25086C8652c92f5AF90D730Bac7C63Fc9A58',
18
- V3_SWAP_ROUTER_02: '0x939bC0Bca6F9B9c52E6e3AD8A3C590b5d9B9D10E',
19
- V3_QUOTER: '0x12e2B76FaF4dDA5a173a4532916bb6Bfa3645275',
20
- V3_QUOTER_V2: '0x15C729fdd833Ba675edd466Dfc63E1B737925A4c',
21
- V3_TICK_LENS: '0x57A22965AdA0e52D785A9Aa155beF423D573b879',
22
- V3_NFT_POSITION_MANAGER: '0x7a4C48B9dae0b7c396569b34042fcA604150Ee28',
23
- V3_NFT_DESCRIPTOR: '0x53B1aAA5b6DDFD4eD00D0A7b5Ef333dc74B605b5',
24
- };
25
- /**
26
- * Contract addresses for Lux Testnet (96368)
27
- */
28
- export const LUX_TESTNET_CONTRACTS = {
29
- // Core
30
- WLUX: '0x732740c5c895C9FCF619930ed4293fc858eb44c7',
31
- WETH: '0xd9956542B51032d940ef076d70B69410667277A3',
32
- MULTICALL: '0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F',
33
- // AMM V2
34
- V2_FACTORY: '0x81C3669B139D92909AA67DbF74a241b10540d919',
35
- V2_ROUTER: '0xDB6c703c80BFaE5F9a56482d3c8535f27E1136EB',
36
- // AMM V3
37
- V3_FACTORY: '0x80bBc7C4C7a59C899D1B37BC14539A22D5830a84',
38
- V3_SWAP_ROUTER: '0xE8fb25086C8652c92f5AF90D730Bac7C63Fc9A58',
39
- V3_SWAP_ROUTER_02: '0x939bC0Bca6F9B9c52E6e3AD8A3C590b5d9B9D10E',
40
- V3_QUOTER: '0x12e2B76FaF4dDA5a173a4532916bb6Bfa3645275',
41
- V3_QUOTER_V2: '0x15C729fdd833Ba675edd466Dfc63E1B737925A4c',
42
- V3_TICK_LENS: '0x57A22965AdA0e52D785A9Aa155beF423D573b879',
43
- V3_NFT_POSITION_MANAGER: '0x7a4C48B9dae0b7c396569b34042fcA604150Ee28',
44
- V3_NFT_DESCRIPTOR: '0x53B1aAA5b6DDFD4eD00D0A7b5Ef333dc74B605b5',
45
- };
46
- /**
47
- * DEX Precompile addresses (native AMM)
48
- * These provide sub-microsecond execution
49
- */
50
- export const DEX_PRECOMPILES = {
51
- POOL_MANAGER: '0x0000000000000000000000000000000000000400',
52
- SWAP_ROUTER: '0x0000000000000000000000000000000000000401',
53
- HOOKS_REGISTRY: '0x0000000000000000000000000000000000000402',
54
- FLASH_LOAN: '0x0000000000000000000000000000000000000403',
55
- };
56
- /**
57
- * Get contracts for a specific chain
58
- */
59
- export function getContracts(chainId) {
60
- switch (chainId) {
61
- case 96369:
62
- return LUX_MAINNET_CONTRACTS;
63
- case 96368:
64
- return LUX_TESTNET_CONTRACTS;
65
- default:
66
- return LUX_TESTNET_CONTRACTS;
67
- }
68
- }