@chainflip/sdk 1.1.5 → 1.2.0-rc.1
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/{broker-PDSDURH6.mjs → broker-Z7ASKYS2.mjs} +2 -2
- package/dist/{chunk-Q7HQVR3T.mjs → chunk-DV4HDL4K.mjs} +585 -5
- package/dist/chunk-M2FID654.mjs +27 -0
- package/dist/{chunk-MRYGGECA.mjs → chunk-OV3KFLWM.mjs} +31 -6
- package/dist/funding.js +614 -28
- package/dist/funding.mjs +2 -2
- package/dist/swap.d.mts +66 -11
- package/dist/swap.d.ts +66 -11
- package/dist/swap.js +74 -77
- package/dist/swap.mjs +48 -77
- package/package.json +1 -1
- package/dist/chunk-BF6CBSA3.mjs +0 -606
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import { z, __name, Assets, isNotNullish } from './chunk-
|
|
1
|
+
import { ccmMetadataSchema } from './chunk-M2FID654.mjs';
|
|
2
|
+
import { z, __name, Assets, chainflipAssetAndChain, numericString, hexString, btcAddress, hexStringFromNumber, isNotNullish, dotAddress, unsignedInteger } from './chunk-DV4HDL4K.mjs';
|
|
3
3
|
import { u8aToHex } from '@polkadot/util';
|
|
4
4
|
import { decodeAddress } from '@polkadot/util-crypto';
|
|
5
5
|
import axios from 'axios';
|
|
@@ -1,3 +1,7 @@
|
|
|
1
|
+
import { hexToU8a, u8aToHex } from '@polkadot/util';
|
|
2
|
+
import { encodeAddress, decodeAddress, base58Decode } from '@polkadot/util-crypto';
|
|
3
|
+
import * as ethers from 'ethers';
|
|
4
|
+
|
|
1
5
|
var __create = Object.create;
|
|
2
6
|
var __defProp = Object.defineProperty;
|
|
3
7
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
@@ -30,6 +34,423 @@ var __publicField = (obj, key, value) => {
|
|
|
30
34
|
return value;
|
|
31
35
|
};
|
|
32
36
|
|
|
37
|
+
// ../../node_modules/.pnpm/bech32-buffer@0.2.1_patch_hash=elryfzb6nrq4qzi6wcigmgsdj4/node_modules/bech32-buffer/lib/bit-converter.js
|
|
38
|
+
var require_bit_converter = __commonJS({
|
|
39
|
+
"../../node_modules/.pnpm/bech32-buffer@0.2.1_patch_hash=elryfzb6nrq4qzi6wcigmgsdj4/node_modules/bech32-buffer/lib/bit-converter.js"(exports) {
|
|
40
|
+
Object.defineProperty(exports, "__esModule", {
|
|
41
|
+
value: true
|
|
42
|
+
});
|
|
43
|
+
exports.createBitArray = createBitArray;
|
|
44
|
+
exports.fromBits = fromBits;
|
|
45
|
+
exports.toBits = toBits;
|
|
46
|
+
function toBitArrayUnchecked(src) {
|
|
47
|
+
return src;
|
|
48
|
+
}
|
|
49
|
+
__name(toBitArrayUnchecked, "toBitArrayUnchecked");
|
|
50
|
+
function createBitArray(len) {
|
|
51
|
+
return toBitArrayUnchecked(new Uint8Array(len));
|
|
52
|
+
}
|
|
53
|
+
__name(createBitArray, "createBitArray");
|
|
54
|
+
function convert(src, srcBits, dst, dstBits, pad) {
|
|
55
|
+
var mask = (1 << dstBits) - 1;
|
|
56
|
+
var acc = 0;
|
|
57
|
+
var bits = 0;
|
|
58
|
+
var pos = 0;
|
|
59
|
+
src.forEach(function(b) {
|
|
60
|
+
acc = (acc << srcBits) + b;
|
|
61
|
+
bits += srcBits;
|
|
62
|
+
while (bits >= dstBits) {
|
|
63
|
+
bits -= dstBits;
|
|
64
|
+
dst[pos] = acc >> bits & mask;
|
|
65
|
+
pos += 1;
|
|
66
|
+
}
|
|
67
|
+
});
|
|
68
|
+
if (pad) {
|
|
69
|
+
if (bits > 0) {
|
|
70
|
+
dst[pos] = acc << dstBits - bits & mask;
|
|
71
|
+
}
|
|
72
|
+
} else {
|
|
73
|
+
if (bits >= srcBits) {
|
|
74
|
+
throw new Error("Excessive padding: ".concat(bits, " (max ").concat(srcBits - 1, " allowed)"));
|
|
75
|
+
}
|
|
76
|
+
if (acc % (1 << bits) !== 0) {
|
|
77
|
+
throw new Error("Non-zero padding");
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
__name(convert, "convert");
|
|
82
|
+
function toBits(src, bits, dst) {
|
|
83
|
+
if (bits > 8 || bits < 1) {
|
|
84
|
+
throw new RangeError("Invalid bits per element; 1 to 8 expected");
|
|
85
|
+
}
|
|
86
|
+
convert(toBitArrayUnchecked(src), 8, dst, bits, true);
|
|
87
|
+
return dst;
|
|
88
|
+
}
|
|
89
|
+
__name(toBits, "toBits");
|
|
90
|
+
function fromBits(src, bits, dst) {
|
|
91
|
+
if (bits > 8 || bits < 1) {
|
|
92
|
+
throw new RangeError("Invalid bits per element; 1 to 8 expected");
|
|
93
|
+
}
|
|
94
|
+
convert(src, bits, toBitArrayUnchecked(dst), 8, false);
|
|
95
|
+
return dst;
|
|
96
|
+
}
|
|
97
|
+
__name(fromBits, "fromBits");
|
|
98
|
+
}
|
|
99
|
+
});
|
|
100
|
+
|
|
101
|
+
// ../../node_modules/.pnpm/bech32-buffer@0.2.1_patch_hash=elryfzb6nrq4qzi6wcigmgsdj4/node_modules/bech32-buffer/lib/encoding.js
|
|
102
|
+
var require_encoding = __commonJS({
|
|
103
|
+
"../../node_modules/.pnpm/bech32-buffer@0.2.1_patch_hash=elryfzb6nrq4qzi6wcigmgsdj4/node_modules/bech32-buffer/lib/encoding.js"(exports) {
|
|
104
|
+
Object.defineProperty(exports, "__esModule", {
|
|
105
|
+
value: true
|
|
106
|
+
});
|
|
107
|
+
exports.CHECKSUM_LENGTH = void 0;
|
|
108
|
+
exports.createChecksum = createChecksum;
|
|
109
|
+
exports.decode = decode;
|
|
110
|
+
exports.decodeWithPrefix = decodeWithPrefix;
|
|
111
|
+
exports.detectCase = detectCase;
|
|
112
|
+
exports.encode = encode;
|
|
113
|
+
exports.expandPrefix = expandPrefix;
|
|
114
|
+
exports.verifyChecksum = verifyChecksum;
|
|
115
|
+
var _bitConverter = require_bit_converter();
|
|
116
|
+
var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
|
|
117
|
+
var BECH32M_CHECKSUM = 734539939;
|
|
118
|
+
var MIN_CHAR_CODE = 33;
|
|
119
|
+
var MAX_CHAR_CODE = 126;
|
|
120
|
+
var CHECKSUM_LENGTH = 6;
|
|
121
|
+
exports.CHECKSUM_LENGTH = CHECKSUM_LENGTH;
|
|
122
|
+
var CHAR_LOOKUP = function() {
|
|
123
|
+
var lookup = /* @__PURE__ */ new Map();
|
|
124
|
+
for (var i = 0; i < CHARSET.length; i += 1) {
|
|
125
|
+
lookup.set(CHARSET[i], i);
|
|
126
|
+
}
|
|
127
|
+
return lookup;
|
|
128
|
+
}();
|
|
129
|
+
var GEN = [
|
|
130
|
+
996825010,
|
|
131
|
+
642813549,
|
|
132
|
+
513874426,
|
|
133
|
+
1027748829,
|
|
134
|
+
705979059
|
|
135
|
+
];
|
|
136
|
+
function polymod(values) {
|
|
137
|
+
return values.reduce(
|
|
138
|
+
function(checksum, value) {
|
|
139
|
+
var bits = checksum >> 25;
|
|
140
|
+
var newChecksum = (checksum & 33554431) << 5 ^ value;
|
|
141
|
+
return GEN.reduce(function(chk, gen, i) {
|
|
142
|
+
return (bits >> i & 1) === 0 ? chk : chk ^ gen;
|
|
143
|
+
}, newChecksum);
|
|
144
|
+
},
|
|
145
|
+
/* initial checksum */
|
|
146
|
+
1
|
|
147
|
+
);
|
|
148
|
+
}
|
|
149
|
+
__name(polymod, "polymod");
|
|
150
|
+
function expandPrefix(prefix, outBuffer) {
|
|
151
|
+
for (var i = 0; i < prefix.length; i += 1) {
|
|
152
|
+
var code = prefix.charCodeAt(i);
|
|
153
|
+
outBuffer[i] = code >> 5;
|
|
154
|
+
outBuffer[i + prefix.length + 1] = code & 31;
|
|
155
|
+
}
|
|
156
|
+
outBuffer[prefix.length] = 0;
|
|
157
|
+
}
|
|
158
|
+
__name(expandPrefix, "expandPrefix");
|
|
159
|
+
function verifyChecksum(buffer) {
|
|
160
|
+
switch (polymod(buffer)) {
|
|
161
|
+
case 1:
|
|
162
|
+
return "bech32";
|
|
163
|
+
case BECH32M_CHECKSUM:
|
|
164
|
+
return "bech32m";
|
|
165
|
+
default:
|
|
166
|
+
return void 0;
|
|
167
|
+
}
|
|
168
|
+
}
|
|
169
|
+
__name(verifyChecksum, "verifyChecksum");
|
|
170
|
+
function createChecksum(buffer, encoding) {
|
|
171
|
+
var checksumConstant;
|
|
172
|
+
switch (encoding) {
|
|
173
|
+
case "bech32":
|
|
174
|
+
checksumConstant = 1;
|
|
175
|
+
break;
|
|
176
|
+
case "bech32m":
|
|
177
|
+
checksumConstant = BECH32M_CHECKSUM;
|
|
178
|
+
break;
|
|
179
|
+
default:
|
|
180
|
+
throw Error("Invalid encoding value: ".concat(encoding, "; expected bech32 or bech32m"));
|
|
181
|
+
}
|
|
182
|
+
var mod = polymod(buffer) ^ checksumConstant;
|
|
183
|
+
for (var i = 0; i < CHECKSUM_LENGTH; i += 1) {
|
|
184
|
+
var shift = 5 * (5 - i);
|
|
185
|
+
buffer[buffer.length - CHECKSUM_LENGTH + i] = mod >> shift & 31;
|
|
186
|
+
}
|
|
187
|
+
}
|
|
188
|
+
__name(createChecksum, "createChecksum");
|
|
189
|
+
function encode(buffer) {
|
|
190
|
+
return buffer.reduce(function(acc, bits) {
|
|
191
|
+
return acc + CHARSET[bits];
|
|
192
|
+
}, "");
|
|
193
|
+
}
|
|
194
|
+
__name(encode, "encode");
|
|
195
|
+
function decode(message, dst) {
|
|
196
|
+
var realDst = dst || (0, _bitConverter.createBitArray)(message.length);
|
|
197
|
+
for (var i = 0; i < message.length; i += 1) {
|
|
198
|
+
var idx = CHAR_LOOKUP.get(message[i]);
|
|
199
|
+
if (idx === void 0) {
|
|
200
|
+
throw new Error("Invalid char in message: ".concat(message[i]));
|
|
201
|
+
}
|
|
202
|
+
realDst[i] = idx;
|
|
203
|
+
}
|
|
204
|
+
return realDst;
|
|
205
|
+
}
|
|
206
|
+
__name(decode, "decode");
|
|
207
|
+
function decodeWithPrefix(prefix, message) {
|
|
208
|
+
var len = message.length + 2 * prefix.length + 1;
|
|
209
|
+
var dst = (0, _bitConverter.createBitArray)(len);
|
|
210
|
+
expandPrefix(prefix, dst.subarray(0, 2 * prefix.length + 1));
|
|
211
|
+
decode(message, dst.subarray(2 * prefix.length + 1));
|
|
212
|
+
return dst;
|
|
213
|
+
}
|
|
214
|
+
__name(decodeWithPrefix, "decodeWithPrefix");
|
|
215
|
+
function detectCase(message) {
|
|
216
|
+
var messageDescription = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "message";
|
|
217
|
+
var hasLowerCase = false;
|
|
218
|
+
var hasUpperCase = false;
|
|
219
|
+
for (var i = 0; i < message.length; i += 1) {
|
|
220
|
+
var ord = message.charCodeAt(i);
|
|
221
|
+
if (ord < MIN_CHAR_CODE || ord > MAX_CHAR_CODE) {
|
|
222
|
+
throw new TypeError("Invalid char in ".concat(messageDescription, ": ").concat(ord, "; ") + "should be in ASCII range ".concat(MIN_CHAR_CODE, "-").concat(MAX_CHAR_CODE));
|
|
223
|
+
}
|
|
224
|
+
hasUpperCase = hasUpperCase || ord >= 65 && ord <= 90;
|
|
225
|
+
hasLowerCase = hasLowerCase || ord >= 97 && ord <= 122;
|
|
226
|
+
}
|
|
227
|
+
if (hasLowerCase && hasUpperCase) {
|
|
228
|
+
throw new TypeError("Mixed-case ".concat(messageDescription));
|
|
229
|
+
} else if (hasUpperCase) {
|
|
230
|
+
return "upper";
|
|
231
|
+
} else if (hasLowerCase) {
|
|
232
|
+
return "lower";
|
|
233
|
+
} else {
|
|
234
|
+
return null;
|
|
235
|
+
}
|
|
236
|
+
}
|
|
237
|
+
__name(detectCase, "detectCase");
|
|
238
|
+
}
|
|
239
|
+
});
|
|
240
|
+
|
|
241
|
+
// ../../node_modules/.pnpm/bech32-buffer@0.2.1_patch_hash=elryfzb6nrq4qzi6wcigmgsdj4/node_modules/bech32-buffer/lib/index.js
|
|
242
|
+
var require_lib = __commonJS({
|
|
243
|
+
"../../node_modules/.pnpm/bech32-buffer@0.2.1_patch_hash=elryfzb6nrq4qzi6wcigmgsdj4/node_modules/bech32-buffer/lib/index.js"(exports) {
|
|
244
|
+
Object.defineProperty(exports, "__esModule", {
|
|
245
|
+
value: true
|
|
246
|
+
});
|
|
247
|
+
exports.BitcoinAddress = void 0;
|
|
248
|
+
exports.decode = decode;
|
|
249
|
+
exports.decodeTo5BitArray = decodeTo5BitArray;
|
|
250
|
+
exports.encode = encode;
|
|
251
|
+
exports.encode5BitArray = encode5BitArray;
|
|
252
|
+
exports.from5BitArray = from5BitArray;
|
|
253
|
+
exports.to5BitArray = to5BitArray;
|
|
254
|
+
var _bitConverter = require_bit_converter();
|
|
255
|
+
var _encoding = require_encoding();
|
|
256
|
+
function _classCallCheck(instance, Constructor) {
|
|
257
|
+
if (!(instance instanceof Constructor)) {
|
|
258
|
+
throw new TypeError("Cannot call a class as a function");
|
|
259
|
+
}
|
|
260
|
+
}
|
|
261
|
+
__name(_classCallCheck, "_classCallCheck");
|
|
262
|
+
function _defineProperties(target, props) {
|
|
263
|
+
for (var i = 0; i < props.length; i++) {
|
|
264
|
+
var descriptor = props[i];
|
|
265
|
+
descriptor.enumerable = descriptor.enumerable || false;
|
|
266
|
+
descriptor.configurable = true;
|
|
267
|
+
if ("value" in descriptor)
|
|
268
|
+
descriptor.writable = true;
|
|
269
|
+
Object.defineProperty(target, descriptor.key, descriptor);
|
|
270
|
+
}
|
|
271
|
+
}
|
|
272
|
+
__name(_defineProperties, "_defineProperties");
|
|
273
|
+
function _createClass(Constructor, protoProps, staticProps) {
|
|
274
|
+
if (protoProps)
|
|
275
|
+
_defineProperties(Constructor.prototype, protoProps);
|
|
276
|
+
if (staticProps)
|
|
277
|
+
_defineProperties(Constructor, staticProps);
|
|
278
|
+
Object.defineProperty(Constructor, "prototype", {
|
|
279
|
+
writable: false
|
|
280
|
+
});
|
|
281
|
+
return Constructor;
|
|
282
|
+
}
|
|
283
|
+
__name(_createClass, "_createClass");
|
|
284
|
+
var MAX_ENC_LENGTH = 90;
|
|
285
|
+
function to5BitArray(src, dst) {
|
|
286
|
+
var len = Math.ceil(src.length * 8 / 5);
|
|
287
|
+
var realDst = dst || (0, _bitConverter.createBitArray)(len);
|
|
288
|
+
return (0, _bitConverter.toBits)(src, 5, realDst);
|
|
289
|
+
}
|
|
290
|
+
__name(to5BitArray, "to5BitArray");
|
|
291
|
+
function from5BitArray(src, dst) {
|
|
292
|
+
var len = Math.floor(src.length * 5 / 8);
|
|
293
|
+
var realDst = dst || new Uint8Array(len);
|
|
294
|
+
return (0, _bitConverter.fromBits)(src, 5, realDst);
|
|
295
|
+
}
|
|
296
|
+
__name(from5BitArray, "from5BitArray");
|
|
297
|
+
function encode5BitArray(prefix, data) {
|
|
298
|
+
var _detectCase;
|
|
299
|
+
var encoding = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "bech32";
|
|
300
|
+
var len = 2 * prefix.length + 1 + data.length + _encoding.CHECKSUM_LENGTH;
|
|
301
|
+
if (len - prefix.length > MAX_ENC_LENGTH) {
|
|
302
|
+
throw new Error("Message to be produced is too long (max ".concat(MAX_ENC_LENGTH, " supported)"));
|
|
303
|
+
}
|
|
304
|
+
var prefixCase = (_detectCase = (0, _encoding.detectCase)(prefix, "prefix")) !== null && _detectCase !== void 0 ? _detectCase : "lower";
|
|
305
|
+
var buffer = (0, _bitConverter.createBitArray)(len);
|
|
306
|
+
(0, _encoding.expandPrefix)(prefix.toLowerCase(), buffer.subarray(0, 2 * prefix.length + 1));
|
|
307
|
+
var dataBuffer = buffer.subarray(2 * prefix.length + 1, buffer.length - _encoding.CHECKSUM_LENGTH);
|
|
308
|
+
dataBuffer.set(data);
|
|
309
|
+
(0, _encoding.createChecksum)(buffer, encoding);
|
|
310
|
+
var encoded = (0, _encoding.encode)(buffer.subarray(2 * prefix.length + 1));
|
|
311
|
+
if (prefixCase === "upper") {
|
|
312
|
+
encoded = encoded.toUpperCase();
|
|
313
|
+
}
|
|
314
|
+
return "".concat(prefix, "1").concat(encoded);
|
|
315
|
+
}
|
|
316
|
+
__name(encode5BitArray, "encode5BitArray");
|
|
317
|
+
function encode(prefix, data) {
|
|
318
|
+
var encoding = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "bech32";
|
|
319
|
+
return encode5BitArray(prefix, to5BitArray(data), encoding);
|
|
320
|
+
}
|
|
321
|
+
__name(encode, "encode");
|
|
322
|
+
function decodeTo5BitArray(message) {
|
|
323
|
+
if (message.length > MAX_ENC_LENGTH) {
|
|
324
|
+
throw new TypeError("Message too long; max ".concat(MAX_ENC_LENGTH, " expected"));
|
|
325
|
+
}
|
|
326
|
+
(0, _encoding.detectCase)(message);
|
|
327
|
+
var lowerCaseMsg = message.toLowerCase();
|
|
328
|
+
var sepIdx = lowerCaseMsg.lastIndexOf("1");
|
|
329
|
+
if (sepIdx < 0) {
|
|
330
|
+
throw new Error('No separator char ("1") found');
|
|
331
|
+
}
|
|
332
|
+
if (sepIdx > message.length - _encoding.CHECKSUM_LENGTH - 1) {
|
|
333
|
+
throw new Error("Data part of the message too short (at least ".concat(_encoding.CHECKSUM_LENGTH, " chars expected)"));
|
|
334
|
+
}
|
|
335
|
+
var prefix = lowerCaseMsg.substring(0, sepIdx);
|
|
336
|
+
var bitArray = (0, _encoding.decodeWithPrefix)(prefix, lowerCaseMsg.substring(sepIdx + 1));
|
|
337
|
+
var encoding = (0, _encoding.verifyChecksum)(bitArray);
|
|
338
|
+
if (encoding === void 0) {
|
|
339
|
+
throw new Error("Invalid checksum");
|
|
340
|
+
}
|
|
341
|
+
return {
|
|
342
|
+
prefix,
|
|
343
|
+
encoding,
|
|
344
|
+
// Strip off the prefix from the front and the checksum from the end
|
|
345
|
+
data: bitArray.subarray(2 * prefix.length + 1, bitArray.length - _encoding.CHECKSUM_LENGTH)
|
|
346
|
+
};
|
|
347
|
+
}
|
|
348
|
+
__name(decodeTo5BitArray, "decodeTo5BitArray");
|
|
349
|
+
function decode(message) {
|
|
350
|
+
var _decodeTo5BitArray = decodeTo5BitArray(message), prefix = _decodeTo5BitArray.prefix, encoding = _decodeTo5BitArray.encoding, bitArray = _decodeTo5BitArray.data;
|
|
351
|
+
return {
|
|
352
|
+
prefix,
|
|
353
|
+
encoding,
|
|
354
|
+
data: from5BitArray(bitArray)
|
|
355
|
+
};
|
|
356
|
+
}
|
|
357
|
+
__name(decode, "decode");
|
|
358
|
+
var BitcoinAddress2 = /* @__PURE__ */ function() {
|
|
359
|
+
function BitcoinAddress3(prefix, scriptVersion, data) {
|
|
360
|
+
_classCallCheck(this, BitcoinAddress3);
|
|
361
|
+
if (prefix !== "bc" && prefix !== "tb" && prefix !== "bcrt") {
|
|
362
|
+
throw new Error('Invalid human-readable prefix, "bc", "tb", or "bcrt" expected');
|
|
363
|
+
}
|
|
364
|
+
if (scriptVersion < 0 || scriptVersion > 16) {
|
|
365
|
+
throw new RangeError("Invalid scriptVersion, value in range [0, 16] expected");
|
|
366
|
+
}
|
|
367
|
+
if (data.length < 2 || data.length > 40) {
|
|
368
|
+
throw new RangeError("Invalid script length: expected 2 to 40 bytes");
|
|
369
|
+
}
|
|
370
|
+
if (scriptVersion === 0 && data.length !== 20 && data.length !== 32) {
|
|
371
|
+
throw new Error("Invalid v0 script length: expected 20 or 32 bytes");
|
|
372
|
+
}
|
|
373
|
+
this.prefix = prefix;
|
|
374
|
+
this.scriptVersion = scriptVersion;
|
|
375
|
+
this.data = data;
|
|
376
|
+
}
|
|
377
|
+
__name(BitcoinAddress3, "BitcoinAddress");
|
|
378
|
+
_createClass(BitcoinAddress3, [
|
|
379
|
+
{
|
|
380
|
+
key: "type",
|
|
381
|
+
value: /* @__PURE__ */ __name(function type() {
|
|
382
|
+
if (this.scriptVersion !== 0) {
|
|
383
|
+
return void 0;
|
|
384
|
+
}
|
|
385
|
+
switch (this.data.length) {
|
|
386
|
+
case 20:
|
|
387
|
+
return "p2wpkh";
|
|
388
|
+
case 32:
|
|
389
|
+
return "p2wsh";
|
|
390
|
+
default:
|
|
391
|
+
return void 0;
|
|
392
|
+
}
|
|
393
|
+
}, "type")
|
|
394
|
+
},
|
|
395
|
+
{
|
|
396
|
+
key: "encode",
|
|
397
|
+
value: /* @__PURE__ */ __name(function encode2() {
|
|
398
|
+
var len = Math.ceil(this.data.length * 8 / 5);
|
|
399
|
+
var converted = (0, _bitConverter.createBitArray)(len + 1);
|
|
400
|
+
converted[0] = this.scriptVersion;
|
|
401
|
+
to5BitArray(this.data, converted.subarray(1));
|
|
402
|
+
var encoding = this.scriptVersion === 0 ? "bech32" : "bech32m";
|
|
403
|
+
return encode5BitArray(this.prefix, converted, encoding);
|
|
404
|
+
}, "encode")
|
|
405
|
+
}
|
|
406
|
+
], [
|
|
407
|
+
{
|
|
408
|
+
key: "decode",
|
|
409
|
+
value: (
|
|
410
|
+
/**
|
|
411
|
+
* Human-readable prefix. Equal to `'bc'` (for mainnet addresses)
|
|
412
|
+
* or `'tb'` (for testnet addresses).
|
|
413
|
+
*/
|
|
414
|
+
/**
|
|
415
|
+
* Script version. An integer between 0 and 16 (inclusive).
|
|
416
|
+
*/
|
|
417
|
+
/**
|
|
418
|
+
* Script data. A byte string with length 2 to 40 (inclusive).
|
|
419
|
+
*/
|
|
420
|
+
/**
|
|
421
|
+
* Decodes a Bitcoin address from a Bech32(m) string.
|
|
422
|
+
* As per BIP 350, the original encoding is expected for version 0 scripts, while
|
|
423
|
+
* other script versions expect the modified encoding.
|
|
424
|
+
*
|
|
425
|
+
* This method does not check whether the address is well-formed;
|
|
426
|
+
* use `type()` method on returned address to find that out.
|
|
427
|
+
*
|
|
428
|
+
* @param {string} message
|
|
429
|
+
* @returns {BitcoinAddress}
|
|
430
|
+
*/
|
|
431
|
+
/* @__PURE__ */ __name(function decode2(message) {
|
|
432
|
+
var _decodeTo5BitArray2 = decodeTo5BitArray(message), prefix = _decodeTo5BitArray2.prefix, data = _decodeTo5BitArray2.data, encoding = _decodeTo5BitArray2.encoding;
|
|
433
|
+
if (prefix !== "bc" && prefix !== "tb" && prefix !== "bcrt") {
|
|
434
|
+
throw new Error('Invalid human-readable prefix, "bc", "tb", or "bcrt" expected');
|
|
435
|
+
}
|
|
436
|
+
var scriptVersion = data[0];
|
|
437
|
+
if (scriptVersion === 0 && encoding !== "bech32") {
|
|
438
|
+
throw Error("Unexpected encoding ".concat(encoding, " used for version 0 script"));
|
|
439
|
+
}
|
|
440
|
+
if (scriptVersion > 0 && encoding !== "bech32m") {
|
|
441
|
+
throw Error("Unexpected encoding ".concat(encoding, " used for version ").concat(scriptVersion, " script"));
|
|
442
|
+
}
|
|
443
|
+
return new this(prefix, scriptVersion, from5BitArray(data.subarray(1)));
|
|
444
|
+
}, "decode")
|
|
445
|
+
)
|
|
446
|
+
}
|
|
447
|
+
]);
|
|
448
|
+
return BitcoinAddress3;
|
|
449
|
+
}();
|
|
450
|
+
exports.BitcoinAddress = BitcoinAddress2;
|
|
451
|
+
}
|
|
452
|
+
});
|
|
453
|
+
|
|
33
454
|
// ../shared/src/enums.ts
|
|
34
455
|
var arrayToMap = /* @__PURE__ */ __name((array) => Object.fromEntries(array.map((key) => [
|
|
35
456
|
key,
|
|
@@ -630,12 +1051,12 @@ var handleResult = /* @__PURE__ */ __name((ctx, result) => {
|
|
|
630
1051
|
function processCreateParams(params) {
|
|
631
1052
|
if (!params)
|
|
632
1053
|
return {};
|
|
633
|
-
const { errorMap:
|
|
634
|
-
if (
|
|
1054
|
+
const { errorMap: errorMap3, invalid_type_error, required_error, description } = params;
|
|
1055
|
+
if (errorMap3 && (invalid_type_error || required_error)) {
|
|
635
1056
|
throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
|
|
636
1057
|
}
|
|
637
|
-
if (
|
|
638
|
-
return { errorMap:
|
|
1058
|
+
if (errorMap3)
|
|
1059
|
+
return { errorMap: errorMap3, description };
|
|
639
1060
|
const customMap = /* @__PURE__ */ __name((iss, ctx) => {
|
|
640
1061
|
if (iss.code !== "invalid_type")
|
|
641
1062
|
return { message: ctx.defaultError };
|
|
@@ -3959,4 +4380,163 @@ var z = /* @__PURE__ */ Object.freeze({
|
|
|
3959
4380
|
ZodError
|
|
3960
4381
|
});
|
|
3961
4382
|
|
|
3962
|
-
|
|
4383
|
+
// ../shared/src/bitcoin.ts
|
|
4384
|
+
var import_bech32_buffer = __toESM(require_lib());
|
|
4385
|
+
var isValidSegwitAddress = /* @__PURE__ */ __name((address) => {
|
|
4386
|
+
const hrp = /^(bc|tb|bcrt)1/.exec(address)?.[1];
|
|
4387
|
+
if (!hrp)
|
|
4388
|
+
return false;
|
|
4389
|
+
return import_bech32_buffer.BitcoinAddress.decode(address).prefix === hrp;
|
|
4390
|
+
}, "isValidSegwitAddress");
|
|
4391
|
+
|
|
4392
|
+
// ../shared/src/validation/addressValidation.ts
|
|
4393
|
+
var assertArraylikeEqual = /* @__PURE__ */ __name((a, b) => {
|
|
4394
|
+
assert(a.length === b.length, "arraylike lengths must be equal");
|
|
4395
|
+
for (let i = 0; i < a.length; i += 1) {
|
|
4396
|
+
assert(a[i] === b[i], "arraylike elements must be equal");
|
|
4397
|
+
}
|
|
4398
|
+
}, "assertArraylikeEqual");
|
|
4399
|
+
var validateP2PKHOrP2SHAddress = /* @__PURE__ */ __name((address, network) => {
|
|
4400
|
+
try {
|
|
4401
|
+
const decoded = base58Decode(address);
|
|
4402
|
+
assert(decoded.length === 25, "decoded address must be 25 bytes long");
|
|
4403
|
+
if (network === "mainnet") {
|
|
4404
|
+
assert(decoded[0] === 0 || decoded[0] === 5, "decoded address must start with 0x00 or 0x05");
|
|
4405
|
+
} else {
|
|
4406
|
+
assert(decoded[0] === 111 || decoded[0] === 196, "decoded address must start with 0x6f or 0xc4");
|
|
4407
|
+
}
|
|
4408
|
+
const checksum = decoded.slice(-4);
|
|
4409
|
+
const doubleHash = ethers.getBytes(ethers.sha256(ethers.sha256(decoded.slice(0, 21))));
|
|
4410
|
+
assertArraylikeEqual(checksum, doubleHash.slice(0, 4));
|
|
4411
|
+
return true;
|
|
4412
|
+
} catch (error) {
|
|
4413
|
+
return false;
|
|
4414
|
+
}
|
|
4415
|
+
}, "validateP2PKHOrP2SHAddress");
|
|
4416
|
+
var validateSegwitAddress = /* @__PURE__ */ __name((address, network) => {
|
|
4417
|
+
try {
|
|
4418
|
+
assert(
|
|
4419
|
+
// On mainnet, the address must start with "bc1"
|
|
4420
|
+
network === "mainnet" && address.startsWith("bc1") || // on testnet it must start with "tb1"
|
|
4421
|
+
network === "testnet" && address.startsWith("tb1") || // on regtest it must start with "bcrt1"
|
|
4422
|
+
network === "regtest" && address.startsWith("bcrt1"),
|
|
4423
|
+
"address must start with bc1, tb1 or bcrt1"
|
|
4424
|
+
);
|
|
4425
|
+
return isValidSegwitAddress(address);
|
|
4426
|
+
} catch {
|
|
4427
|
+
return false;
|
|
4428
|
+
}
|
|
4429
|
+
}, "validateSegwitAddress");
|
|
4430
|
+
var validateBitcoinAddress = /* @__PURE__ */ __name((address, network) => validateP2PKHOrP2SHAddress(address, network) || validateSegwitAddress(address, network), "validateBitcoinAddress");
|
|
4431
|
+
var validateBitcoinMainnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "mainnet"), "validateBitcoinMainnetAddress");
|
|
4432
|
+
var validateBitcoinTestnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "testnet"), "validateBitcoinTestnetAddress");
|
|
4433
|
+
var validateBitcoinRegtestAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "regtest"), "validateBitcoinRegtestAddress");
|
|
4434
|
+
|
|
4435
|
+
// ../shared/src/parsers.ts
|
|
4436
|
+
var safeStringify = /* @__PURE__ */ __name((obj) => JSON.stringify(obj, (key, value) => typeof value === "bigint" ? value.toString() : value), "safeStringify");
|
|
4437
|
+
var errorMap2 = /* @__PURE__ */ __name((_issue, context) => ({
|
|
4438
|
+
message: `received: ${safeStringify(context.data)}`
|
|
4439
|
+
}), "errorMap");
|
|
4440
|
+
var string = z.string({
|
|
4441
|
+
errorMap: errorMap2
|
|
4442
|
+
});
|
|
4443
|
+
var number = z.number({
|
|
4444
|
+
errorMap: errorMap2
|
|
4445
|
+
});
|
|
4446
|
+
var numericString = string.regex(/^[0-9]+$/);
|
|
4447
|
+
var hexString = string.refine((v) => /^0x[0-9a-f]+$/i.test(v));
|
|
4448
|
+
var hexStringWithMaxByteSize = /* @__PURE__ */ __name((maxByteSize) => hexString.refine((val) => val.length / 2 <= maxByteSize + 1, {
|
|
4449
|
+
message: `String must be less than or equal to ${maxByteSize} bytes`
|
|
4450
|
+
}), "hexStringWithMaxByteSize");
|
|
4451
|
+
var hexStringFromNumber = numericString.transform((arg) => `0x${BigInt(arg).toString(16)}`);
|
|
4452
|
+
string.regex(/^[0-9a-f]+$/);
|
|
4453
|
+
var btcAddress = /* @__PURE__ */ __name((network) => {
|
|
4454
|
+
if (network === "mainnet") {
|
|
4455
|
+
return string.regex(/^(1|3|bc1)/).refine(validateBitcoinMainnetAddress);
|
|
4456
|
+
}
|
|
4457
|
+
return z.union([
|
|
4458
|
+
string.regex(/^(m|n|2|tb1)/).refine(validateBitcoinTestnetAddress),
|
|
4459
|
+
string.regex(/^bcrt1/).refine(validateBitcoinRegtestAddress)
|
|
4460
|
+
]);
|
|
4461
|
+
}, "btcAddress");
|
|
4462
|
+
var DOT_PREFIX = 0;
|
|
4463
|
+
var dotAddress = z.union([
|
|
4464
|
+
string,
|
|
4465
|
+
hexString
|
|
4466
|
+
]).transform((arg) => {
|
|
4467
|
+
try {
|
|
4468
|
+
if (arg.startsWith("0x")) {
|
|
4469
|
+
return encodeAddress(hexToU8a(arg), DOT_PREFIX);
|
|
4470
|
+
}
|
|
4471
|
+
const hex = u8aToHex(decodeAddress(arg));
|
|
4472
|
+
return encodeAddress(hex, DOT_PREFIX);
|
|
4473
|
+
} catch {
|
|
4474
|
+
return null;
|
|
4475
|
+
}
|
|
4476
|
+
}).refine(isString);
|
|
4477
|
+
var ethereumAddress = hexString.refine((address) => ethers.isAddress(address));
|
|
4478
|
+
numericString.transform((arg) => BigInt(arg));
|
|
4479
|
+
var u128 = z.union([
|
|
4480
|
+
number,
|
|
4481
|
+
numericString,
|
|
4482
|
+
hexString
|
|
4483
|
+
]).transform((arg) => BigInt(arg));
|
|
4484
|
+
var unsignedInteger = z.union([
|
|
4485
|
+
u128,
|
|
4486
|
+
z.number().transform((n) => BigInt(n))
|
|
4487
|
+
]);
|
|
4488
|
+
z.object({
|
|
4489
|
+
__kind: z.enum([
|
|
4490
|
+
"Usdc",
|
|
4491
|
+
"Flip",
|
|
4492
|
+
"Dot",
|
|
4493
|
+
"Eth",
|
|
4494
|
+
"Btc"
|
|
4495
|
+
])
|
|
4496
|
+
}).transform(({ __kind }) => __kind.toUpperCase());
|
|
4497
|
+
var transformAsset = /* @__PURE__ */ __name((asset) => ({
|
|
4498
|
+
asset,
|
|
4499
|
+
chain: assetChains[asset]
|
|
4500
|
+
}), "transformAsset");
|
|
4501
|
+
var chainflipChain = z.nativeEnum(Chains);
|
|
4502
|
+
var chainflipAsset = z.nativeEnum(Assets);
|
|
4503
|
+
var chainflipAssetAndChain = z.union([
|
|
4504
|
+
chainflipAsset.transform(transformAsset),
|
|
4505
|
+
z.object({
|
|
4506
|
+
asset: z.nativeEnum(Assets),
|
|
4507
|
+
chain: z.nativeEnum(Chains)
|
|
4508
|
+
})
|
|
4509
|
+
]).superRefine((obj, ctx) => {
|
|
4510
|
+
if (assetChains[obj.asset] !== obj.chain) {
|
|
4511
|
+
ctx.addIssue({
|
|
4512
|
+
code: z.ZodIssueCode.custom,
|
|
4513
|
+
message: `asset ${obj.asset} does not belong to chain ${obj.chain}`,
|
|
4514
|
+
path: []
|
|
4515
|
+
});
|
|
4516
|
+
}
|
|
4517
|
+
return z.NEVER;
|
|
4518
|
+
});
|
|
4519
|
+
z.nativeEnum(ChainflipNetworks);
|
|
4520
|
+
z.union([
|
|
4521
|
+
z.object({
|
|
4522
|
+
__kind: z.literal("CcmPrincipal"),
|
|
4523
|
+
value: unsignedInteger
|
|
4524
|
+
}).transform(({ value: ccmId }) => ({
|
|
4525
|
+
type: "PRINCIPAL",
|
|
4526
|
+
ccmId
|
|
4527
|
+
})),
|
|
4528
|
+
z.object({
|
|
4529
|
+
__kind: z.literal("CcmGas"),
|
|
4530
|
+
value: unsignedInteger
|
|
4531
|
+
}).transform(({ value: ccmId }) => ({
|
|
4532
|
+
type: "GAS",
|
|
4533
|
+
ccmId
|
|
4534
|
+
})),
|
|
4535
|
+
z.object({
|
|
4536
|
+
__kind: z.literal("Swap")
|
|
4537
|
+
}).transform(() => ({
|
|
4538
|
+
type: "SWAP"
|
|
4539
|
+
}))
|
|
4540
|
+
]);
|
|
4541
|
+
|
|
4542
|
+
export { Assets, ChainflipNetworks, Chains, __name, __publicField, assert, assertIsValidAssetAndChain, assetChains, assetContractIds, assetDecimals, btcAddress, chainAssets, chainContractIds, chainflipAsset, chainflipAssetAndChain, chainflipChain, dotAddress, ethereumAddress, hexString, hexStringFromNumber, hexStringWithMaxByteSize, isNotNullish, isTestnet, isTokenCall, isTokenSwap, numericString, unsignedInteger, z };
|
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
import { z, chainflipAssetAndChain, numericString, hexStringWithMaxByteSize, chainflipAsset, chainflipChain } from './chunk-DV4HDL4K.mjs';
|
|
2
|
+
|
|
3
|
+
// ../shared/src/schemas.ts
|
|
4
|
+
z.object({
|
|
5
|
+
srcAsset: chainflipAssetAndChain,
|
|
6
|
+
destAsset: chainflipAssetAndChain,
|
|
7
|
+
amount: numericString,
|
|
8
|
+
brokerCommissionBps: z.string().regex(/^[0-9]*$/).transform((v) => Number(v)).optional()
|
|
9
|
+
});
|
|
10
|
+
var ccmMetadataSchema = z.object({
|
|
11
|
+
gasBudget: numericString,
|
|
12
|
+
message: hexStringWithMaxByteSize(1024 * 10)
|
|
13
|
+
});
|
|
14
|
+
z.object({
|
|
15
|
+
srcAsset: chainflipAsset,
|
|
16
|
+
destAsset: chainflipAsset,
|
|
17
|
+
srcChain: chainflipChain,
|
|
18
|
+
destChain: chainflipChain,
|
|
19
|
+
destAddress: z.string(),
|
|
20
|
+
amount: numericString,
|
|
21
|
+
ccmMetadata: ccmMetadataSchema.optional()
|
|
22
|
+
}).transform(({ amount, ...rest }) => ({
|
|
23
|
+
...rest,
|
|
24
|
+
expectedDepositAmount: amount
|
|
25
|
+
}));
|
|
26
|
+
|
|
27
|
+
export { ccmMetadataSchema };
|