@chainflip/sdk 0.1.0
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/README.md +3 -0
- package/dist/chunk-BSY2FXE7.mjs +2128 -0
- package/dist/enums-d5fa72fa.d.ts +32 -0
- package/dist/funding.d.ts +20 -0
- package/dist/funding.js +998 -0
- package/dist/funding.mjs +102 -0
- package/dist/swap.d.ts +430 -0
- package/dist/swap.js +2229 -0
- package/dist/swap.mjs +754 -0
- package/package.json +60 -0
package/dist/swap.mjs
ADDED
|
@@ -0,0 +1,754 @@
|
|
|
1
|
+
import { isString, Chains, Assets, ChainflipNetworks, assetDecimals, __name, assert, getVaultManagerContractAddress, approve, isTokenSwap, isTokenCall, getTokenContractAddress, checkAllowance, isTestnet, Vault__factory, chainContractIds, assetContractIds } from './chunk-BSY2FXE7.mjs';
|
|
2
|
+
export { Assets, ChainflipNetworks, Chains, assetChains, assetContractIds, assetDecimals, chainAssets, chainContractIds } from './chunk-BSY2FXE7.mjs';
|
|
3
|
+
import { encodeAddress, decodeAddress } from '@polkadot/util-crypto';
|
|
4
|
+
import * as ethers from 'ethers';
|
|
5
|
+
import { Signer } from 'ethers';
|
|
6
|
+
import { z } from 'zod';
|
|
7
|
+
import { hexToU8a } from '@polkadot/util';
|
|
8
|
+
import axios from 'axios';
|
|
9
|
+
|
|
10
|
+
// ../shared/src/validation/segwitAddr.ts
|
|
11
|
+
var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
|
|
12
|
+
var GENERATOR = [
|
|
13
|
+
996825010,
|
|
14
|
+
642813549,
|
|
15
|
+
513874426,
|
|
16
|
+
1027748829,
|
|
17
|
+
705979059
|
|
18
|
+
];
|
|
19
|
+
var Encoding;
|
|
20
|
+
(function(Encoding2) {
|
|
21
|
+
Encoding2["Bech32"] = "bech32";
|
|
22
|
+
Encoding2["Bech32m"] = "bech32m";
|
|
23
|
+
})(Encoding || (Encoding = {}));
|
|
24
|
+
var bech32 = {
|
|
25
|
+
getEncodingConst(enc) {
|
|
26
|
+
if (enc === Encoding.Bech32)
|
|
27
|
+
return 1;
|
|
28
|
+
if (enc === Encoding.Bech32m)
|
|
29
|
+
return 734539939;
|
|
30
|
+
return null;
|
|
31
|
+
},
|
|
32
|
+
polymod(values) {
|
|
33
|
+
let chk = 1;
|
|
34
|
+
for (let p = 0; p < values.length; p += 1) {
|
|
35
|
+
const top = chk >> 25;
|
|
36
|
+
chk = (chk & 33554431) << 5 ^ values[p];
|
|
37
|
+
for (let i = 0; i < 5; i += 1) {
|
|
38
|
+
if (top >> i & 1) {
|
|
39
|
+
chk ^= GENERATOR[i];
|
|
40
|
+
}
|
|
41
|
+
}
|
|
42
|
+
}
|
|
43
|
+
return chk;
|
|
44
|
+
},
|
|
45
|
+
hrpExpand(hrp) {
|
|
46
|
+
const ret = [];
|
|
47
|
+
let p;
|
|
48
|
+
for (p = 0; p < hrp.length; p += 1) {
|
|
49
|
+
ret.push(hrp.charCodeAt(p) >> 5);
|
|
50
|
+
}
|
|
51
|
+
ret.push(0);
|
|
52
|
+
for (p = 0; p < hrp.length; p += 1) {
|
|
53
|
+
ret.push(hrp.charCodeAt(p) & 31);
|
|
54
|
+
}
|
|
55
|
+
return ret;
|
|
56
|
+
},
|
|
57
|
+
verifyChecksum(hrp, data, enc) {
|
|
58
|
+
return this.polymod(this.hrpExpand(hrp).concat(data)) === this.getEncodingConst(enc);
|
|
59
|
+
},
|
|
60
|
+
createChecksum(hrp, data, enc) {
|
|
61
|
+
const values = this.hrpExpand(hrp).concat(data).concat([
|
|
62
|
+
0,
|
|
63
|
+
0,
|
|
64
|
+
0,
|
|
65
|
+
0,
|
|
66
|
+
0,
|
|
67
|
+
0
|
|
68
|
+
]);
|
|
69
|
+
const mod = this.polymod(values) ^ this.getEncodingConst(enc);
|
|
70
|
+
const ret = [];
|
|
71
|
+
for (let p = 0; p < 6; p += 1) {
|
|
72
|
+
ret.push(mod >> 5 * (5 - p) & 31);
|
|
73
|
+
}
|
|
74
|
+
return ret;
|
|
75
|
+
},
|
|
76
|
+
encode(hrp, data, enc) {
|
|
77
|
+
const combined = data.concat(this.createChecksum(hrp, data, enc));
|
|
78
|
+
let ret = `${hrp}1`;
|
|
79
|
+
for (let p = 0; p < combined.length; p += 1) {
|
|
80
|
+
ret += CHARSET.charAt(combined[p]);
|
|
81
|
+
}
|
|
82
|
+
return ret;
|
|
83
|
+
},
|
|
84
|
+
decode(bechString, enc) {
|
|
85
|
+
let p;
|
|
86
|
+
let hasLower = false;
|
|
87
|
+
let hasUpper = false;
|
|
88
|
+
for (p = 0; p < bechString.length; p += 1) {
|
|
89
|
+
if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126) {
|
|
90
|
+
return null;
|
|
91
|
+
}
|
|
92
|
+
if (bechString.charCodeAt(p) >= 97 && bechString.charCodeAt(p) <= 122) {
|
|
93
|
+
hasLower = true;
|
|
94
|
+
}
|
|
95
|
+
if (bechString.charCodeAt(p) >= 65 && bechString.charCodeAt(p) <= 90) {
|
|
96
|
+
hasUpper = true;
|
|
97
|
+
}
|
|
98
|
+
}
|
|
99
|
+
if (hasLower && hasUpper)
|
|
100
|
+
return null;
|
|
101
|
+
const lowercase = bechString.toLowerCase();
|
|
102
|
+
const pos = lowercase.lastIndexOf("1");
|
|
103
|
+
if (pos < 1 || pos + 7 > lowercase.length || lowercase.length > 90) {
|
|
104
|
+
return null;
|
|
105
|
+
}
|
|
106
|
+
const hrp = lowercase.substring(0, pos);
|
|
107
|
+
const data = [];
|
|
108
|
+
for (p = pos + 1; p < lowercase.length; p += 1) {
|
|
109
|
+
const d = CHARSET.indexOf(lowercase.charAt(p));
|
|
110
|
+
if (d === -1)
|
|
111
|
+
return null;
|
|
112
|
+
data.push(d);
|
|
113
|
+
}
|
|
114
|
+
if (!this.verifyChecksum(hrp, data, enc)) {
|
|
115
|
+
return null;
|
|
116
|
+
}
|
|
117
|
+
return {
|
|
118
|
+
hrp,
|
|
119
|
+
data: data.slice(0, data.length - 6)
|
|
120
|
+
};
|
|
121
|
+
}
|
|
122
|
+
};
|
|
123
|
+
var segwitAddress = {
|
|
124
|
+
convertbits(data, frombits, tobits, pad) {
|
|
125
|
+
let acc = 0;
|
|
126
|
+
let bits = 0;
|
|
127
|
+
const ret = [];
|
|
128
|
+
const maxv = (1 << tobits) - 1;
|
|
129
|
+
for (let p = 0; p < data.length; p += 1) {
|
|
130
|
+
const value = data[p];
|
|
131
|
+
if (value < 0 || value >> frombits !== 0) {
|
|
132
|
+
return null;
|
|
133
|
+
}
|
|
134
|
+
acc = acc << frombits | value;
|
|
135
|
+
bits += frombits;
|
|
136
|
+
while (bits >= tobits) {
|
|
137
|
+
bits -= tobits;
|
|
138
|
+
ret.push(acc >> bits & maxv);
|
|
139
|
+
}
|
|
140
|
+
}
|
|
141
|
+
if (pad) {
|
|
142
|
+
if (bits > 0) {
|
|
143
|
+
ret.push(acc << tobits - bits & maxv);
|
|
144
|
+
}
|
|
145
|
+
} else if (bits >= frombits || acc << tobits - bits & maxv) {
|
|
146
|
+
return null;
|
|
147
|
+
}
|
|
148
|
+
return ret;
|
|
149
|
+
},
|
|
150
|
+
decode(hrp, addr) {
|
|
151
|
+
let bech32m = false;
|
|
152
|
+
let dec = bech32.decode(addr, Encoding.Bech32);
|
|
153
|
+
if (dec === null) {
|
|
154
|
+
dec = bech32.decode(addr, Encoding.Bech32m);
|
|
155
|
+
bech32m = true;
|
|
156
|
+
}
|
|
157
|
+
if (dec === null || dec.hrp !== hrp || dec.data.length < 1 || dec.data[0] > 16) {
|
|
158
|
+
return null;
|
|
159
|
+
}
|
|
160
|
+
const res = this.convertbits(dec.data.slice(1), 5, 8, false);
|
|
161
|
+
if (res === null || res.length < 2 || res.length > 40) {
|
|
162
|
+
return null;
|
|
163
|
+
}
|
|
164
|
+
if (dec.data[0] === 0 && res.length !== 20 && res.length !== 32) {
|
|
165
|
+
return null;
|
|
166
|
+
}
|
|
167
|
+
if (dec.data[0] === 0 && bech32m) {
|
|
168
|
+
return null;
|
|
169
|
+
}
|
|
170
|
+
if (dec.data[0] !== 0 && !bech32m) {
|
|
171
|
+
return null;
|
|
172
|
+
}
|
|
173
|
+
return {
|
|
174
|
+
version: dec.data[0],
|
|
175
|
+
program: res
|
|
176
|
+
};
|
|
177
|
+
},
|
|
178
|
+
encode(hrp, version, program) {
|
|
179
|
+
let enc = Encoding.Bech32;
|
|
180
|
+
if (version > 0) {
|
|
181
|
+
enc = Encoding.Bech32m;
|
|
182
|
+
}
|
|
183
|
+
const ret = bech32.encode(
|
|
184
|
+
hrp,
|
|
185
|
+
// @ts-expect-error can be null
|
|
186
|
+
[
|
|
187
|
+
version
|
|
188
|
+
].concat(this.convertbits(program, 8, 5, true)),
|
|
189
|
+
enc
|
|
190
|
+
);
|
|
191
|
+
if (this.decode(hrp, ret) === null) {
|
|
192
|
+
return null;
|
|
193
|
+
}
|
|
194
|
+
return ret;
|
|
195
|
+
}
|
|
196
|
+
};
|
|
197
|
+
var isValidSegwitAddress = /* @__PURE__ */ __name((address) => {
|
|
198
|
+
const hrp = /^(bc|tb|bcrt)1/.exec(address)?.[1];
|
|
199
|
+
if (!hrp)
|
|
200
|
+
return false;
|
|
201
|
+
return segwitAddress.decode(hrp, address) !== null;
|
|
202
|
+
}, "isValidSegwitAddress");
|
|
203
|
+
|
|
204
|
+
// ../shared/src/validation/addressValidation.ts
|
|
205
|
+
var assertArraylikeEqual = /* @__PURE__ */ __name((a, b) => {
|
|
206
|
+
assert(a.length === b.length, "arraylike lengths must be equal");
|
|
207
|
+
for (let i = 0; i < a.length; i += 1) {
|
|
208
|
+
assert(a[i] === b[i], "arraylike elements must be equal");
|
|
209
|
+
}
|
|
210
|
+
}, "assertArraylikeEqual");
|
|
211
|
+
var validateP2PKHOrP2SHAddress = /* @__PURE__ */ __name((address, network) => {
|
|
212
|
+
try {
|
|
213
|
+
const decoded = ethers.utils.base58.decode(address);
|
|
214
|
+
assert(decoded.length === 25, "decoded address must be 25 bytes long");
|
|
215
|
+
if (network === "mainnet") {
|
|
216
|
+
assert(decoded[0] === 0 || decoded[0] === 5, "decoded address must start with 0x00 or 0x05");
|
|
217
|
+
} else {
|
|
218
|
+
assert(decoded[0] === 111 || decoded[0] === 196, "decoded address must start with 0x6f or 0xc4");
|
|
219
|
+
}
|
|
220
|
+
const checksum = decoded.slice(-4);
|
|
221
|
+
const doubleHash = ethers.utils.arrayify(ethers.utils.sha256(ethers.utils.sha256(decoded.slice(0, 21))));
|
|
222
|
+
assertArraylikeEqual(checksum, doubleHash.slice(0, 4));
|
|
223
|
+
return true;
|
|
224
|
+
} catch (error) {
|
|
225
|
+
return false;
|
|
226
|
+
}
|
|
227
|
+
}, "validateP2PKHOrP2SHAddress");
|
|
228
|
+
var validateSegwitAddress = /* @__PURE__ */ __name((address, network) => {
|
|
229
|
+
try {
|
|
230
|
+
assert(
|
|
231
|
+
// On mainnet, the address must start with "bc1"
|
|
232
|
+
network === "mainnet" && address.startsWith("bc1") || // on testnet it must start with "tb1"
|
|
233
|
+
network === "testnet" && address.startsWith("tb1") || // on regtest it must start with "bcrt1"
|
|
234
|
+
network === "regtest" && address.startsWith("bcrt1"),
|
|
235
|
+
"address must start with bc1, tb1 or bcrt1"
|
|
236
|
+
);
|
|
237
|
+
return isValidSegwitAddress(address);
|
|
238
|
+
} catch {
|
|
239
|
+
return false;
|
|
240
|
+
}
|
|
241
|
+
}, "validateSegwitAddress");
|
|
242
|
+
var validateBitcoinAddress = /* @__PURE__ */ __name((address, network) => validateP2PKHOrP2SHAddress(address, network) || validateSegwitAddress(address, network), "validateBitcoinAddress");
|
|
243
|
+
var validateBitcoinMainnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "mainnet"), "validateBitcoinMainnetAddress");
|
|
244
|
+
var validateBitcoinTestnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "testnet"), "validateBitcoinTestnetAddress");
|
|
245
|
+
var validateBitcoinRegtestAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "regtest"), "validateBitcoinRegtestAddress");
|
|
246
|
+
|
|
247
|
+
// ../shared/src/parsers.ts
|
|
248
|
+
var errorMap = /* @__PURE__ */ __name((issue, context) => ({
|
|
249
|
+
message: `received: ${JSON.stringify(context.data)}`
|
|
250
|
+
}), "errorMap");
|
|
251
|
+
var string = z.string({
|
|
252
|
+
errorMap
|
|
253
|
+
});
|
|
254
|
+
z.number({
|
|
255
|
+
errorMap
|
|
256
|
+
});
|
|
257
|
+
var numericString = string.regex(/^[0-9]+$/);
|
|
258
|
+
var hexString = z.custom((val) => typeof val === "string" && /^0x[0-9a-f]+$/i.test(val));
|
|
259
|
+
numericString.transform((arg) => ethers.BigNumber.from(arg).toHexString()).refine((arg) => arg.startsWith("0x"));
|
|
260
|
+
string.regex(/^[0-9a-f]+$/);
|
|
261
|
+
var btcAddress = z.union([
|
|
262
|
+
string.regex(/^(1|3|bc1)/).refine(validateBitcoinMainnetAddress),
|
|
263
|
+
string.regex(/^(m|n|2|tb1)/).refine(validateBitcoinTestnetAddress),
|
|
264
|
+
string.regex(/^bcrt1/).refine(validateBitcoinRegtestAddress)
|
|
265
|
+
]);
|
|
266
|
+
var dotAddress = z.union([
|
|
267
|
+
string,
|
|
268
|
+
hexString
|
|
269
|
+
]).transform((arg) => {
|
|
270
|
+
try {
|
|
271
|
+
if (arg.startsWith("0x")) {
|
|
272
|
+
return encodeAddress(hexToU8a(arg));
|
|
273
|
+
}
|
|
274
|
+
decodeAddress(arg);
|
|
275
|
+
return arg;
|
|
276
|
+
} catch {
|
|
277
|
+
return null;
|
|
278
|
+
}
|
|
279
|
+
}).refine(isString);
|
|
280
|
+
var ethereumAddress = hexString.refine((address) => ethers.utils.isAddress(address));
|
|
281
|
+
numericString.transform((arg) => BigInt(arg));
|
|
282
|
+
var u128 = z.union([
|
|
283
|
+
numericString,
|
|
284
|
+
hexString
|
|
285
|
+
]).transform((arg) => BigInt(arg));
|
|
286
|
+
z.union([
|
|
287
|
+
u128,
|
|
288
|
+
z.number().transform((n) => BigInt(n))
|
|
289
|
+
]);
|
|
290
|
+
z.object({
|
|
291
|
+
__kind: z.enum([
|
|
292
|
+
"Usdc",
|
|
293
|
+
"Flip",
|
|
294
|
+
"Dot",
|
|
295
|
+
"Eth",
|
|
296
|
+
"Btc"
|
|
297
|
+
])
|
|
298
|
+
}).transform(({ __kind }) => __kind.toUpperCase());
|
|
299
|
+
z.nativeEnum(Chains);
|
|
300
|
+
z.nativeEnum(Assets);
|
|
301
|
+
var chainflipNetwork = z.nativeEnum(ChainflipNetworks);
|
|
302
|
+
|
|
303
|
+
// ../shared/src/vault/schemas.ts
|
|
304
|
+
var bytesToHex = /* @__PURE__ */ __name((arr) => `0x${[
|
|
305
|
+
...arr
|
|
306
|
+
].map((v) => v.toString(16).padStart(2, "0")).join("")}`, "bytesToHex");
|
|
307
|
+
var utf8ToHex = /* @__PURE__ */ __name((str) => `0x${Buffer.from(str).toString("hex")}`, "utf8ToHex");
|
|
308
|
+
var base = z.object({
|
|
309
|
+
amount: z.union([
|
|
310
|
+
numericString,
|
|
311
|
+
hexString,
|
|
312
|
+
z.bigint()
|
|
313
|
+
])
|
|
314
|
+
});
|
|
315
|
+
var ethereumBase = base.extend({
|
|
316
|
+
destChain: z.literal(Chains.Ethereum),
|
|
317
|
+
destAddress: ethereumAddress
|
|
318
|
+
});
|
|
319
|
+
var polkadotBase = base.extend({
|
|
320
|
+
destChain: z.literal(Chains.Polkadot),
|
|
321
|
+
destAddress: dotAddress.transform((addr) => bytesToHex(decodeAddress(addr)))
|
|
322
|
+
});
|
|
323
|
+
var bitcoinBase = base.extend({
|
|
324
|
+
destChain: z.literal(Chains.Bitcoin),
|
|
325
|
+
destAddress: btcAddress.transform(utf8ToHex)
|
|
326
|
+
});
|
|
327
|
+
var erc20 = z.union([
|
|
328
|
+
z.literal(Assets.FLIP),
|
|
329
|
+
z.literal(Assets.USDC)
|
|
330
|
+
]);
|
|
331
|
+
var ethereumNative = ethereumBase.extend({
|
|
332
|
+
destAsset: erc20
|
|
333
|
+
}).strict();
|
|
334
|
+
var polkadotNative = polkadotBase.extend({
|
|
335
|
+
destAsset: z.literal(Assets.DOT)
|
|
336
|
+
}).strict();
|
|
337
|
+
var bitcoinNative = bitcoinBase.extend({
|
|
338
|
+
destAsset: z.literal(Assets.BTC)
|
|
339
|
+
}).strict();
|
|
340
|
+
var nativeSwapParamsSchema = z.union([
|
|
341
|
+
ethereumNative,
|
|
342
|
+
polkadotNative,
|
|
343
|
+
bitcoinNative
|
|
344
|
+
]);
|
|
345
|
+
var tokenSwapParamsSchema = z.union([
|
|
346
|
+
ethereumBase.extend({
|
|
347
|
+
srcAsset: z.literal(Assets.FLIP),
|
|
348
|
+
destAsset: z.union([
|
|
349
|
+
z.literal(Assets.USDC),
|
|
350
|
+
z.literal(Assets.ETH)
|
|
351
|
+
])
|
|
352
|
+
}),
|
|
353
|
+
ethereumBase.extend({
|
|
354
|
+
srcAsset: z.literal(Assets.USDC),
|
|
355
|
+
destAsset: z.union([
|
|
356
|
+
z.literal(Assets.FLIP),
|
|
357
|
+
z.literal(Assets.ETH)
|
|
358
|
+
])
|
|
359
|
+
}),
|
|
360
|
+
polkadotNative.extend({
|
|
361
|
+
srcAsset: erc20
|
|
362
|
+
}),
|
|
363
|
+
bitcoinNative.extend({
|
|
364
|
+
srcAsset: erc20
|
|
365
|
+
})
|
|
366
|
+
]);
|
|
367
|
+
var executeSwapParamsSchema = z.union([
|
|
368
|
+
nativeSwapParamsSchema,
|
|
369
|
+
tokenSwapParamsSchema
|
|
370
|
+
]);
|
|
371
|
+
var nativeCallParamsSchema = ethereumBase.extend({
|
|
372
|
+
destAsset: erc20,
|
|
373
|
+
message: z.string(),
|
|
374
|
+
gasAmount: numericString
|
|
375
|
+
}).strict();
|
|
376
|
+
var tokenCallParamsSchema = z.union([
|
|
377
|
+
ethereumBase.extend({
|
|
378
|
+
srcAsset: z.literal(Assets.FLIP),
|
|
379
|
+
destAsset: z.union([
|
|
380
|
+
z.literal(Assets.USDC),
|
|
381
|
+
z.literal(Assets.ETH)
|
|
382
|
+
]),
|
|
383
|
+
message: hexString,
|
|
384
|
+
gasAmount: numericString
|
|
385
|
+
}),
|
|
386
|
+
ethereumBase.extend({
|
|
387
|
+
srcAsset: z.literal(Assets.USDC),
|
|
388
|
+
destAsset: z.union([
|
|
389
|
+
z.literal(Assets.FLIP),
|
|
390
|
+
z.literal(Assets.ETH)
|
|
391
|
+
]),
|
|
392
|
+
message: hexString,
|
|
393
|
+
gasAmount: numericString
|
|
394
|
+
})
|
|
395
|
+
]);
|
|
396
|
+
var executeCallParamsSchema = z.union([
|
|
397
|
+
nativeCallParamsSchema,
|
|
398
|
+
tokenCallParamsSchema
|
|
399
|
+
]);
|
|
400
|
+
var executeOptionsSchema = z.intersection(z.object({
|
|
401
|
+
signer: z.instanceof(Signer),
|
|
402
|
+
nonce: z.union([
|
|
403
|
+
z.number(),
|
|
404
|
+
z.bigint(),
|
|
405
|
+
z.string()
|
|
406
|
+
]).optional()
|
|
407
|
+
}), z.union([
|
|
408
|
+
z.object({
|
|
409
|
+
network: chainflipNetwork
|
|
410
|
+
}),
|
|
411
|
+
z.object({
|
|
412
|
+
network: z.literal("localnet"),
|
|
413
|
+
vaultContractAddress: z.string(),
|
|
414
|
+
srcTokenContractAddress: z.string().optional()
|
|
415
|
+
})
|
|
416
|
+
]));
|
|
417
|
+
|
|
418
|
+
// ../shared/src/vault/executeSwap.ts
|
|
419
|
+
var swapNative = /* @__PURE__ */ __name(async ({ destChain, destAsset, destAddress, amount }, { nonce, ...opts }) => {
|
|
420
|
+
const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
|
|
421
|
+
const vault = Vault__factory.connect(vaultContractAddress, opts.signer);
|
|
422
|
+
const transaction = await vault.xSwapNative(chainContractIds[destChain], destAddress, assetContractIds[destAsset], [], {
|
|
423
|
+
value: amount,
|
|
424
|
+
nonce
|
|
425
|
+
});
|
|
426
|
+
return transaction.wait(1);
|
|
427
|
+
}, "swapNative");
|
|
428
|
+
var swapToken = /* @__PURE__ */ __name(async (params, opts) => {
|
|
429
|
+
const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
|
|
430
|
+
const erc20Address = opts.network === "localnet" ? opts.srcTokenContractAddress : getTokenContractAddress(params.srcAsset, opts.network);
|
|
431
|
+
assert(erc20Address !== void 0, "Missing ERC20 contract address");
|
|
432
|
+
const { isAllowable } = await checkAllowance(params.amount, vaultContractAddress, erc20Address, opts.signer);
|
|
433
|
+
assert(isAllowable, "Swap amount exceeds allowance");
|
|
434
|
+
const vault = Vault__factory.connect(vaultContractAddress, opts.signer);
|
|
435
|
+
const transaction = await vault.xSwapToken(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], erc20Address, params.amount, [], {
|
|
436
|
+
nonce: opts.nonce
|
|
437
|
+
});
|
|
438
|
+
return transaction.wait(1);
|
|
439
|
+
}, "swapToken");
|
|
440
|
+
var executeSwap = /* @__PURE__ */ __name(async (params, options) => {
|
|
441
|
+
const parsedParams = executeSwapParamsSchema.parse(params);
|
|
442
|
+
const opts = executeOptionsSchema.parse(options);
|
|
443
|
+
return isTokenSwap(parsedParams) ? swapToken(parsedParams, opts) : swapNative(parsedParams, opts);
|
|
444
|
+
}, "executeSwap");
|
|
445
|
+
var executeSwap_default = executeSwap;
|
|
446
|
+
|
|
447
|
+
// ../shared/src/vault/executeCall.ts
|
|
448
|
+
var callNative = /* @__PURE__ */ __name(async (params, { nonce, ...opts }) => {
|
|
449
|
+
const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
|
|
450
|
+
const vault = Vault__factory.connect(vaultContractAddress, opts.signer);
|
|
451
|
+
const transaction = await vault.xCallNative(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], params.message, params.gasAmount, [], {
|
|
452
|
+
value: params.amount,
|
|
453
|
+
nonce
|
|
454
|
+
});
|
|
455
|
+
return transaction.wait(1);
|
|
456
|
+
}, "callNative");
|
|
457
|
+
var callToken = /* @__PURE__ */ __name(async (params, { signer, ...opts }) => {
|
|
458
|
+
const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
|
|
459
|
+
const erc20Address = opts.network === "localnet" ? opts.srcTokenContractAddress : getTokenContractAddress(params.srcAsset, opts.network);
|
|
460
|
+
assert(erc20Address !== void 0, "Missing ERC20 contract address");
|
|
461
|
+
const { isAllowable } = await checkAllowance(params.amount, vaultContractAddress, erc20Address, signer);
|
|
462
|
+
assert(isAllowable, "Swap amount exceeds allowance");
|
|
463
|
+
const vault = Vault__factory.connect(vaultContractAddress, signer);
|
|
464
|
+
const transaction = await vault.xCallToken(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], params.message, params.gasAmount, erc20Address, params.amount, [], {
|
|
465
|
+
nonce: opts.nonce
|
|
466
|
+
});
|
|
467
|
+
return transaction.wait(1);
|
|
468
|
+
}, "callToken");
|
|
469
|
+
var executeCall = /* @__PURE__ */ __name(async (params, options) => {
|
|
470
|
+
const parsedParams = executeCallParamsSchema.parse(params);
|
|
471
|
+
const opts = executeOptionsSchema.parse(options);
|
|
472
|
+
return isTokenCall(parsedParams) ? callToken(parsedParams, opts) : callNative(parsedParams, opts);
|
|
473
|
+
}, "executeCall");
|
|
474
|
+
var executeCall_default = executeCall;
|
|
475
|
+
|
|
476
|
+
// ../shared/src/vault/approval.ts
|
|
477
|
+
var checkVaultAllowance = /* @__PURE__ */ __name((params, opts) => {
|
|
478
|
+
const erc20Address = opts.network === "localnet" ? opts.srcTokenContractAddress : getTokenContractAddress(params.srcAsset, opts.network);
|
|
479
|
+
assert(erc20Address !== void 0, "Missing ERC20 contract address");
|
|
480
|
+
const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
|
|
481
|
+
return checkAllowance(params.amount, vaultContractAddress, erc20Address, opts.signer);
|
|
482
|
+
}, "checkVaultAllowance");
|
|
483
|
+
var approveVault = /* @__PURE__ */ __name(async (params, opts) => {
|
|
484
|
+
const { isAllowable, erc20: erc202, allowance } = await checkVaultAllowance(params, opts);
|
|
485
|
+
if (isAllowable)
|
|
486
|
+
return null;
|
|
487
|
+
const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
|
|
488
|
+
return approve(params.amount, vaultContractAddress, erc202, allowance, opts.nonce);
|
|
489
|
+
}, "approveVault");
|
|
490
|
+
|
|
491
|
+
// src/swap/consts.ts
|
|
492
|
+
var BACKEND_SERVICE_URLS = {
|
|
493
|
+
[ChainflipNetworks.sisyphos]: "https://chainflip-swap.staging/",
|
|
494
|
+
[ChainflipNetworks.perseverance]: "https://chainflip-swap-perseverance.chainflip.io/",
|
|
495
|
+
[ChainflipNetworks.partnernet]: "https://chainflip-swap-partnernet.chainflip.io/"
|
|
496
|
+
};
|
|
497
|
+
|
|
498
|
+
// src/swap/mocks.ts
|
|
499
|
+
var ethereum = {
|
|
500
|
+
id: Chains.Ethereum,
|
|
501
|
+
name: "Ethereum",
|
|
502
|
+
isMainnet: true
|
|
503
|
+
};
|
|
504
|
+
var polkadot = {
|
|
505
|
+
id: Chains.Polkadot,
|
|
506
|
+
name: "Polkadot",
|
|
507
|
+
isMainnet: true
|
|
508
|
+
};
|
|
509
|
+
var bitcoin = {
|
|
510
|
+
id: Chains.Bitcoin,
|
|
511
|
+
name: "Bitcoin",
|
|
512
|
+
isMainnet: true
|
|
513
|
+
};
|
|
514
|
+
var ethereumAssets = [
|
|
515
|
+
{
|
|
516
|
+
id: Assets.ETH,
|
|
517
|
+
chain: Chains.Ethereum,
|
|
518
|
+
contractAddress: "0xeth",
|
|
519
|
+
decimals: assetDecimals[Assets.ETH],
|
|
520
|
+
name: "ether",
|
|
521
|
+
symbol: "ETH",
|
|
522
|
+
isMainnet: true
|
|
523
|
+
},
|
|
524
|
+
{
|
|
525
|
+
id: Assets.USDC,
|
|
526
|
+
chain: Chains.Ethereum,
|
|
527
|
+
contractAddress: "0xusdc",
|
|
528
|
+
decimals: assetDecimals[Assets.USDC],
|
|
529
|
+
name: "usdc",
|
|
530
|
+
symbol: "USDC",
|
|
531
|
+
isMainnet: true
|
|
532
|
+
},
|
|
533
|
+
{
|
|
534
|
+
id: Assets.FLIP,
|
|
535
|
+
chain: Chains.Ethereum,
|
|
536
|
+
contractAddress: "0xflip",
|
|
537
|
+
decimals: assetDecimals[Assets.FLIP],
|
|
538
|
+
name: "flip",
|
|
539
|
+
symbol: "FLIP",
|
|
540
|
+
isMainnet: true
|
|
541
|
+
}
|
|
542
|
+
];
|
|
543
|
+
var dot$ = {
|
|
544
|
+
id: Assets.DOT,
|
|
545
|
+
chain: Chains.Polkadot,
|
|
546
|
+
contractAddress: "0xdot",
|
|
547
|
+
decimals: assetDecimals[Assets.DOT],
|
|
548
|
+
name: "dot",
|
|
549
|
+
symbol: "DOT",
|
|
550
|
+
isMainnet: true
|
|
551
|
+
};
|
|
552
|
+
var btc$ = {
|
|
553
|
+
id: Assets.BTC,
|
|
554
|
+
chain: Chains.Bitcoin,
|
|
555
|
+
contractAddress: "0xbitcoin",
|
|
556
|
+
decimals: assetDecimals[Assets.BTC],
|
|
557
|
+
name: "bitcoin",
|
|
558
|
+
symbol: "BTC",
|
|
559
|
+
isMainnet: true
|
|
560
|
+
};
|
|
561
|
+
var testnetChains = /* @__PURE__ */ __name((chains) => chains.map((chain) => ({
|
|
562
|
+
...chain,
|
|
563
|
+
isMainnet: false
|
|
564
|
+
})), "testnetChains");
|
|
565
|
+
var testnetAssets = /* @__PURE__ */ __name((assets) => assets.map((asset) => ({
|
|
566
|
+
...asset,
|
|
567
|
+
isMainnet: false
|
|
568
|
+
})), "testnetAssets");
|
|
569
|
+
|
|
570
|
+
// src/swap/services/ApiService.ts
|
|
571
|
+
var getChains = /* @__PURE__ */ __name(async (network) => {
|
|
572
|
+
if (isTestnet(network)) {
|
|
573
|
+
return testnetChains([
|
|
574
|
+
ethereum,
|
|
575
|
+
polkadot,
|
|
576
|
+
bitcoin
|
|
577
|
+
]);
|
|
578
|
+
}
|
|
579
|
+
return [
|
|
580
|
+
ethereum,
|
|
581
|
+
polkadot,
|
|
582
|
+
bitcoin
|
|
583
|
+
];
|
|
584
|
+
}, "getChains");
|
|
585
|
+
var getPossibleDestinationChains = /* @__PURE__ */ __name(async (sourceChain, network) => {
|
|
586
|
+
if (isTestnet(network)) {
|
|
587
|
+
if (sourceChain === Chains.Ethereum)
|
|
588
|
+
return testnetChains([
|
|
589
|
+
polkadot,
|
|
590
|
+
bitcoin
|
|
591
|
+
]);
|
|
592
|
+
if (sourceChain === Chains.Polkadot)
|
|
593
|
+
return testnetChains([
|
|
594
|
+
ethereum,
|
|
595
|
+
bitcoin
|
|
596
|
+
]);
|
|
597
|
+
if (sourceChain === Chains.Bitcoin)
|
|
598
|
+
return testnetChains([
|
|
599
|
+
ethereum,
|
|
600
|
+
polkadot
|
|
601
|
+
]);
|
|
602
|
+
throw new Error("received testnet flag but mainnet chain");
|
|
603
|
+
}
|
|
604
|
+
if (sourceChain === Chains.Ethereum)
|
|
605
|
+
return [
|
|
606
|
+
bitcoin,
|
|
607
|
+
polkadot
|
|
608
|
+
];
|
|
609
|
+
if (sourceChain === Chains.Polkadot)
|
|
610
|
+
return [
|
|
611
|
+
ethereum,
|
|
612
|
+
bitcoin
|
|
613
|
+
];
|
|
614
|
+
if (sourceChain === Chains.Bitcoin)
|
|
615
|
+
return [
|
|
616
|
+
ethereum,
|
|
617
|
+
polkadot
|
|
618
|
+
];
|
|
619
|
+
throw new Error("received unknown chain");
|
|
620
|
+
}, "getPossibleDestinationChains");
|
|
621
|
+
var getAssets = /* @__PURE__ */ __name(async (chain, network) => {
|
|
622
|
+
if (isTestnet(network)) {
|
|
623
|
+
if (chain === Chains.Ethereum)
|
|
624
|
+
return testnetAssets(ethereumAssets);
|
|
625
|
+
if (chain === Chains.Polkadot)
|
|
626
|
+
return testnetAssets([
|
|
627
|
+
dot$
|
|
628
|
+
]);
|
|
629
|
+
if (chain === Chains.Bitcoin)
|
|
630
|
+
return testnetAssets([
|
|
631
|
+
btc$
|
|
632
|
+
]);
|
|
633
|
+
throw new Error("received testnet flag but mainnet chain");
|
|
634
|
+
}
|
|
635
|
+
if (chain === Chains.Ethereum)
|
|
636
|
+
return ethereumAssets;
|
|
637
|
+
if (chain === Chains.Polkadot)
|
|
638
|
+
return [
|
|
639
|
+
dot$
|
|
640
|
+
];
|
|
641
|
+
if (chain === Chains.Bitcoin)
|
|
642
|
+
return [
|
|
643
|
+
btc$
|
|
644
|
+
];
|
|
645
|
+
throw new Error("received unknown chain");
|
|
646
|
+
}, "getAssets");
|
|
647
|
+
var getQuote = /* @__PURE__ */ __name(async (baseUrl, quoteRequest, { signal }) => {
|
|
648
|
+
const params = {
|
|
649
|
+
amount: quoteRequest.amount,
|
|
650
|
+
srcAsset: quoteRequest.srcAsset,
|
|
651
|
+
destAsset: quoteRequest.destAsset
|
|
652
|
+
};
|
|
653
|
+
const queryParams = new URLSearchParams(params);
|
|
654
|
+
const url = new URL(`/quote?${queryParams.toString()}`, baseUrl).toString();
|
|
655
|
+
const { data } = await axios.get(url, {
|
|
656
|
+
signal
|
|
657
|
+
});
|
|
658
|
+
return {
|
|
659
|
+
...quoteRequest,
|
|
660
|
+
quote: data
|
|
661
|
+
};
|
|
662
|
+
}, "getQuote");
|
|
663
|
+
var requestDepositAddress = /* @__PURE__ */ __name(async (baseUrl, depositAddressRequest, { signal }) => {
|
|
664
|
+
const body = {
|
|
665
|
+
destAddress: depositAddressRequest.destAddress,
|
|
666
|
+
srcAsset: depositAddressRequest.srcAsset,
|
|
667
|
+
destAsset: depositAddressRequest.destAsset,
|
|
668
|
+
srcChain: depositAddressRequest.srcChain,
|
|
669
|
+
destChain: depositAddressRequest.destChain,
|
|
670
|
+
amount: depositAddressRequest.amount,
|
|
671
|
+
ccmMetadata: depositAddressRequest.ccmMetadata
|
|
672
|
+
};
|
|
673
|
+
const url = new URL("/swaps", baseUrl).toString();
|
|
674
|
+
const { data } = await axios.post(url, body, {
|
|
675
|
+
signal
|
|
676
|
+
});
|
|
677
|
+
return {
|
|
678
|
+
...depositAddressRequest,
|
|
679
|
+
depositChannelId: data.id,
|
|
680
|
+
depositAddress: data.depositAddress
|
|
681
|
+
};
|
|
682
|
+
}, "requestDepositAddress");
|
|
683
|
+
var getStatus = /* @__PURE__ */ __name(async (baseUrl, { id }, { signal }) => {
|
|
684
|
+
const url = new URL(`/swaps/${id}`, baseUrl).toString();
|
|
685
|
+
const { data } = await axios.get(url, {
|
|
686
|
+
signal
|
|
687
|
+
});
|
|
688
|
+
return data;
|
|
689
|
+
}, "getStatus");
|
|
690
|
+
var ApiService_default = {
|
|
691
|
+
getChains,
|
|
692
|
+
getPossibleDestinationChains,
|
|
693
|
+
getQuote,
|
|
694
|
+
getAssets,
|
|
695
|
+
getStatus,
|
|
696
|
+
requestDepositAddress
|
|
697
|
+
};
|
|
698
|
+
|
|
699
|
+
// src/swap/sdk.ts
|
|
700
|
+
var SwapSDK = class {
|
|
701
|
+
constructor(options = {}) {
|
|
702
|
+
this.network = options.network ?? ChainflipNetworks.partnernet;
|
|
703
|
+
this.baseUrl = options.backendUrl ?? BACKEND_SERVICE_URLS[this.network];
|
|
704
|
+
this.signer = options.signer;
|
|
705
|
+
}
|
|
706
|
+
getChains(sourceChain) {
|
|
707
|
+
if (sourceChain !== void 0) {
|
|
708
|
+
return ApiService_default.getPossibleDestinationChains(sourceChain, this.network);
|
|
709
|
+
}
|
|
710
|
+
return ApiService_default.getChains(this.network);
|
|
711
|
+
}
|
|
712
|
+
getAssets(chain) {
|
|
713
|
+
return ApiService_default.getAssets(chain, this.network);
|
|
714
|
+
}
|
|
715
|
+
getQuote(quoteRequest, options = {}) {
|
|
716
|
+
return ApiService_default.getQuote(this.baseUrl, quoteRequest, options);
|
|
717
|
+
}
|
|
718
|
+
requestDepositAddress(depositAddressRequest, options = {}) {
|
|
719
|
+
return ApiService_default.requestDepositAddress(this.baseUrl, depositAddressRequest, options);
|
|
720
|
+
}
|
|
721
|
+
getStatus(swapStatusRequest, options = {}) {
|
|
722
|
+
return ApiService_default.getStatus(this.baseUrl, swapStatusRequest, options);
|
|
723
|
+
}
|
|
724
|
+
async executeSwap(params) {
|
|
725
|
+
assert(this.signer, "No signer provided");
|
|
726
|
+
const receipt = await executeSwap_default(params, {
|
|
727
|
+
network: this.network,
|
|
728
|
+
signer: this.signer
|
|
729
|
+
});
|
|
730
|
+
return receipt.transactionHash;
|
|
731
|
+
}
|
|
732
|
+
async executeCall(params) {
|
|
733
|
+
assert(this.signer, "No signer provided");
|
|
734
|
+
const receipt = await executeCall_default(params, {
|
|
735
|
+
network: this.network,
|
|
736
|
+
signer: this.signer
|
|
737
|
+
});
|
|
738
|
+
return receipt.transactionHash;
|
|
739
|
+
}
|
|
740
|
+
async approveVault(params, options = {}) {
|
|
741
|
+
if (!("srcAsset" in params))
|
|
742
|
+
return null;
|
|
743
|
+
assert(this.signer, "No signer provided");
|
|
744
|
+
const receipt = await approveVault(params, {
|
|
745
|
+
signer: this.signer,
|
|
746
|
+
network: this.network,
|
|
747
|
+
...options
|
|
748
|
+
});
|
|
749
|
+
return receipt && receipt.transactionHash;
|
|
750
|
+
}
|
|
751
|
+
};
|
|
752
|
+
__name(SwapSDK, "SwapSDK");
|
|
753
|
+
|
|
754
|
+
export { SwapSDK };
|