@chainflip/sdk 0.1.13 → 0.1.15

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.
package/dist/swap.js CHANGED
@@ -1,7 +1,7 @@
1
1
  'use strict';
2
2
 
3
- var ethers = require('ethers');
4
3
  var utilCrypto = require('@polkadot/util-crypto');
4
+ var ethers = require('ethers');
5
5
  var zod = require('zod');
6
6
  var util = require('@polkadot/util');
7
7
  var axios = require('axios');
@@ -55,10 +55,10 @@ var Assets = arrayToMap([
55
55
  "BTC"
56
56
  ]);
57
57
  var ChainflipNetworks = arrayToMap([
58
+ "partnernet",
58
59
  "sisyphos",
59
60
  "perseverance",
60
- "mainnet",
61
- "partnernet"
61
+ "mainnet"
62
62
  ]);
63
63
  var isTestnet = /* @__PURE__ */ __name((network) => network !== ChainflipNetworks.mainnet, "isTestnet");
64
64
  var assetChains = {
@@ -117,168 +117,593 @@ function assert(condition, message) {
117
117
  __name(assert, "assert");
118
118
  var isTokenSwap = /* @__PURE__ */ __name((params) => params.srcAsset !== Assets.ETH, "isTokenSwap");
119
119
  var isTokenCall = /* @__PURE__ */ __name((params) => params.srcAsset !== Assets.ETH, "isTokenCall");
120
- var _abi = [
121
- {
122
- inputs: [
123
- {
124
- internalType: "address",
125
- name: "owner",
126
- type: "address"
127
- },
128
- {
129
- internalType: "address",
130
- name: "spender",
131
- type: "address"
132
- }
133
- ],
134
- name: "allowance",
135
- outputs: [
136
- {
137
- internalType: "uint256",
138
- name: "",
139
- type: "uint256"
140
- }
141
- ],
142
- stateMutability: "view",
143
- type: "function"
120
+
121
+ // ../shared/src/validation/segwitAddr.ts
122
+ var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
123
+ var GENERATOR = [
124
+ 996825010,
125
+ 642813549,
126
+ 513874426,
127
+ 1027748829,
128
+ 705979059
129
+ ];
130
+ var Encoding;
131
+ (function(Encoding2) {
132
+ Encoding2["Bech32"] = "bech32";
133
+ Encoding2["Bech32m"] = "bech32m";
134
+ })(Encoding || (Encoding = {}));
135
+ var bech32 = {
136
+ getEncodingConst(enc) {
137
+ if (enc === Encoding.Bech32)
138
+ return 1;
139
+ if (enc === Encoding.Bech32m)
140
+ return 734539939;
141
+ return null;
144
142
  },
145
- {
146
- inputs: [
147
- {
148
- internalType: "address",
149
- name: "spender",
150
- type: "address"
151
- },
152
- {
153
- internalType: "uint256",
154
- name: "amount",
155
- type: "uint256"
156
- }
157
- ],
158
- name: "approve",
159
- outputs: [
160
- {
161
- internalType: "bool",
162
- name: "",
163
- type: "bool"
143
+ polymod(values) {
144
+ let chk = 1;
145
+ for (let p = 0; p < values.length; p += 1) {
146
+ const top = chk >> 25;
147
+ chk = (chk & 33554431) << 5 ^ values[p];
148
+ for (let i = 0; i < 5; i += 1) {
149
+ if (top >> i & 1) {
150
+ chk ^= GENERATOR[i];
151
+ }
164
152
  }
165
- ],
166
- stateMutability: "nonpayable",
167
- type: "function"
153
+ }
154
+ return chk;
168
155
  },
169
- {
170
- inputs: [
171
- {
172
- internalType: "address",
173
- name: "account",
174
- type: "address"
156
+ hrpExpand(hrp) {
157
+ const ret = [];
158
+ let p;
159
+ for (p = 0; p < hrp.length; p += 1) {
160
+ ret.push(hrp.charCodeAt(p) >> 5);
161
+ }
162
+ ret.push(0);
163
+ for (p = 0; p < hrp.length; p += 1) {
164
+ ret.push(hrp.charCodeAt(p) & 31);
165
+ }
166
+ return ret;
167
+ },
168
+ verifyChecksum(hrp, data, enc) {
169
+ return this.polymod(this.hrpExpand(hrp).concat(data)) === this.getEncodingConst(enc);
170
+ },
171
+ createChecksum(hrp, data, enc) {
172
+ const values = this.hrpExpand(hrp).concat(data).concat([
173
+ 0,
174
+ 0,
175
+ 0,
176
+ 0,
177
+ 0,
178
+ 0
179
+ ]);
180
+ const mod = this.polymod(values) ^ this.getEncodingConst(enc);
181
+ const ret = [];
182
+ for (let p = 0; p < 6; p += 1) {
183
+ ret.push(mod >> 5 * (5 - p) & 31);
184
+ }
185
+ return ret;
186
+ },
187
+ encode(hrp, data, enc) {
188
+ const combined = data.concat(this.createChecksum(hrp, data, enc));
189
+ let ret = `${hrp}1`;
190
+ for (let p = 0; p < combined.length; p += 1) {
191
+ ret += CHARSET.charAt(combined[p]);
192
+ }
193
+ return ret;
194
+ },
195
+ decode(bechString, enc) {
196
+ let p;
197
+ let hasLower = false;
198
+ let hasUpper = false;
199
+ for (p = 0; p < bechString.length; p += 1) {
200
+ if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126) {
201
+ return null;
175
202
  }
176
- ],
177
- name: "balanceOf",
178
- outputs: [
179
- {
180
- internalType: "uint256",
181
- name: "",
182
- type: "uint256"
203
+ if (bechString.charCodeAt(p) >= 97 && bechString.charCodeAt(p) <= 122) {
204
+ hasLower = true;
183
205
  }
184
- ],
185
- stateMutability: "view",
186
- type: "function"
187
- }
188
- ];
189
- var ERC20__factory = class {
190
- static createInterface() {
191
- return new ethers.utils.Interface(_abi);
192
- }
193
- static connect(address, signerOrProvider) {
194
- return new ethers.Contract(address, _abi, signerOrProvider);
206
+ if (bechString.charCodeAt(p) >= 65 && bechString.charCodeAt(p) <= 90) {
207
+ hasUpper = true;
208
+ }
209
+ }
210
+ if (hasLower && hasUpper)
211
+ return null;
212
+ const lowercase = bechString.toLowerCase();
213
+ const pos = lowercase.lastIndexOf("1");
214
+ if (pos < 1 || pos + 7 > lowercase.length || lowercase.length > 90) {
215
+ return null;
216
+ }
217
+ const hrp = lowercase.substring(0, pos);
218
+ const data = [];
219
+ for (p = pos + 1; p < lowercase.length; p += 1) {
220
+ const d = CHARSET.indexOf(lowercase.charAt(p));
221
+ if (d === -1)
222
+ return null;
223
+ data.push(d);
224
+ }
225
+ if (!this.verifyChecksum(hrp, data, enc)) {
226
+ return null;
227
+ }
228
+ return {
229
+ hrp,
230
+ data: data.slice(0, data.length - 6)
231
+ };
195
232
  }
196
233
  };
197
- __name(ERC20__factory, "ERC20__factory");
198
- __publicField(ERC20__factory, "abi", _abi);
199
- var _abi2 = [
200
- {
201
- inputs: [
202
- {
203
- internalType: "contract IKeyManager",
204
- name: "keyManager",
205
- type: "address"
234
+ var segwitAddress = {
235
+ convertbits(data, frombits, tobits, pad) {
236
+ let acc = 0;
237
+ let bits = 0;
238
+ const ret = [];
239
+ const maxv = (1 << tobits) - 1;
240
+ for (let p = 0; p < data.length; p += 1) {
241
+ const value = data[p];
242
+ if (value < 0 || value >> frombits !== 0) {
243
+ return null;
206
244
  }
207
- ],
208
- stateMutability: "nonpayable",
209
- type: "constructor"
210
- },
211
- {
212
- anonymous: false,
213
- inputs: [
214
- {
215
- indexed: false,
216
- internalType: "bytes32",
217
- name: "swapID",
218
- type: "bytes32"
219
- },
220
- {
221
- indexed: false,
222
- internalType: "uint256",
223
- name: "amount",
224
- type: "uint256"
245
+ acc = acc << frombits | value;
246
+ bits += frombits;
247
+ while (bits >= tobits) {
248
+ bits -= tobits;
249
+ ret.push(acc >> bits & maxv);
225
250
  }
226
- ],
227
- name: "AddGasNative",
228
- type: "event"
229
- },
230
- {
231
- anonymous: false,
232
- inputs: [
233
- {
234
- indexed: false,
235
- internalType: "bytes32",
236
- name: "swapID",
237
- type: "bytes32"
238
- },
239
- {
240
- indexed: false,
241
- internalType: "uint256",
242
- name: "amount",
243
- type: "uint256"
244
- },
245
- {
246
- indexed: false,
247
- internalType: "address",
248
- name: "token",
249
- type: "address"
251
+ }
252
+ if (pad) {
253
+ if (bits > 0) {
254
+ ret.push(acc << tobits - bits & maxv);
250
255
  }
251
- ],
252
- name: "AddGasToken",
253
- type: "event"
256
+ } else if (bits >= frombits || acc << tobits - bits & maxv) {
257
+ return null;
258
+ }
259
+ return ret;
254
260
  },
255
- {
256
- anonymous: false,
257
- inputs: [
258
- {
259
- indexed: false,
260
- internalType: "bool",
261
- name: "communityGuardDisabled",
262
- type: "bool"
263
- }
264
- ],
265
- name: "CommunityGuardDisabled",
266
- type: "event"
261
+ decode(hrp, addr) {
262
+ let bech32m = false;
263
+ let dec = bech32.decode(addr, Encoding.Bech32);
264
+ if (dec === null) {
265
+ dec = bech32.decode(addr, Encoding.Bech32m);
266
+ bech32m = true;
267
+ }
268
+ if (dec === null || dec.hrp !== hrp || dec.data.length < 1 || dec.data[0] > 16) {
269
+ return null;
270
+ }
271
+ const res = this.convertbits(dec.data.slice(1), 5, 8, false);
272
+ if (res === null || res.length < 2 || res.length > 40) {
273
+ return null;
274
+ }
275
+ if (dec.data[0] === 0 && res.length !== 20 && res.length !== 32) {
276
+ return null;
277
+ }
278
+ if (dec.data[0] === 0 && bech32m) {
279
+ return null;
280
+ }
281
+ if (dec.data[0] !== 0 && !bech32m) {
282
+ return null;
283
+ }
284
+ return {
285
+ version: dec.data[0],
286
+ program: res
287
+ };
267
288
  },
289
+ encode(hrp, version, program) {
290
+ let enc = Encoding.Bech32;
291
+ if (version > 0) {
292
+ enc = Encoding.Bech32m;
293
+ }
294
+ const ret = bech32.encode(
295
+ hrp,
296
+ // @ts-expect-error can be null
297
+ [
298
+ version
299
+ ].concat(this.convertbits(program, 8, 5, true)),
300
+ enc
301
+ );
302
+ if (this.decode(hrp, ret) === null) {
303
+ return null;
304
+ }
305
+ return ret;
306
+ }
307
+ };
308
+ var isValidSegwitAddress = /* @__PURE__ */ __name((address) => {
309
+ const hrp = /^(bc|tb|bcrt)1/.exec(address)?.[1];
310
+ if (!hrp)
311
+ return false;
312
+ return segwitAddress.decode(hrp, address) !== null;
313
+ }, "isValidSegwitAddress");
314
+
315
+ // ../shared/src/validation/addressValidation.ts
316
+ var assertArraylikeEqual = /* @__PURE__ */ __name((a, b) => {
317
+ assert(a.length === b.length, "arraylike lengths must be equal");
318
+ for (let i = 0; i < a.length; i += 1) {
319
+ assert(a[i] === b[i], "arraylike elements must be equal");
320
+ }
321
+ }, "assertArraylikeEqual");
322
+ var validateP2PKHOrP2SHAddress = /* @__PURE__ */ __name((address, network) => {
323
+ try {
324
+ const decoded = ethers__namespace.utils.base58.decode(address);
325
+ assert(decoded.length === 25, "decoded address must be 25 bytes long");
326
+ if (network === "mainnet") {
327
+ assert(decoded[0] === 0 || decoded[0] === 5, "decoded address must start with 0x00 or 0x05");
328
+ } else {
329
+ assert(decoded[0] === 111 || decoded[0] === 196, "decoded address must start with 0x6f or 0xc4");
330
+ }
331
+ const checksum = decoded.slice(-4);
332
+ const doubleHash = ethers__namespace.utils.arrayify(ethers__namespace.utils.sha256(ethers__namespace.utils.sha256(decoded.slice(0, 21))));
333
+ assertArraylikeEqual(checksum, doubleHash.slice(0, 4));
334
+ return true;
335
+ } catch (error) {
336
+ return false;
337
+ }
338
+ }, "validateP2PKHOrP2SHAddress");
339
+ var validateSegwitAddress = /* @__PURE__ */ __name((address, network) => {
340
+ try {
341
+ assert(
342
+ // On mainnet, the address must start with "bc1"
343
+ network === "mainnet" && address.startsWith("bc1") || // on testnet it must start with "tb1"
344
+ network === "testnet" && address.startsWith("tb1") || // on regtest it must start with "bcrt1"
345
+ network === "regtest" && address.startsWith("bcrt1"),
346
+ "address must start with bc1, tb1 or bcrt1"
347
+ );
348
+ return isValidSegwitAddress(address);
349
+ } catch {
350
+ return false;
351
+ }
352
+ }, "validateSegwitAddress");
353
+ var validateBitcoinAddress = /* @__PURE__ */ __name((address, network) => validateP2PKHOrP2SHAddress(address, network) || validateSegwitAddress(address, network), "validateBitcoinAddress");
354
+ var validateBitcoinMainnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "mainnet"), "validateBitcoinMainnetAddress");
355
+ var validateBitcoinTestnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "testnet"), "validateBitcoinTestnetAddress");
356
+ var validateBitcoinRegtestAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "regtest"), "validateBitcoinRegtestAddress");
357
+
358
+ // ../shared/src/parsers.ts
359
+ var errorMap = /* @__PURE__ */ __name((_issue, context) => ({
360
+ message: `received: ${JSON.stringify(context.data)}`
361
+ }), "errorMap");
362
+ var string = zod.z.string({
363
+ errorMap
364
+ });
365
+ zod.z.number({
366
+ errorMap
367
+ });
368
+ var numericString = string.regex(/^[0-9]+$/);
369
+ var hexString = zod.z.custom((val) => typeof val === "string" && /^0x[0-9a-f]+$/i.test(val));
370
+ numericString.transform((arg) => ethers__namespace.BigNumber.from(arg).toHexString()).refine((arg) => arg.startsWith("0x"));
371
+ string.regex(/^[0-9a-f]+$/);
372
+ var btcAddress = /* @__PURE__ */ __name((env) => {
373
+ const network = env ?? process.env.CHAINFLIP_NETWORK;
374
+ if (network === "mainnet")
375
+ return string.regex(/^(1|3|bc1)/).refine(validateBitcoinMainnetAddress);
376
+ return zod.z.union([
377
+ string.regex(/^(m|n|2|tb1)/).refine(validateBitcoinTestnetAddress),
378
+ string.regex(/^bcrt1/).refine(validateBitcoinRegtestAddress)
379
+ ]);
380
+ }, "btcAddress");
381
+ var dotAddress = zod.z.union([
382
+ string,
383
+ hexString
384
+ ]).transform((arg) => {
385
+ try {
386
+ if (arg.startsWith("0x")) {
387
+ return utilCrypto.encodeAddress(util.hexToU8a(arg));
388
+ }
389
+ utilCrypto.decodeAddress(arg);
390
+ return arg;
391
+ } catch {
392
+ return null;
393
+ }
394
+ }).refine(isString);
395
+ var ethereumAddress = hexString.refine((address) => ethers__namespace.utils.isAddress(address));
396
+ numericString.transform((arg) => BigInt(arg));
397
+ var u128 = zod.z.union([
398
+ numericString,
399
+ hexString
400
+ ]).transform((arg) => BigInt(arg));
401
+ var unsignedInteger = zod.z.union([
402
+ u128,
403
+ zod.z.number().transform((n) => BigInt(n))
404
+ ]);
405
+ zod.z.object({
406
+ __kind: zod.z.enum([
407
+ "Usdc",
408
+ "Flip",
409
+ "Dot",
410
+ "Eth",
411
+ "Btc"
412
+ ])
413
+ }).transform(({ __kind }) => __kind.toUpperCase());
414
+ zod.z.nativeEnum(Chains);
415
+ zod.z.nativeEnum(Assets);
416
+ var chainflipNetwork = zod.z.nativeEnum(ChainflipNetworks);
417
+ zod.z.union([
418
+ zod.z.object({
419
+ __kind: zod.z.literal("CcmPrincipal"),
420
+ value: unsignedInteger
421
+ }).transform(({ value: ccmId }) => ({
422
+ type: "PRINCIPAL",
423
+ ccmId
424
+ })),
425
+ zod.z.object({
426
+ __kind: zod.z.literal("CcmGas"),
427
+ value: unsignedInteger
428
+ }).transform(({ value: ccmId }) => ({
429
+ type: "GAS",
430
+ ccmId
431
+ })),
432
+ zod.z.object({
433
+ __kind: zod.z.literal("Swap")
434
+ }).transform(() => ({
435
+ type: "SWAP"
436
+ }))
437
+ ]);
438
+
439
+ // ../shared/src/vault/schemas.ts
440
+ var bytesToHex = /* @__PURE__ */ __name((arr) => `0x${[
441
+ ...arr
442
+ ].map((v) => v.toString(16).padStart(2, "0")).join("")}`, "bytesToHex");
443
+ var utf8ToHex = /* @__PURE__ */ __name((str) => `0x${Buffer.from(str).toString("hex")}`, "utf8ToHex");
444
+ var eth = zod.z.object({
445
+ amount: zod.z.union([
446
+ numericString,
447
+ hexString,
448
+ zod.z.bigint()
449
+ ]),
450
+ srcChain: zod.z.literal(Chains.Ethereum),
451
+ srcAsset: zod.z.literal(Assets.ETH)
452
+ });
453
+ var ethToEthereum = eth.extend({
454
+ destChain: zod.z.literal(Chains.Ethereum),
455
+ destAddress: ethereumAddress
456
+ });
457
+ var ethToDot = eth.extend({
458
+ destChain: zod.z.literal(Chains.Polkadot),
459
+ destAddress: dotAddress.transform((addr) => bytesToHex(utilCrypto.decodeAddress(addr))),
460
+ destAsset: zod.z.literal(Assets.DOT)
461
+ });
462
+ var ethToBtc = eth.extend({
463
+ destChain: zod.z.literal(Chains.Bitcoin),
464
+ destAddress: btcAddress().transform(utf8ToHex),
465
+ destAsset: zod.z.literal(Assets.BTC)
466
+ });
467
+ var erc20Asset = zod.z.union([
468
+ zod.z.literal(Assets.FLIP),
469
+ zod.z.literal(Assets.USDC)
470
+ ]);
471
+ var ethToERC20 = ethToEthereum.extend({
472
+ destAsset: erc20Asset
473
+ });
474
+ var nativeSwapParamsSchema = zod.z.union([
475
+ ethToERC20,
476
+ ethToDot,
477
+ ethToBtc
478
+ ]);
479
+ var flipToEthereumAsset = ethToEthereum.extend({
480
+ srcAsset: zod.z.literal(Assets.FLIP),
481
+ destAsset: zod.z.union([
482
+ zod.z.literal(Assets.USDC),
483
+ zod.z.literal(Assets.ETH)
484
+ ])
485
+ });
486
+ var usdcToEthereumAsset = ethToEthereum.extend({
487
+ srcAsset: zod.z.literal(Assets.USDC),
488
+ destAsset: zod.z.union([
489
+ zod.z.literal(Assets.FLIP),
490
+ zod.z.literal(Assets.ETH)
491
+ ])
492
+ });
493
+ var erc20ToDot = ethToDot.extend({
494
+ srcAsset: erc20Asset
495
+ });
496
+ var erc20ToBtc = ethToBtc.extend({
497
+ srcAsset: erc20Asset
498
+ });
499
+ var tokenSwapParamsSchema = zod.z.union([
500
+ flipToEthereumAsset,
501
+ usdcToEthereumAsset,
502
+ erc20ToDot,
503
+ erc20ToBtc
504
+ ]);
505
+ var ccmMetadataSchema = zod.z.object({
506
+ message: zod.z.string(),
507
+ gasBudget: numericString
508
+ });
509
+ var ccmFlipToEthereumAssset = flipToEthereumAsset.extend({
510
+ ccmMetadata: ccmMetadataSchema
511
+ });
512
+ var ccmUsdcToEthereumAsset = usdcToEthereumAsset.extend({
513
+ ccmMetadata: ccmMetadataSchema
514
+ });
515
+ var tokenCallParamsSchema = zod.z.union([
516
+ ccmFlipToEthereumAssset,
517
+ ccmUsdcToEthereumAsset
518
+ ]);
519
+ var nativeCallParamsSchema = ethToERC20.extend({
520
+ ccmMetadata: ccmMetadataSchema
521
+ });
522
+ var executeSwapParamsSchema = zod.z.union([
523
+ // call schemas needs to precede swap schemas
524
+ nativeCallParamsSchema,
525
+ tokenCallParamsSchema,
526
+ nativeSwapParamsSchema,
527
+ tokenSwapParamsSchema
528
+ ]);
529
+ var stripOverrides = /* @__PURE__ */ __name((obj) => {
530
+ const { to, from, value, data, ...rest } = obj;
531
+ return rest;
532
+ }, "stripOverrides");
533
+ var executeOptionsSchema = zod.z.intersection(zod.z.object({
534
+ signer: zod.z.instanceof(ethers.Signer)
535
+ }).passthrough(), zod.z.union([
536
+ zod.z.object({
537
+ network: chainflipNetwork
538
+ }).passthrough(),
539
+ zod.z.object({
540
+ network: zod.z.literal("localnet"),
541
+ vaultContractAddress: zod.z.string(),
542
+ srcTokenContractAddress: zod.z.string().optional()
543
+ }).passthrough()
544
+ ])).transform(stripOverrides);
545
+ var _abi = [
268
546
  {
269
- anonymous: false,
270
547
  inputs: [
271
548
  {
272
- indexed: true,
273
- internalType: "address payable",
274
- name: "multicallAddress",
549
+ internalType: "address",
550
+ name: "owner",
275
551
  type: "address"
276
552
  },
277
553
  {
278
- indexed: false,
279
- internalType: "uint256",
280
- name: "amount",
281
- type: "uint256"
554
+ internalType: "address",
555
+ name: "spender",
556
+ type: "address"
557
+ }
558
+ ],
559
+ name: "allowance",
560
+ outputs: [
561
+ {
562
+ internalType: "uint256",
563
+ name: "",
564
+ type: "uint256"
565
+ }
566
+ ],
567
+ stateMutability: "view",
568
+ type: "function"
569
+ },
570
+ {
571
+ inputs: [
572
+ {
573
+ internalType: "address",
574
+ name: "spender",
575
+ type: "address"
576
+ },
577
+ {
578
+ internalType: "uint256",
579
+ name: "amount",
580
+ type: "uint256"
581
+ }
582
+ ],
583
+ name: "approve",
584
+ outputs: [
585
+ {
586
+ internalType: "bool",
587
+ name: "",
588
+ type: "bool"
589
+ }
590
+ ],
591
+ stateMutability: "nonpayable",
592
+ type: "function"
593
+ },
594
+ {
595
+ inputs: [
596
+ {
597
+ internalType: "address",
598
+ name: "account",
599
+ type: "address"
600
+ }
601
+ ],
602
+ name: "balanceOf",
603
+ outputs: [
604
+ {
605
+ internalType: "uint256",
606
+ name: "",
607
+ type: "uint256"
608
+ }
609
+ ],
610
+ stateMutability: "view",
611
+ type: "function"
612
+ }
613
+ ];
614
+ var ERC20__factory = class {
615
+ static createInterface() {
616
+ return new ethers.utils.Interface(_abi);
617
+ }
618
+ static connect(address, signerOrProvider) {
619
+ return new ethers.Contract(address, _abi, signerOrProvider);
620
+ }
621
+ };
622
+ __name(ERC20__factory, "ERC20__factory");
623
+ __publicField(ERC20__factory, "abi", _abi);
624
+ var _abi2 = [
625
+ {
626
+ inputs: [
627
+ {
628
+ internalType: "contract IKeyManager",
629
+ name: "keyManager",
630
+ type: "address"
631
+ }
632
+ ],
633
+ stateMutability: "nonpayable",
634
+ type: "constructor"
635
+ },
636
+ {
637
+ anonymous: false,
638
+ inputs: [
639
+ {
640
+ indexed: false,
641
+ internalType: "bytes32",
642
+ name: "swapID",
643
+ type: "bytes32"
644
+ },
645
+ {
646
+ indexed: false,
647
+ internalType: "uint256",
648
+ name: "amount",
649
+ type: "uint256"
650
+ }
651
+ ],
652
+ name: "AddGasNative",
653
+ type: "event"
654
+ },
655
+ {
656
+ anonymous: false,
657
+ inputs: [
658
+ {
659
+ indexed: false,
660
+ internalType: "bytes32",
661
+ name: "swapID",
662
+ type: "bytes32"
663
+ },
664
+ {
665
+ indexed: false,
666
+ internalType: "uint256",
667
+ name: "amount",
668
+ type: "uint256"
669
+ },
670
+ {
671
+ indexed: false,
672
+ internalType: "address",
673
+ name: "token",
674
+ type: "address"
675
+ }
676
+ ],
677
+ name: "AddGasToken",
678
+ type: "event"
679
+ },
680
+ {
681
+ anonymous: false,
682
+ inputs: [
683
+ {
684
+ indexed: false,
685
+ internalType: "bool",
686
+ name: "communityGuardDisabled",
687
+ type: "bool"
688
+ }
689
+ ],
690
+ name: "CommunityGuardDisabled",
691
+ type: "event"
692
+ },
693
+ {
694
+ anonymous: false,
695
+ inputs: [
696
+ {
697
+ indexed: true,
698
+ internalType: "address payable",
699
+ name: "multicallAddress",
700
+ type: "address"
701
+ },
702
+ {
703
+ indexed: false,
704
+ internalType: "uint256",
705
+ name: "amount",
706
+ type: "uint256"
282
707
  },
283
708
  {
284
709
  indexed: true,
@@ -1389,516 +1814,110 @@ var _abi2 = [
1389
1814
  type: "address"
1390
1815
  },
1391
1816
  {
1392
- internalType: "uint256",
1393
- name: "amount",
1394
- type: "uint256"
1395
- },
1396
- {
1397
- internalType: "bytes",
1398
- name: "cfParameters",
1399
- type: "bytes"
1400
- }
1401
- ],
1402
- name: "xSwapToken",
1403
- outputs: [],
1404
- stateMutability: "nonpayable",
1405
- type: "function"
1406
- },
1407
- {
1408
- stateMutability: "payable",
1409
- type: "receive"
1410
- }
1411
- ];
1412
- var Vault__factory = class {
1413
- static createInterface() {
1414
- return new ethers.utils.Interface(_abi2);
1415
- }
1416
- static connect(address, signerOrProvider) {
1417
- return new ethers.Contract(address, _abi2, signerOrProvider);
1418
- }
1419
- };
1420
- __name(Vault__factory, "Vault__factory");
1421
- __publicField(Vault__factory, "abi", _abi2);
1422
-
1423
- // ../shared/src/consts.ts
1424
- var ADDRESSES = {
1425
- [ChainflipNetworks.sisyphos]: {
1426
- FLIP_CONTRACT_ADDRESS: "0x2FD78122663A07672e9ac63486573A99EB00125d",
1427
- VAULT_CONTRACT_ADDRESS: "0xd498606dcb9F440CD9F06B397C40fd3327FC2550",
1428
- STATE_CHAIN_MANAGER_CONTRACT_ADDRESS: "0xCCF267Bc5B709F1A1738122f3b76Cd01F0d9f947"
1429
- },
1430
- [ChainflipNetworks.partnernet]: {
1431
- FLIP_CONTRACT_ADDRESS: "0x1Ea4F05a319A8f779F05E153974605756bB13D4F",
1432
- VAULT_CONTRACT_ADDRESS: "0xAfD0C34E6d25F707d931F8b7EE9cf0Ff52160A46",
1433
- STATE_CHAIN_MANAGER_CONTRACT_ADDRESS: "0x07B3Bef16c640B072085BF83C24b6C43000aE056"
1434
- },
1435
- [ChainflipNetworks.perseverance]: {
1436
- FLIP_CONTRACT_ADDRESS: "0x1194C91d47Fc1b65bE18db38380B5344682b67db",
1437
- VAULT_CONTRACT_ADDRESS: "0xF1B061aCCDAa4B7c029128b49aBc047F89D5CB8d",
1438
- STATE_CHAIN_MANAGER_CONTRACT_ADDRESS: "0xC960C4eEe4ADf40d24374D85094f3219cf2DD8EB"
1439
- }
1440
- };
1441
- var GOERLI_USDC_CONTRACT_ADDRESS = "0x07865c6E87B9F70255377e024ace6630C1Eaa37F";
1442
-
1443
- // ../shared/src/contracts.ts
1444
- var getTokenContractAddress = /* @__PURE__ */ __name((asset, network) => {
1445
- assert(network !== ChainflipNetworks.mainnet, "Mainnet is not yet supported");
1446
- if (asset === Assets.FLIP)
1447
- return ADDRESSES[network].FLIP_CONTRACT_ADDRESS;
1448
- assert(asset === Assets.USDC, "Only FLIP and USDC are supported for now");
1449
- return GOERLI_USDC_CONTRACT_ADDRESS;
1450
- }, "getTokenContractAddress");
1451
- var checkAllowance = /* @__PURE__ */ __name(async (amount, spenderAddress, erc20Address, signer) => {
1452
- const erc202 = ERC20__factory.connect(erc20Address, signer);
1453
- const signerAddress = await signer.getAddress();
1454
- const allowance = await erc202.allowance(signerAddress, spenderAddress);
1455
- return {
1456
- allowance,
1457
- isAllowable: allowance.gte(amount),
1458
- erc20: erc202
1459
- };
1460
- }, "checkAllowance");
1461
- var approve = /* @__PURE__ */ __name(async (amount, spenderAddress, erc202, allowance, nonce) => {
1462
- const amountBigNumber = ethers.BigNumber.from(amount);
1463
- const allowanceBigNumber = ethers.BigNumber.from(allowance);
1464
- if (allowanceBigNumber.gte(amountBigNumber))
1465
- return null;
1466
- const requiredAmount = amountBigNumber.sub(allowanceBigNumber);
1467
- const tx = await erc202.approve(spenderAddress, requiredAmount, {
1468
- nonce
1469
- });
1470
- return tx.wait(1);
1471
- }, "approve");
1472
- var getVaultManagerContractAddress = /* @__PURE__ */ __name((network) => {
1473
- assert(network !== ChainflipNetworks.mainnet, "Mainnet is not yet supported");
1474
- return ADDRESSES[network].VAULT_CONTRACT_ADDRESS;
1475
- }, "getVaultManagerContractAddress");
1476
-
1477
- // ../shared/src/validation/segwitAddr.ts
1478
- var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
1479
- var GENERATOR = [
1480
- 996825010,
1481
- 642813549,
1482
- 513874426,
1483
- 1027748829,
1484
- 705979059
1485
- ];
1486
- var Encoding;
1487
- (function(Encoding2) {
1488
- Encoding2["Bech32"] = "bech32";
1489
- Encoding2["Bech32m"] = "bech32m";
1490
- })(Encoding || (Encoding = {}));
1491
- var bech32 = {
1492
- getEncodingConst(enc) {
1493
- if (enc === Encoding.Bech32)
1494
- return 1;
1495
- if (enc === Encoding.Bech32m)
1496
- return 734539939;
1497
- return null;
1498
- },
1499
- polymod(values) {
1500
- let chk = 1;
1501
- for (let p = 0; p < values.length; p += 1) {
1502
- const top = chk >> 25;
1503
- chk = (chk & 33554431) << 5 ^ values[p];
1504
- for (let i = 0; i < 5; i += 1) {
1505
- if (top >> i & 1) {
1506
- chk ^= GENERATOR[i];
1507
- }
1508
- }
1509
- }
1510
- return chk;
1511
- },
1512
- hrpExpand(hrp) {
1513
- const ret = [];
1514
- let p;
1515
- for (p = 0; p < hrp.length; p += 1) {
1516
- ret.push(hrp.charCodeAt(p) >> 5);
1517
- }
1518
- ret.push(0);
1519
- for (p = 0; p < hrp.length; p += 1) {
1520
- ret.push(hrp.charCodeAt(p) & 31);
1521
- }
1522
- return ret;
1523
- },
1524
- verifyChecksum(hrp, data, enc) {
1525
- return this.polymod(this.hrpExpand(hrp).concat(data)) === this.getEncodingConst(enc);
1526
- },
1527
- createChecksum(hrp, data, enc) {
1528
- const values = this.hrpExpand(hrp).concat(data).concat([
1529
- 0,
1530
- 0,
1531
- 0,
1532
- 0,
1533
- 0,
1534
- 0
1535
- ]);
1536
- const mod = this.polymod(values) ^ this.getEncodingConst(enc);
1537
- const ret = [];
1538
- for (let p = 0; p < 6; p += 1) {
1539
- ret.push(mod >> 5 * (5 - p) & 31);
1540
- }
1541
- return ret;
1542
- },
1543
- encode(hrp, data, enc) {
1544
- const combined = data.concat(this.createChecksum(hrp, data, enc));
1545
- let ret = `${hrp}1`;
1546
- for (let p = 0; p < combined.length; p += 1) {
1547
- ret += CHARSET.charAt(combined[p]);
1548
- }
1549
- return ret;
1550
- },
1551
- decode(bechString, enc) {
1552
- let p;
1553
- let hasLower = false;
1554
- let hasUpper = false;
1555
- for (p = 0; p < bechString.length; p += 1) {
1556
- if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126) {
1557
- return null;
1558
- }
1559
- if (bechString.charCodeAt(p) >= 97 && bechString.charCodeAt(p) <= 122) {
1560
- hasLower = true;
1561
- }
1562
- if (bechString.charCodeAt(p) >= 65 && bechString.charCodeAt(p) <= 90) {
1563
- hasUpper = true;
1564
- }
1565
- }
1566
- if (hasLower && hasUpper)
1567
- return null;
1568
- const lowercase = bechString.toLowerCase();
1569
- const pos = lowercase.lastIndexOf("1");
1570
- if (pos < 1 || pos + 7 > lowercase.length || lowercase.length > 90) {
1571
- return null;
1572
- }
1573
- const hrp = lowercase.substring(0, pos);
1574
- const data = [];
1575
- for (p = pos + 1; p < lowercase.length; p += 1) {
1576
- const d = CHARSET.indexOf(lowercase.charAt(p));
1577
- if (d === -1)
1578
- return null;
1579
- data.push(d);
1580
- }
1581
- if (!this.verifyChecksum(hrp, data, enc)) {
1582
- return null;
1583
- }
1584
- return {
1585
- hrp,
1586
- data: data.slice(0, data.length - 6)
1587
- };
1588
- }
1589
- };
1590
- var segwitAddress = {
1591
- convertbits(data, frombits, tobits, pad) {
1592
- let acc = 0;
1593
- let bits = 0;
1594
- const ret = [];
1595
- const maxv = (1 << tobits) - 1;
1596
- for (let p = 0; p < data.length; p += 1) {
1597
- const value = data[p];
1598
- if (value < 0 || value >> frombits !== 0) {
1599
- return null;
1600
- }
1601
- acc = acc << frombits | value;
1602
- bits += frombits;
1603
- while (bits >= tobits) {
1604
- bits -= tobits;
1605
- ret.push(acc >> bits & maxv);
1606
- }
1607
- }
1608
- if (pad) {
1609
- if (bits > 0) {
1610
- ret.push(acc << tobits - bits & maxv);
1611
- }
1612
- } else if (bits >= frombits || acc << tobits - bits & maxv) {
1613
- return null;
1614
- }
1615
- return ret;
1616
- },
1617
- decode(hrp, addr) {
1618
- let bech32m = false;
1619
- let dec = bech32.decode(addr, Encoding.Bech32);
1620
- if (dec === null) {
1621
- dec = bech32.decode(addr, Encoding.Bech32m);
1622
- bech32m = true;
1623
- }
1624
- if (dec === null || dec.hrp !== hrp || dec.data.length < 1 || dec.data[0] > 16) {
1625
- return null;
1626
- }
1627
- const res = this.convertbits(dec.data.slice(1), 5, 8, false);
1628
- if (res === null || res.length < 2 || res.length > 40) {
1629
- return null;
1630
- }
1631
- if (dec.data[0] === 0 && res.length !== 20 && res.length !== 32) {
1632
- return null;
1633
- }
1634
- if (dec.data[0] === 0 && bech32m) {
1635
- return null;
1636
- }
1637
- if (dec.data[0] !== 0 && !bech32m) {
1638
- return null;
1639
- }
1640
- return {
1641
- version: dec.data[0],
1642
- program: res
1643
- };
1644
- },
1645
- encode(hrp, version, program) {
1646
- let enc = Encoding.Bech32;
1647
- if (version > 0) {
1648
- enc = Encoding.Bech32m;
1649
- }
1650
- const ret = bech32.encode(
1651
- hrp,
1652
- // @ts-expect-error can be null
1653
- [
1654
- version
1655
- ].concat(this.convertbits(program, 8, 5, true)),
1656
- enc
1657
- );
1658
- if (this.decode(hrp, ret) === null) {
1659
- return null;
1660
- }
1661
- return ret;
1817
+ internalType: "uint256",
1818
+ name: "amount",
1819
+ type: "uint256"
1820
+ },
1821
+ {
1822
+ internalType: "bytes",
1823
+ name: "cfParameters",
1824
+ type: "bytes"
1825
+ }
1826
+ ],
1827
+ name: "xSwapToken",
1828
+ outputs: [],
1829
+ stateMutability: "nonpayable",
1830
+ type: "function"
1831
+ },
1832
+ {
1833
+ stateMutability: "payable",
1834
+ type: "receive"
1835
+ }
1836
+ ];
1837
+ var Vault__factory = class {
1838
+ static createInterface() {
1839
+ return new ethers.utils.Interface(_abi2);
1840
+ }
1841
+ static connect(address, signerOrProvider) {
1842
+ return new ethers.Contract(address, _abi2, signerOrProvider);
1662
1843
  }
1663
1844
  };
1664
- var isValidSegwitAddress = /* @__PURE__ */ __name((address) => {
1665
- const hrp = /^(bc|tb|bcrt)1/.exec(address)?.[1];
1666
- if (!hrp)
1667
- return false;
1668
- return segwitAddress.decode(hrp, address) !== null;
1669
- }, "isValidSegwitAddress");
1845
+ __name(Vault__factory, "Vault__factory");
1846
+ __publicField(Vault__factory, "abi", _abi2);
1670
1847
 
1671
- // ../shared/src/validation/addressValidation.ts
1672
- var assertArraylikeEqual = /* @__PURE__ */ __name((a, b) => {
1673
- assert(a.length === b.length, "arraylike lengths must be equal");
1674
- for (let i = 0; i < a.length; i += 1) {
1675
- assert(a[i] === b[i], "arraylike elements must be equal");
1848
+ // ../shared/src/consts.ts
1849
+ var MINIMUM_DEPOSIT_AMOUNTS = {
1850
+ [ChainflipNetworks.partnernet]: {
1851
+ [Assets.ETH]: "0",
1852
+ [Assets.FLIP]: "0",
1853
+ [Assets.USDC]: "0",
1854
+ [Assets.BTC]: "0",
1855
+ [Assets.DOT]: "0"
1676
1856
  }
1677
- }, "assertArraylikeEqual");
1678
- var validateP2PKHOrP2SHAddress = /* @__PURE__ */ __name((address, network) => {
1679
- try {
1680
- const decoded = ethers__namespace.utils.base58.decode(address);
1681
- assert(decoded.length === 25, "decoded address must be 25 bytes long");
1682
- if (network === "mainnet") {
1683
- assert(decoded[0] === 0 || decoded[0] === 5, "decoded address must start with 0x00 or 0x05");
1684
- } else {
1685
- assert(decoded[0] === 111 || decoded[0] === 196, "decoded address must start with 0x6f or 0xc4");
1686
- }
1687
- const checksum = decoded.slice(-4);
1688
- const doubleHash = ethers__namespace.utils.arrayify(ethers__namespace.utils.sha256(ethers__namespace.utils.sha256(decoded.slice(0, 21))));
1689
- assertArraylikeEqual(checksum, doubleHash.slice(0, 4));
1690
- return true;
1691
- } catch (error) {
1692
- return false;
1857
+ };
1858
+ var getMinimumDepositAmount = /* @__PURE__ */ __name((network, asset) => MINIMUM_DEPOSIT_AMOUNTS[network]?.[asset] ?? "0", "getMinimumDepositAmount");
1859
+ var MINIMUM_SWAP_AMOUNTS = {
1860
+ [ChainflipNetworks.partnernet]: {
1861
+ [Assets.ETH]: "580000000000000",
1862
+ [Assets.FLIP]: "1000000000000000000",
1863
+ [Assets.USDC]: "1000000",
1864
+ [Assets.BTC]: "390000",
1865
+ [Assets.DOT]: "2000000000"
1693
1866
  }
1694
- }, "validateP2PKHOrP2SHAddress");
1695
- var validateSegwitAddress = /* @__PURE__ */ __name((address, network) => {
1696
- try {
1697
- assert(
1698
- // On mainnet, the address must start with "bc1"
1699
- network === "mainnet" && address.startsWith("bc1") || // on testnet it must start with "tb1"
1700
- network === "testnet" && address.startsWith("tb1") || // on regtest it must start with "bcrt1"
1701
- network === "regtest" && address.startsWith("bcrt1"),
1702
- "address must start with bc1, tb1 or bcrt1"
1703
- );
1704
- return isValidSegwitAddress(address);
1705
- } catch {
1706
- return false;
1867
+ };
1868
+ var getMinimumSwapAmount = /* @__PURE__ */ __name((network, asset) => MINIMUM_SWAP_AMOUNTS[network]?.[asset] ?? "0", "getMinimumSwapAmount");
1869
+ var ADDRESSES = {
1870
+ [ChainflipNetworks.sisyphos]: {
1871
+ FLIP_CONTRACT_ADDRESS: "0x2FD78122663A07672e9ac63486573A99EB00125d",
1872
+ VAULT_CONTRACT_ADDRESS: "0xd498606dcb9F440CD9F06B397C40fd3327FC2550",
1873
+ STATE_CHAIN_MANAGER_CONTRACT_ADDRESS: "0xCCF267Bc5B709F1A1738122f3b76Cd01F0d9f947"
1874
+ },
1875
+ [ChainflipNetworks.partnernet]: {
1876
+ FLIP_CONTRACT_ADDRESS: "0x1Ea4F05a319A8f779F05E153974605756bB13D4F",
1877
+ VAULT_CONTRACT_ADDRESS: "0xAfD0C34E6d25F707d931F8b7EE9cf0Ff52160A46",
1878
+ STATE_CHAIN_MANAGER_CONTRACT_ADDRESS: "0x07B3Bef16c640B072085BF83C24b6C43000aE056"
1879
+ },
1880
+ [ChainflipNetworks.perseverance]: {
1881
+ FLIP_CONTRACT_ADDRESS: "0x1194C91d47Fc1b65bE18db38380B5344682b67db",
1882
+ VAULT_CONTRACT_ADDRESS: "0xF1B061aCCDAa4B7c029128b49aBc047F89D5CB8d",
1883
+ STATE_CHAIN_MANAGER_CONTRACT_ADDRESS: "0xC960C4eEe4ADf40d24374D85094f3219cf2DD8EB"
1707
1884
  }
1708
- }, "validateSegwitAddress");
1709
- var validateBitcoinAddress = /* @__PURE__ */ __name((address, network) => validateP2PKHOrP2SHAddress(address, network) || validateSegwitAddress(address, network), "validateBitcoinAddress");
1710
- var validateBitcoinMainnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "mainnet"), "validateBitcoinMainnetAddress");
1711
- var validateBitcoinTestnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "testnet"), "validateBitcoinTestnetAddress");
1712
- var validateBitcoinRegtestAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "regtest"), "validateBitcoinRegtestAddress");
1885
+ };
1886
+ var GOERLI_USDC_CONTRACT_ADDRESS = "0x07865c6E87B9F70255377e024ace6630C1Eaa37F";
1713
1887
 
1714
- // ../shared/src/parsers.ts
1715
- var errorMap = /* @__PURE__ */ __name((issue, context) => ({
1716
- message: `received: ${JSON.stringify(context.data)}`
1717
- }), "errorMap");
1718
- var string = zod.z.string({
1719
- errorMap
1720
- });
1721
- zod.z.number({
1722
- errorMap
1723
- });
1724
- var numericString = string.regex(/^[0-9]+$/);
1725
- var hexString = zod.z.custom((val) => typeof val === "string" && /^0x[0-9a-f]+$/i.test(val));
1726
- numericString.transform((arg) => ethers__namespace.BigNumber.from(arg).toHexString()).refine((arg) => arg.startsWith("0x"));
1727
- string.regex(/^[0-9a-f]+$/);
1728
- var btcAddress = zod.z.union([
1729
- string.regex(/^(1|3|bc1)/).refine(validateBitcoinMainnetAddress),
1730
- string.regex(/^(m|n|2|tb1)/).refine(validateBitcoinTestnetAddress),
1731
- string.regex(/^bcrt1/).refine(validateBitcoinRegtestAddress)
1732
- ]);
1733
- var dotAddress = zod.z.union([
1734
- string,
1735
- hexString
1736
- ]).transform((arg) => {
1737
- try {
1738
- if (arg.startsWith("0x")) {
1739
- return utilCrypto.encodeAddress(util.hexToU8a(arg));
1740
- }
1741
- utilCrypto.decodeAddress(arg);
1742
- return arg;
1743
- } catch {
1888
+ // ../shared/src/contracts.ts
1889
+ var getTokenContractAddress = /* @__PURE__ */ __name((asset, network) => {
1890
+ assert(network !== ChainflipNetworks.mainnet, "Mainnet is not yet supported");
1891
+ if (asset === Assets.FLIP)
1892
+ return ADDRESSES[network].FLIP_CONTRACT_ADDRESS;
1893
+ assert(asset === Assets.USDC, "Only FLIP and USDC are supported for now");
1894
+ return GOERLI_USDC_CONTRACT_ADDRESS;
1895
+ }, "getTokenContractAddress");
1896
+ var checkAllowance = /* @__PURE__ */ __name(async (amount, spenderAddress, erc20Address, signer) => {
1897
+ const erc20 = ERC20__factory.connect(erc20Address, signer);
1898
+ const signerAddress = await signer.getAddress();
1899
+ const allowance = await erc20.allowance(signerAddress, spenderAddress);
1900
+ return {
1901
+ allowance,
1902
+ isAllowable: allowance.gte(amount),
1903
+ erc20
1904
+ };
1905
+ }, "checkAllowance");
1906
+ var approve = /* @__PURE__ */ __name(async (amount, spenderAddress, erc20, allowance, nonce) => {
1907
+ const amountBigNumber = ethers.BigNumber.from(amount);
1908
+ const allowanceBigNumber = ethers.BigNumber.from(allowance);
1909
+ if (allowanceBigNumber.gte(amountBigNumber))
1744
1910
  return null;
1745
- }
1746
- }).refine(isString);
1747
- var ethereumAddress = hexString.refine((address) => ethers__namespace.utils.isAddress(address));
1748
- numericString.transform((arg) => BigInt(arg));
1749
- var u128 = zod.z.union([
1750
- numericString,
1751
- hexString
1752
- ]).transform((arg) => BigInt(arg));
1753
- var unsignedInteger = zod.z.union([
1754
- u128,
1755
- zod.z.number().transform((n) => BigInt(n))
1756
- ]);
1757
- zod.z.object({
1758
- __kind: zod.z.enum([
1759
- "Usdc",
1760
- "Flip",
1761
- "Dot",
1762
- "Eth",
1763
- "Btc"
1764
- ])
1765
- }).transform(({ __kind }) => __kind.toUpperCase());
1766
- zod.z.nativeEnum(Chains);
1767
- zod.z.nativeEnum(Assets);
1768
- var chainflipNetwork = zod.z.nativeEnum(ChainflipNetworks);
1769
- zod.z.union([
1770
- zod.z.object({
1771
- __kind: zod.z.literal("CcmPrincipal"),
1772
- value: unsignedInteger
1773
- }).transform(({ value: ccmId }) => ({
1774
- type: "PRINCIPAL",
1775
- ccmId
1776
- })),
1777
- zod.z.object({
1778
- __kind: zod.z.literal("CcmGas"),
1779
- value: unsignedInteger
1780
- }).transform(({ value: ccmId }) => ({
1781
- type: "GAS",
1782
- ccmId
1783
- })),
1784
- zod.z.object({
1785
- __kind: zod.z.literal("Swap")
1786
- }).transform(() => ({
1787
- type: "SWAP"
1788
- }))
1789
- ]);
1790
-
1791
- // ../shared/src/vault/schemas.ts
1792
- var bytesToHex = /* @__PURE__ */ __name((arr) => `0x${[
1793
- ...arr
1794
- ].map((v) => v.toString(16).padStart(2, "0")).join("")}`, "bytesToHex");
1795
- var utf8ToHex = /* @__PURE__ */ __name((str) => `0x${Buffer.from(str).toString("hex")}`, "utf8ToHex");
1796
- var base = zod.z.object({
1797
- amount: zod.z.union([
1798
- numericString,
1799
- hexString,
1800
- zod.z.bigint()
1801
- ]),
1802
- srcChain: zod.z.literal(Chains.Ethereum),
1803
- srcAsset: zod.z.literal(Assets.ETH)
1804
- });
1805
- var ethereumBase = base.extend({
1806
- destChain: zod.z.literal(Chains.Ethereum),
1807
- destAddress: ethereumAddress
1808
- });
1809
- var polkadotBase = base.extend({
1810
- destChain: zod.z.literal(Chains.Polkadot),
1811
- destAddress: dotAddress.transform((addr) => bytesToHex(utilCrypto.decodeAddress(addr)))
1812
- });
1813
- var bitcoinBase = base.extend({
1814
- destChain: zod.z.literal(Chains.Bitcoin),
1815
- destAddress: btcAddress.transform(utf8ToHex)
1816
- });
1817
- var erc20 = zod.z.union([
1818
- zod.z.literal(Assets.FLIP),
1819
- zod.z.literal(Assets.USDC)
1820
- ]);
1821
- var ethereumNative = ethereumBase.extend({
1822
- destAsset: erc20
1823
- });
1824
- var polkadotNative = polkadotBase.extend({
1825
- destAsset: zod.z.literal(Assets.DOT)
1826
- });
1827
- var bitcoinNative = bitcoinBase.extend({
1828
- destAsset: zod.z.literal(Assets.BTC)
1829
- });
1830
- var nativeSwapParamsSchema = zod.z.union([
1831
- ethereumNative,
1832
- polkadotNative,
1833
- bitcoinNative
1834
- ]);
1835
- var tokenSwapParamsSchema = zod.z.union([
1836
- ethereumBase.extend({
1837
- srcAsset: zod.z.literal(Assets.FLIP),
1838
- destAsset: zod.z.union([
1839
- zod.z.literal(Assets.USDC),
1840
- zod.z.literal(Assets.ETH)
1841
- ])
1842
- }),
1843
- ethereumBase.extend({
1844
- srcAsset: zod.z.literal(Assets.USDC),
1845
- destAsset: zod.z.union([
1846
- zod.z.literal(Assets.FLIP),
1847
- zod.z.literal(Assets.ETH)
1848
- ])
1849
- }),
1850
- polkadotNative.extend({
1851
- srcAsset: erc20
1852
- }),
1853
- bitcoinNative.extend({
1854
- srcAsset: erc20
1855
- })
1856
- ]);
1857
- var ccmMetadataSchema = zod.z.object({
1858
- message: zod.z.string(),
1859
- gasBudget: numericString
1860
- });
1861
- var tokenCallParamsSchema = zod.z.union([
1862
- ethereumBase.extend({
1863
- srcAsset: zod.z.literal(Assets.FLIP),
1864
- destAsset: zod.z.union([
1865
- zod.z.literal(Assets.USDC),
1866
- zod.z.literal(Assets.ETH)
1867
- ]),
1868
- ccmMetadata: ccmMetadataSchema
1869
- }),
1870
- ethereumBase.extend({
1871
- srcAsset: zod.z.literal(Assets.USDC),
1872
- destAsset: zod.z.union([
1873
- zod.z.literal(Assets.FLIP),
1874
- zod.z.literal(Assets.ETH)
1875
- ]),
1876
- ccmMetadata: ccmMetadataSchema
1877
- })
1878
- ]);
1879
- var nativeCallParamsSchema = ethereumBase.extend({
1880
- destAsset: erc20,
1881
- ccmMetadata: ccmMetadataSchema
1882
- });
1883
- var executeSwapParamsSchema = zod.z.union([
1884
- // call schemas needs to precede swap schemas
1885
- nativeCallParamsSchema,
1886
- tokenCallParamsSchema,
1887
- nativeSwapParamsSchema,
1888
- tokenSwapParamsSchema
1889
- ]);
1890
- var executeOptionsSchema = zod.z.intersection(zod.z.object({
1891
- signer: zod.z.instanceof(ethers.Signer)
1892
- }).passthrough(), zod.z.union([
1893
- zod.z.object({
1894
- network: chainflipNetwork
1895
- }).passthrough(),
1896
- zod.z.object({
1897
- network: zod.z.literal("localnet"),
1898
- vaultContractAddress: zod.z.string(),
1899
- srcTokenContractAddress: zod.z.string().optional()
1900
- }).passthrough()
1901
- ]));
1911
+ const requiredAmount = amountBigNumber.sub(allowanceBigNumber);
1912
+ const tx = await erc20.approve(spenderAddress, requiredAmount, {
1913
+ nonce
1914
+ });
1915
+ return tx.wait(1);
1916
+ }, "approve");
1917
+ var getVaultManagerContractAddress = /* @__PURE__ */ __name((network) => {
1918
+ assert(network !== ChainflipNetworks.mainnet, "Mainnet is not yet supported");
1919
+ return ADDRESSES[network].VAULT_CONTRACT_ADDRESS;
1920
+ }, "getVaultManagerContractAddress");
1902
1921
 
1903
1922
  // ../shared/src/vault/executeSwap.ts
1904
1923
  var swapNative = /* @__PURE__ */ __name(async ({ destChain, destAsset, destAddress, amount }, { network, vaultContractAddress: address, signer, ...opts }) => {
@@ -1957,11 +1976,11 @@ var checkVaultAllowance = /* @__PURE__ */ __name((params, opts) => {
1957
1976
  return checkAllowance(params.amount, vaultContractAddress, erc20Address, opts.signer);
1958
1977
  }, "checkVaultAllowance");
1959
1978
  var approveVault = /* @__PURE__ */ __name(async (params, opts) => {
1960
- const { isAllowable, erc20: erc202, allowance } = await checkVaultAllowance(params, opts);
1979
+ const { isAllowable, erc20, allowance } = await checkVaultAllowance(params, opts);
1961
1980
  if (isAllowable)
1962
1981
  return null;
1963
1982
  const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
1964
- return approve(params.amount, vaultContractAddress, erc202, allowance, opts.nonce);
1983
+ return approve(params.amount, vaultContractAddress, erc20, allowance, opts.nonce);
1965
1984
  }, "approveVault");
1966
1985
 
1967
1986
  // src/swap/consts.ts
@@ -1979,7 +1998,9 @@ var eth$ = /* @__PURE__ */ __name((network) => ({
1979
1998
  decimals: assetDecimals[Assets.ETH],
1980
1999
  name: "Ether",
1981
2000
  symbol: "ETH",
1982
- isMainnet: !isTestnet(network)
2001
+ isMainnet: !isTestnet(network),
2002
+ minimumDepositAmount: getMinimumDepositAmount(network, Assets.ETH),
2003
+ minimumSwapAmount: getMinimumSwapAmount(network, Assets.ETH)
1983
2004
  }), "eth$");
1984
2005
  var usdc$ = /* @__PURE__ */ __name((network) => ({
1985
2006
  id: Assets.USDC,
@@ -1988,7 +2009,9 @@ var usdc$ = /* @__PURE__ */ __name((network) => ({
1988
2009
  decimals: assetDecimals[Assets.USDC],
1989
2010
  name: "USDC",
1990
2011
  symbol: "USDC",
1991
- isMainnet: !isTestnet(network)
2012
+ isMainnet: !isTestnet(network),
2013
+ minimumDepositAmount: getMinimumDepositAmount(network, Assets.USDC),
2014
+ minimumSwapAmount: getMinimumSwapAmount(network, Assets.USDC)
1992
2015
  }), "usdc$");
1993
2016
  var flip$ = /* @__PURE__ */ __name((network) => ({
1994
2017
  id: Assets.FLIP,
@@ -1997,7 +2020,9 @@ var flip$ = /* @__PURE__ */ __name((network) => ({
1997
2020
  decimals: assetDecimals[Assets.FLIP],
1998
2021
  name: "FLIP",
1999
2022
  symbol: "FLIP",
2000
- isMainnet: !isTestnet(network)
2023
+ isMainnet: !isTestnet(network),
2024
+ minimumDepositAmount: getMinimumDepositAmount(network, Assets.FLIP),
2025
+ minimumSwapAmount: getMinimumSwapAmount(network, Assets.FLIP)
2001
2026
  }), "flip$");
2002
2027
  var dot$ = /* @__PURE__ */ __name((network) => ({
2003
2028
  id: Assets.DOT,
@@ -2006,7 +2031,9 @@ var dot$ = /* @__PURE__ */ __name((network) => ({
2006
2031
  decimals: assetDecimals[Assets.DOT],
2007
2032
  name: "Polkadot",
2008
2033
  symbol: "DOT",
2009
- isMainnet: !isTestnet(network)
2034
+ isMainnet: !isTestnet(network),
2035
+ minimumDepositAmount: getMinimumDepositAmount(network, Assets.DOT),
2036
+ minimumSwapAmount: getMinimumSwapAmount(network, Assets.DOT)
2010
2037
  }), "dot$");
2011
2038
  var btc$ = /* @__PURE__ */ __name((network) => ({
2012
2039
  id: Assets.BTC,
@@ -2015,7 +2042,9 @@ var btc$ = /* @__PURE__ */ __name((network) => ({
2015
2042
  decimals: assetDecimals[Assets.BTC],
2016
2043
  name: "Bitcoin",
2017
2044
  symbol: "BTC",
2018
- isMainnet: !isTestnet(network)
2045
+ isMainnet: !isTestnet(network),
2046
+ minimumDepositAmount: getMinimumDepositAmount(network, Assets.BTC),
2047
+ minimumSwapAmount: getMinimumSwapAmount(network, Assets.BTC)
2019
2048
  }), "btc$");
2020
2049
 
2021
2050
  // src/swap/chains.ts
@@ -2132,6 +2161,9 @@ var ApiService_default = {
2132
2161
  // src/swap/sdk.ts
2133
2162
  var SwapSDK = class {
2134
2163
  constructor(options = {}) {
2164
+ __publicField(this, "baseUrl");
2165
+ __publicField(this, "network");
2166
+ __publicField(this, "signer");
2135
2167
  this.network = options.network ?? ChainflipNetworks.partnernet;
2136
2168
  this.baseUrl = options.backendUrl ?? BACKEND_SERVICE_URLS[this.network];
2137
2169
  this.signer = options.signer;