@chainflip/sdk 1.1.1 → 1.1.2
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-BDXRD56F.mjs → broker-IPTE3R72.mjs} +13 -13
- package/dist/{chunk-UTZ4VKAX.mjs → chunk-4PQXI2DE.mjs} +1 -1
- package/dist/{chunk-EQSMT5US.mjs → chunk-Q7HQVR3T.mjs} +25 -1
- package/dist/chunk-Z4OL2TKA.mjs +603 -0
- package/dist/{contracts-rsXvYw7v.d.mts → contracts-ss509umD.d.mts} +1 -1
- package/dist/{contracts-rsXvYw7v.d.ts → contracts-ss509umD.d.ts} +1 -1
- package/dist/funding.d.mts +1 -1
- package/dist/funding.d.ts +1 -1
- package/dist/funding.mjs +2 -2
- package/dist/swap.d.mts +36 -36
- package/dist/swap.d.ts +36 -36
- package/dist/swap.js +471 -214
- package/dist/swap.mjs +23 -22
- package/package.json +1 -1
- package/dist/chunk-KUNN7I5S.mjs +0 -371
package/dist/swap.js
CHANGED
|
@@ -28,17 +28,40 @@ function _interopNamespace(e) {
|
|
|
28
28
|
var ethers__namespace = /*#__PURE__*/_interopNamespace(ethers);
|
|
29
29
|
var axios2__default = /*#__PURE__*/_interopDefault(axios2);
|
|
30
30
|
|
|
31
|
+
var __create = Object.create;
|
|
31
32
|
var __defProp = Object.defineProperty;
|
|
33
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
32
34
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
35
|
+
var __getProtoOf = Object.getPrototypeOf;
|
|
36
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
33
37
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
34
38
|
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
|
35
39
|
var __esm = (fn, res) => function __init() {
|
|
36
40
|
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
|
|
37
41
|
};
|
|
42
|
+
var __commonJS = (cb, mod) => function __require() {
|
|
43
|
+
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
44
|
+
};
|
|
38
45
|
var __export = (target, all) => {
|
|
39
46
|
for (var name in all)
|
|
40
47
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
41
48
|
};
|
|
49
|
+
var __copyProps = (to, from, except, desc) => {
|
|
50
|
+
if (from && typeof from === "object" || typeof from === "function") {
|
|
51
|
+
for (let key of __getOwnPropNames(from))
|
|
52
|
+
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
53
|
+
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
54
|
+
}
|
|
55
|
+
return to;
|
|
56
|
+
};
|
|
57
|
+
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
58
|
+
// If the importer is in node compatibility mode or this is not an ESM
|
|
59
|
+
// file that has been converted to a CommonJS file using a Babel-
|
|
60
|
+
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
61
|
+
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
62
|
+
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
63
|
+
mod
|
|
64
|
+
));
|
|
42
65
|
var __publicField = (obj, key, value) => {
|
|
43
66
|
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
44
67
|
return value;
|
|
@@ -3984,207 +4007,440 @@ var init_lib = __esm({
|
|
|
3984
4007
|
}
|
|
3985
4008
|
});
|
|
3986
4009
|
|
|
3987
|
-
//
|
|
3988
|
-
var
|
|
3989
|
-
|
|
3990
|
-
|
|
3991
|
-
|
|
3992
|
-
|
|
4010
|
+
// ../../node_modules/.pnpm/bech32-buffer@0.2.1_patch_hash=elryfzb6nrq4qzi6wcigmgsdj4/node_modules/bech32-buffer/lib/bit-converter.js
|
|
4011
|
+
var require_bit_converter = __commonJS({
|
|
4012
|
+
"../../node_modules/.pnpm/bech32-buffer@0.2.1_patch_hash=elryfzb6nrq4qzi6wcigmgsdj4/node_modules/bech32-buffer/lib/bit-converter.js"(exports) {
|
|
4013
|
+
Object.defineProperty(exports, "__esModule", {
|
|
4014
|
+
value: true
|
|
4015
|
+
});
|
|
4016
|
+
exports.createBitArray = createBitArray;
|
|
4017
|
+
exports.fromBits = fromBits;
|
|
4018
|
+
exports.toBits = toBits;
|
|
4019
|
+
function toBitArrayUnchecked(src) {
|
|
4020
|
+
return src;
|
|
4021
|
+
}
|
|
4022
|
+
__name(toBitArrayUnchecked, "toBitArrayUnchecked");
|
|
4023
|
+
function createBitArray(len) {
|
|
4024
|
+
return toBitArrayUnchecked(new Uint8Array(len));
|
|
4025
|
+
}
|
|
4026
|
+
__name(createBitArray, "createBitArray");
|
|
4027
|
+
function convert(src, srcBits, dst, dstBits, pad) {
|
|
4028
|
+
var mask = (1 << dstBits) - 1;
|
|
4029
|
+
var acc = 0;
|
|
4030
|
+
var bits = 0;
|
|
4031
|
+
var pos = 0;
|
|
4032
|
+
src.forEach(function(b) {
|
|
4033
|
+
acc = (acc << srcBits) + b;
|
|
4034
|
+
bits += srcBits;
|
|
4035
|
+
while (bits >= dstBits) {
|
|
4036
|
+
bits -= dstBits;
|
|
4037
|
+
dst[pos] = acc >> bits & mask;
|
|
4038
|
+
pos += 1;
|
|
4039
|
+
}
|
|
4040
|
+
});
|
|
4041
|
+
if (pad) {
|
|
4042
|
+
if (bits > 0) {
|
|
4043
|
+
dst[pos] = acc << dstBits - bits & mask;
|
|
4044
|
+
}
|
|
4045
|
+
} else {
|
|
4046
|
+
if (bits >= srcBits) {
|
|
4047
|
+
throw new Error("Excessive padding: ".concat(bits, " (max ").concat(srcBits - 1, " allowed)"));
|
|
4048
|
+
}
|
|
4049
|
+
if (acc % (1 << bits) !== 0) {
|
|
4050
|
+
throw new Error("Non-zero padding");
|
|
4051
|
+
}
|
|
4052
|
+
}
|
|
4053
|
+
}
|
|
4054
|
+
__name(convert, "convert");
|
|
4055
|
+
function toBits(src, bits, dst) {
|
|
4056
|
+
if (bits > 8 || bits < 1) {
|
|
4057
|
+
throw new RangeError("Invalid bits per element; 1 to 8 expected");
|
|
4058
|
+
}
|
|
4059
|
+
convert(toBitArrayUnchecked(src), 8, dst, bits, true);
|
|
4060
|
+
return dst;
|
|
4061
|
+
}
|
|
4062
|
+
__name(toBits, "toBits");
|
|
4063
|
+
function fromBits(src, bits, dst) {
|
|
4064
|
+
if (bits > 8 || bits < 1) {
|
|
4065
|
+
throw new RangeError("Invalid bits per element; 1 to 8 expected");
|
|
4066
|
+
}
|
|
4067
|
+
convert(src, bits, toBitArrayUnchecked(dst), 8, false);
|
|
4068
|
+
return dst;
|
|
4069
|
+
}
|
|
4070
|
+
__name(fromBits, "fromBits");
|
|
4071
|
+
}
|
|
4072
|
+
});
|
|
4073
|
+
|
|
4074
|
+
// ../../node_modules/.pnpm/bech32-buffer@0.2.1_patch_hash=elryfzb6nrq4qzi6wcigmgsdj4/node_modules/bech32-buffer/lib/encoding.js
|
|
4075
|
+
var require_encoding = __commonJS({
|
|
4076
|
+
"../../node_modules/.pnpm/bech32-buffer@0.2.1_patch_hash=elryfzb6nrq4qzi6wcigmgsdj4/node_modules/bech32-buffer/lib/encoding.js"(exports) {
|
|
4077
|
+
Object.defineProperty(exports, "__esModule", {
|
|
4078
|
+
value: true
|
|
4079
|
+
});
|
|
4080
|
+
exports.CHECKSUM_LENGTH = void 0;
|
|
4081
|
+
exports.createChecksum = createChecksum;
|
|
4082
|
+
exports.decode = decode;
|
|
4083
|
+
exports.decodeWithPrefix = decodeWithPrefix;
|
|
4084
|
+
exports.detectCase = detectCase;
|
|
4085
|
+
exports.encode = encode;
|
|
4086
|
+
exports.expandPrefix = expandPrefix;
|
|
4087
|
+
exports.verifyChecksum = verifyChecksum;
|
|
4088
|
+
var _bitConverter = require_bit_converter();
|
|
4089
|
+
var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
|
|
4090
|
+
var BECH32M_CHECKSUM = 734539939;
|
|
4091
|
+
var MIN_CHAR_CODE = 33;
|
|
4092
|
+
var MAX_CHAR_CODE = 126;
|
|
4093
|
+
var CHECKSUM_LENGTH = 6;
|
|
4094
|
+
exports.CHECKSUM_LENGTH = CHECKSUM_LENGTH;
|
|
4095
|
+
var CHAR_LOOKUP = function() {
|
|
4096
|
+
var lookup = /* @__PURE__ */ new Map();
|
|
4097
|
+
for (var i = 0; i < CHARSET.length; i += 1) {
|
|
4098
|
+
lookup.set(CHARSET[i], i);
|
|
4099
|
+
}
|
|
4100
|
+
return lookup;
|
|
4101
|
+
}();
|
|
4102
|
+
var GEN = [
|
|
3993
4103
|
996825010,
|
|
3994
4104
|
642813549,
|
|
3995
4105
|
513874426,
|
|
3996
4106
|
1027748829,
|
|
3997
4107
|
705979059
|
|
3998
4108
|
];
|
|
3999
|
-
|
|
4000
|
-
|
|
4001
|
-
|
|
4002
|
-
|
|
4003
|
-
|
|
4004
|
-
|
|
4005
|
-
|
|
4006
|
-
|
|
4007
|
-
|
|
4008
|
-
|
|
4009
|
-
|
|
4010
|
-
|
|
4011
|
-
|
|
4012
|
-
|
|
4013
|
-
|
|
4014
|
-
|
|
4015
|
-
|
|
4016
|
-
|
|
4017
|
-
|
|
4018
|
-
|
|
4019
|
-
|
|
4020
|
-
|
|
4021
|
-
|
|
4022
|
-
|
|
4023
|
-
|
|
4024
|
-
|
|
4025
|
-
|
|
4026
|
-
|
|
4027
|
-
|
|
4028
|
-
|
|
4029
|
-
|
|
4030
|
-
ret.push(0);
|
|
4031
|
-
for (p = 0; p < hrp.length; p += 1) {
|
|
4032
|
-
ret.push(hrp.charCodeAt(p) & 31);
|
|
4033
|
-
}
|
|
4034
|
-
return ret;
|
|
4035
|
-
},
|
|
4036
|
-
verifyChecksum(hrp, data, enc) {
|
|
4037
|
-
return this.polymod(this.hrpExpand(hrp).concat(data)) === this.getEncodingConst(enc);
|
|
4038
|
-
},
|
|
4039
|
-
createChecksum(hrp, data, enc) {
|
|
4040
|
-
const values = this.hrpExpand(hrp).concat(data).concat([
|
|
4041
|
-
0,
|
|
4042
|
-
0,
|
|
4043
|
-
0,
|
|
4044
|
-
0,
|
|
4045
|
-
0,
|
|
4046
|
-
0
|
|
4047
|
-
]);
|
|
4048
|
-
const mod = this.polymod(values) ^ this.getEncodingConst(enc);
|
|
4049
|
-
const ret = [];
|
|
4050
|
-
for (let p = 0; p < 6; p += 1) {
|
|
4051
|
-
ret.push(mod >> 5 * (5 - p) & 31);
|
|
4052
|
-
}
|
|
4053
|
-
return ret;
|
|
4054
|
-
},
|
|
4055
|
-
encode(hrp, data, enc) {
|
|
4056
|
-
const combined = data.concat(this.createChecksum(hrp, data, enc));
|
|
4057
|
-
let ret = `${hrp}1`;
|
|
4058
|
-
for (let p = 0; p < combined.length; p += 1) {
|
|
4059
|
-
ret += CHARSET.charAt(combined[p]);
|
|
4060
|
-
}
|
|
4061
|
-
return ret;
|
|
4062
|
-
},
|
|
4063
|
-
decode(bechString, enc) {
|
|
4064
|
-
let p;
|
|
4065
|
-
let hasLower = false;
|
|
4066
|
-
let hasUpper = false;
|
|
4067
|
-
for (p = 0; p < bechString.length; p += 1) {
|
|
4068
|
-
if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126) {
|
|
4069
|
-
return null;
|
|
4070
|
-
}
|
|
4071
|
-
if (bechString.charCodeAt(p) >= 97 && bechString.charCodeAt(p) <= 122) {
|
|
4072
|
-
hasLower = true;
|
|
4073
|
-
}
|
|
4074
|
-
if (bechString.charCodeAt(p) >= 65 && bechString.charCodeAt(p) <= 90) {
|
|
4075
|
-
hasUpper = true;
|
|
4076
|
-
}
|
|
4077
|
-
}
|
|
4078
|
-
if (hasLower && hasUpper)
|
|
4079
|
-
return null;
|
|
4080
|
-
const lowercase = bechString.toLowerCase();
|
|
4081
|
-
const pos = lowercase.lastIndexOf("1");
|
|
4082
|
-
if (pos < 1 || pos + 7 > lowercase.length || lowercase.length > 90) {
|
|
4083
|
-
return null;
|
|
4084
|
-
}
|
|
4085
|
-
const hrp = lowercase.substring(0, pos);
|
|
4086
|
-
const data = [];
|
|
4087
|
-
for (p = pos + 1; p < lowercase.length; p += 1) {
|
|
4088
|
-
const d = CHARSET.indexOf(lowercase.charAt(p));
|
|
4089
|
-
if (d === -1)
|
|
4090
|
-
return null;
|
|
4091
|
-
data.push(d);
|
|
4092
|
-
}
|
|
4093
|
-
if (!this.verifyChecksum(hrp, data, enc)) {
|
|
4094
|
-
return null;
|
|
4095
|
-
}
|
|
4096
|
-
return {
|
|
4097
|
-
hrp,
|
|
4098
|
-
data: data.slice(0, data.length - 6)
|
|
4099
|
-
};
|
|
4109
|
+
function polymod(values) {
|
|
4110
|
+
return values.reduce(
|
|
4111
|
+
function(checksum, value) {
|
|
4112
|
+
var bits = checksum >> 25;
|
|
4113
|
+
var newChecksum = (checksum & 33554431) << 5 ^ value;
|
|
4114
|
+
return GEN.reduce(function(chk, gen, i) {
|
|
4115
|
+
return (bits >> i & 1) === 0 ? chk : chk ^ gen;
|
|
4116
|
+
}, newChecksum);
|
|
4117
|
+
},
|
|
4118
|
+
/* initial checksum */
|
|
4119
|
+
1
|
|
4120
|
+
);
|
|
4121
|
+
}
|
|
4122
|
+
__name(polymod, "polymod");
|
|
4123
|
+
function expandPrefix(prefix, outBuffer) {
|
|
4124
|
+
for (var i = 0; i < prefix.length; i += 1) {
|
|
4125
|
+
var code = prefix.charCodeAt(i);
|
|
4126
|
+
outBuffer[i] = code >> 5;
|
|
4127
|
+
outBuffer[i + prefix.length + 1] = code & 31;
|
|
4128
|
+
}
|
|
4129
|
+
outBuffer[prefix.length] = 0;
|
|
4130
|
+
}
|
|
4131
|
+
__name(expandPrefix, "expandPrefix");
|
|
4132
|
+
function verifyChecksum(buffer) {
|
|
4133
|
+
switch (polymod(buffer)) {
|
|
4134
|
+
case 1:
|
|
4135
|
+
return "bech32";
|
|
4136
|
+
case BECH32M_CHECKSUM:
|
|
4137
|
+
return "bech32m";
|
|
4138
|
+
default:
|
|
4139
|
+
return void 0;
|
|
4100
4140
|
}
|
|
4101
|
-
}
|
|
4102
|
-
|
|
4103
|
-
|
|
4104
|
-
|
|
4105
|
-
|
|
4106
|
-
|
|
4107
|
-
|
|
4108
|
-
|
|
4109
|
-
|
|
4110
|
-
|
|
4111
|
-
|
|
4112
|
-
|
|
4113
|
-
|
|
4114
|
-
|
|
4115
|
-
|
|
4116
|
-
|
|
4117
|
-
|
|
4118
|
-
|
|
4119
|
-
|
|
4120
|
-
|
|
4121
|
-
|
|
4122
|
-
|
|
4123
|
-
|
|
4124
|
-
|
|
4125
|
-
|
|
4126
|
-
|
|
4127
|
-
|
|
4128
|
-
|
|
4129
|
-
|
|
4130
|
-
|
|
4131
|
-
|
|
4132
|
-
if (
|
|
4133
|
-
|
|
4134
|
-
bech32m = true;
|
|
4135
|
-
}
|
|
4136
|
-
if (dec === null || dec.hrp !== hrp || dec.data.length < 1 || dec.data[0] > 16) {
|
|
4137
|
-
return null;
|
|
4138
|
-
}
|
|
4139
|
-
const res = this.convertbits(dec.data.slice(1), 5, 8, false);
|
|
4140
|
-
if (res === null || res.length < 2 || res.length > 40) {
|
|
4141
|
-
return null;
|
|
4142
|
-
}
|
|
4143
|
-
if (dec.data[0] === 0 && res.length !== 20 && res.length !== 32) {
|
|
4144
|
-
return null;
|
|
4145
|
-
}
|
|
4146
|
-
if (dec.data[0] === 0 && bech32m) {
|
|
4147
|
-
return null;
|
|
4148
|
-
}
|
|
4149
|
-
if (dec.data[0] !== 0 && !bech32m) {
|
|
4150
|
-
return null;
|
|
4151
|
-
}
|
|
4152
|
-
return {
|
|
4153
|
-
version: dec.data[0],
|
|
4154
|
-
program: res
|
|
4155
|
-
};
|
|
4156
|
-
},
|
|
4157
|
-
encode(hrp, version, program) {
|
|
4158
|
-
let enc = "bech32";
|
|
4159
|
-
if (version > 0) {
|
|
4160
|
-
enc = "bech32m";
|
|
4161
|
-
}
|
|
4162
|
-
const ret = bech32.encode(
|
|
4163
|
-
hrp,
|
|
4164
|
-
// @ts-expect-error can be null
|
|
4165
|
-
[
|
|
4166
|
-
version
|
|
4167
|
-
].concat(this.convertbits(program, 8, 5, true)),
|
|
4168
|
-
enc
|
|
4169
|
-
);
|
|
4170
|
-
if (this.decode(hrp, ret) === null) {
|
|
4171
|
-
return null;
|
|
4141
|
+
}
|
|
4142
|
+
__name(verifyChecksum, "verifyChecksum");
|
|
4143
|
+
function createChecksum(buffer, encoding) {
|
|
4144
|
+
var checksumConstant;
|
|
4145
|
+
switch (encoding) {
|
|
4146
|
+
case "bech32":
|
|
4147
|
+
checksumConstant = 1;
|
|
4148
|
+
break;
|
|
4149
|
+
case "bech32m":
|
|
4150
|
+
checksumConstant = BECH32M_CHECKSUM;
|
|
4151
|
+
break;
|
|
4152
|
+
default:
|
|
4153
|
+
throw Error("Invalid encoding value: ".concat(encoding, "; expected bech32 or bech32m"));
|
|
4154
|
+
}
|
|
4155
|
+
var mod = polymod(buffer) ^ checksumConstant;
|
|
4156
|
+
for (var i = 0; i < CHECKSUM_LENGTH; i += 1) {
|
|
4157
|
+
var shift = 5 * (5 - i);
|
|
4158
|
+
buffer[buffer.length - CHECKSUM_LENGTH + i] = mod >> shift & 31;
|
|
4159
|
+
}
|
|
4160
|
+
}
|
|
4161
|
+
__name(createChecksum, "createChecksum");
|
|
4162
|
+
function encode(buffer) {
|
|
4163
|
+
return buffer.reduce(function(acc, bits) {
|
|
4164
|
+
return acc + CHARSET[bits];
|
|
4165
|
+
}, "");
|
|
4166
|
+
}
|
|
4167
|
+
__name(encode, "encode");
|
|
4168
|
+
function decode(message, dst) {
|
|
4169
|
+
var realDst = dst || (0, _bitConverter.createBitArray)(message.length);
|
|
4170
|
+
for (var i = 0; i < message.length; i += 1) {
|
|
4171
|
+
var idx = CHAR_LOOKUP.get(message[i]);
|
|
4172
|
+
if (idx === void 0) {
|
|
4173
|
+
throw new Error("Invalid char in message: ".concat(message[i]));
|
|
4172
4174
|
}
|
|
4173
|
-
|
|
4175
|
+
realDst[i] = idx;
|
|
4174
4176
|
}
|
|
4175
|
-
|
|
4177
|
+
return realDst;
|
|
4178
|
+
}
|
|
4179
|
+
__name(decode, "decode");
|
|
4180
|
+
function decodeWithPrefix(prefix, message) {
|
|
4181
|
+
var len = message.length + 2 * prefix.length + 1;
|
|
4182
|
+
var dst = (0, _bitConverter.createBitArray)(len);
|
|
4183
|
+
expandPrefix(prefix, dst.subarray(0, 2 * prefix.length + 1));
|
|
4184
|
+
decode(message, dst.subarray(2 * prefix.length + 1));
|
|
4185
|
+
return dst;
|
|
4186
|
+
}
|
|
4187
|
+
__name(decodeWithPrefix, "decodeWithPrefix");
|
|
4188
|
+
function detectCase(message) {
|
|
4189
|
+
var messageDescription = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "message";
|
|
4190
|
+
var hasLowerCase = false;
|
|
4191
|
+
var hasUpperCase = false;
|
|
4192
|
+
for (var i = 0; i < message.length; i += 1) {
|
|
4193
|
+
var ord = message.charCodeAt(i);
|
|
4194
|
+
if (ord < MIN_CHAR_CODE || ord > MAX_CHAR_CODE) {
|
|
4195
|
+
throw new TypeError("Invalid char in ".concat(messageDescription, ": ").concat(ord, "; ") + "should be in ASCII range ".concat(MIN_CHAR_CODE, "-").concat(MAX_CHAR_CODE));
|
|
4196
|
+
}
|
|
4197
|
+
hasUpperCase = hasUpperCase || ord >= 65 && ord <= 90;
|
|
4198
|
+
hasLowerCase = hasLowerCase || ord >= 97 && ord <= 122;
|
|
4199
|
+
}
|
|
4200
|
+
if (hasLowerCase && hasUpperCase) {
|
|
4201
|
+
throw new TypeError("Mixed-case ".concat(messageDescription));
|
|
4202
|
+
} else if (hasUpperCase) {
|
|
4203
|
+
return "upper";
|
|
4204
|
+
} else if (hasLowerCase) {
|
|
4205
|
+
return "lower";
|
|
4206
|
+
} else {
|
|
4207
|
+
return null;
|
|
4208
|
+
}
|
|
4209
|
+
}
|
|
4210
|
+
__name(detectCase, "detectCase");
|
|
4211
|
+
}
|
|
4212
|
+
});
|
|
4213
|
+
|
|
4214
|
+
// ../../node_modules/.pnpm/bech32-buffer@0.2.1_patch_hash=elryfzb6nrq4qzi6wcigmgsdj4/node_modules/bech32-buffer/lib/index.js
|
|
4215
|
+
var require_lib = __commonJS({
|
|
4216
|
+
"../../node_modules/.pnpm/bech32-buffer@0.2.1_patch_hash=elryfzb6nrq4qzi6wcigmgsdj4/node_modules/bech32-buffer/lib/index.js"(exports) {
|
|
4217
|
+
Object.defineProperty(exports, "__esModule", {
|
|
4218
|
+
value: true
|
|
4219
|
+
});
|
|
4220
|
+
exports.BitcoinAddress = void 0;
|
|
4221
|
+
exports.decode = decode;
|
|
4222
|
+
exports.decodeTo5BitArray = decodeTo5BitArray;
|
|
4223
|
+
exports.encode = encode;
|
|
4224
|
+
exports.encode5BitArray = encode5BitArray;
|
|
4225
|
+
exports.from5BitArray = from5BitArray;
|
|
4226
|
+
exports.to5BitArray = to5BitArray;
|
|
4227
|
+
var _bitConverter = require_bit_converter();
|
|
4228
|
+
var _encoding = require_encoding();
|
|
4229
|
+
function _classCallCheck(instance, Constructor) {
|
|
4230
|
+
if (!(instance instanceof Constructor)) {
|
|
4231
|
+
throw new TypeError("Cannot call a class as a function");
|
|
4232
|
+
}
|
|
4233
|
+
}
|
|
4234
|
+
__name(_classCallCheck, "_classCallCheck");
|
|
4235
|
+
function _defineProperties(target, props) {
|
|
4236
|
+
for (var i = 0; i < props.length; i++) {
|
|
4237
|
+
var descriptor = props[i];
|
|
4238
|
+
descriptor.enumerable = descriptor.enumerable || false;
|
|
4239
|
+
descriptor.configurable = true;
|
|
4240
|
+
if ("value" in descriptor)
|
|
4241
|
+
descriptor.writable = true;
|
|
4242
|
+
Object.defineProperty(target, descriptor.key, descriptor);
|
|
4243
|
+
}
|
|
4244
|
+
}
|
|
4245
|
+
__name(_defineProperties, "_defineProperties");
|
|
4246
|
+
function _createClass(Constructor, protoProps, staticProps) {
|
|
4247
|
+
if (protoProps)
|
|
4248
|
+
_defineProperties(Constructor.prototype, protoProps);
|
|
4249
|
+
if (staticProps)
|
|
4250
|
+
_defineProperties(Constructor, staticProps);
|
|
4251
|
+
Object.defineProperty(Constructor, "prototype", {
|
|
4252
|
+
writable: false
|
|
4253
|
+
});
|
|
4254
|
+
return Constructor;
|
|
4255
|
+
}
|
|
4256
|
+
__name(_createClass, "_createClass");
|
|
4257
|
+
var MAX_ENC_LENGTH = 90;
|
|
4258
|
+
function to5BitArray(src, dst) {
|
|
4259
|
+
var len = Math.ceil(src.length * 8 / 5);
|
|
4260
|
+
var realDst = dst || (0, _bitConverter.createBitArray)(len);
|
|
4261
|
+
return (0, _bitConverter.toBits)(src, 5, realDst);
|
|
4262
|
+
}
|
|
4263
|
+
__name(to5BitArray, "to5BitArray");
|
|
4264
|
+
function from5BitArray(src, dst) {
|
|
4265
|
+
var len = Math.floor(src.length * 5 / 8);
|
|
4266
|
+
var realDst = dst || new Uint8Array(len);
|
|
4267
|
+
return (0, _bitConverter.fromBits)(src, 5, realDst);
|
|
4268
|
+
}
|
|
4269
|
+
__name(from5BitArray, "from5BitArray");
|
|
4270
|
+
function encode5BitArray(prefix, data) {
|
|
4271
|
+
var _detectCase;
|
|
4272
|
+
var encoding = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "bech32";
|
|
4273
|
+
var len = 2 * prefix.length + 1 + data.length + _encoding.CHECKSUM_LENGTH;
|
|
4274
|
+
if (len - prefix.length > MAX_ENC_LENGTH) {
|
|
4275
|
+
throw new Error("Message to be produced is too long (max ".concat(MAX_ENC_LENGTH, " supported)"));
|
|
4276
|
+
}
|
|
4277
|
+
var prefixCase = (_detectCase = (0, _encoding.detectCase)(prefix, "prefix")) !== null && _detectCase !== void 0 ? _detectCase : "lower";
|
|
4278
|
+
var buffer = (0, _bitConverter.createBitArray)(len);
|
|
4279
|
+
(0, _encoding.expandPrefix)(prefix.toLowerCase(), buffer.subarray(0, 2 * prefix.length + 1));
|
|
4280
|
+
var dataBuffer = buffer.subarray(2 * prefix.length + 1, buffer.length - _encoding.CHECKSUM_LENGTH);
|
|
4281
|
+
dataBuffer.set(data);
|
|
4282
|
+
(0, _encoding.createChecksum)(buffer, encoding);
|
|
4283
|
+
var encoded = (0, _encoding.encode)(buffer.subarray(2 * prefix.length + 1));
|
|
4284
|
+
if (prefixCase === "upper") {
|
|
4285
|
+
encoded = encoded.toUpperCase();
|
|
4286
|
+
}
|
|
4287
|
+
return "".concat(prefix, "1").concat(encoded);
|
|
4288
|
+
}
|
|
4289
|
+
__name(encode5BitArray, "encode5BitArray");
|
|
4290
|
+
function encode(prefix, data) {
|
|
4291
|
+
var encoding = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "bech32";
|
|
4292
|
+
return encode5BitArray(prefix, to5BitArray(data), encoding);
|
|
4293
|
+
}
|
|
4294
|
+
__name(encode, "encode");
|
|
4295
|
+
function decodeTo5BitArray(message) {
|
|
4296
|
+
if (message.length > MAX_ENC_LENGTH) {
|
|
4297
|
+
throw new TypeError("Message too long; max ".concat(MAX_ENC_LENGTH, " expected"));
|
|
4298
|
+
}
|
|
4299
|
+
(0, _encoding.detectCase)(message);
|
|
4300
|
+
var lowerCaseMsg = message.toLowerCase();
|
|
4301
|
+
var sepIdx = lowerCaseMsg.lastIndexOf("1");
|
|
4302
|
+
if (sepIdx < 0) {
|
|
4303
|
+
throw new Error('No separator char ("1") found');
|
|
4304
|
+
}
|
|
4305
|
+
if (sepIdx > message.length - _encoding.CHECKSUM_LENGTH - 1) {
|
|
4306
|
+
throw new Error("Data part of the message too short (at least ".concat(_encoding.CHECKSUM_LENGTH, " chars expected)"));
|
|
4307
|
+
}
|
|
4308
|
+
var prefix = lowerCaseMsg.substring(0, sepIdx);
|
|
4309
|
+
var bitArray = (0, _encoding.decodeWithPrefix)(prefix, lowerCaseMsg.substring(sepIdx + 1));
|
|
4310
|
+
var encoding = (0, _encoding.verifyChecksum)(bitArray);
|
|
4311
|
+
if (encoding === void 0) {
|
|
4312
|
+
throw new Error("Invalid checksum");
|
|
4313
|
+
}
|
|
4314
|
+
return {
|
|
4315
|
+
prefix,
|
|
4316
|
+
encoding,
|
|
4317
|
+
// Strip off the prefix from the front and the checksum from the end
|
|
4318
|
+
data: bitArray.subarray(2 * prefix.length + 1, bitArray.length - _encoding.CHECKSUM_LENGTH)
|
|
4319
|
+
};
|
|
4320
|
+
}
|
|
4321
|
+
__name(decodeTo5BitArray, "decodeTo5BitArray");
|
|
4322
|
+
function decode(message) {
|
|
4323
|
+
var _decodeTo5BitArray = decodeTo5BitArray(message), prefix = _decodeTo5BitArray.prefix, encoding = _decodeTo5BitArray.encoding, bitArray = _decodeTo5BitArray.data;
|
|
4324
|
+
return {
|
|
4325
|
+
prefix,
|
|
4326
|
+
encoding,
|
|
4327
|
+
data: from5BitArray(bitArray)
|
|
4328
|
+
};
|
|
4329
|
+
}
|
|
4330
|
+
__name(decode, "decode");
|
|
4331
|
+
var BitcoinAddress2 = /* @__PURE__ */ function() {
|
|
4332
|
+
function BitcoinAddress3(prefix, scriptVersion, data) {
|
|
4333
|
+
_classCallCheck(this, BitcoinAddress3);
|
|
4334
|
+
if (prefix !== "bc" && prefix !== "tb" && prefix !== "bcrt") {
|
|
4335
|
+
throw new Error('Invalid human-readable prefix, "bc", "tb", or "bcrt" expected');
|
|
4336
|
+
}
|
|
4337
|
+
if (scriptVersion < 0 || scriptVersion > 16) {
|
|
4338
|
+
throw new RangeError("Invalid scriptVersion, value in range [0, 16] expected");
|
|
4339
|
+
}
|
|
4340
|
+
if (data.length < 2 || data.length > 40) {
|
|
4341
|
+
throw new RangeError("Invalid script length: expected 2 to 40 bytes");
|
|
4342
|
+
}
|
|
4343
|
+
if (scriptVersion === 0 && data.length !== 20 && data.length !== 32) {
|
|
4344
|
+
throw new Error("Invalid v0 script length: expected 20 or 32 bytes");
|
|
4345
|
+
}
|
|
4346
|
+
this.prefix = prefix;
|
|
4347
|
+
this.scriptVersion = scriptVersion;
|
|
4348
|
+
this.data = data;
|
|
4349
|
+
}
|
|
4350
|
+
__name(BitcoinAddress3, "BitcoinAddress");
|
|
4351
|
+
_createClass(BitcoinAddress3, [
|
|
4352
|
+
{
|
|
4353
|
+
key: "type",
|
|
4354
|
+
value: /* @__PURE__ */ __name(function type() {
|
|
4355
|
+
if (this.scriptVersion !== 0) {
|
|
4356
|
+
return void 0;
|
|
4357
|
+
}
|
|
4358
|
+
switch (this.data.length) {
|
|
4359
|
+
case 20:
|
|
4360
|
+
return "p2wpkh";
|
|
4361
|
+
case 32:
|
|
4362
|
+
return "p2wsh";
|
|
4363
|
+
default:
|
|
4364
|
+
return void 0;
|
|
4365
|
+
}
|
|
4366
|
+
}, "type")
|
|
4367
|
+
},
|
|
4368
|
+
{
|
|
4369
|
+
key: "encode",
|
|
4370
|
+
value: /* @__PURE__ */ __name(function encode2() {
|
|
4371
|
+
var len = Math.ceil(this.data.length * 8 / 5);
|
|
4372
|
+
var converted = (0, _bitConverter.createBitArray)(len + 1);
|
|
4373
|
+
converted[0] = this.scriptVersion;
|
|
4374
|
+
to5BitArray(this.data, converted.subarray(1));
|
|
4375
|
+
var encoding = this.scriptVersion === 0 ? "bech32" : "bech32m";
|
|
4376
|
+
return encode5BitArray(this.prefix, converted, encoding);
|
|
4377
|
+
}, "encode")
|
|
4378
|
+
}
|
|
4379
|
+
], [
|
|
4380
|
+
{
|
|
4381
|
+
key: "decode",
|
|
4382
|
+
value: (
|
|
4383
|
+
/**
|
|
4384
|
+
* Human-readable prefix. Equal to `'bc'` (for mainnet addresses)
|
|
4385
|
+
* or `'tb'` (for testnet addresses).
|
|
4386
|
+
*/
|
|
4387
|
+
/**
|
|
4388
|
+
* Script version. An integer between 0 and 16 (inclusive).
|
|
4389
|
+
*/
|
|
4390
|
+
/**
|
|
4391
|
+
* Script data. A byte string with length 2 to 40 (inclusive).
|
|
4392
|
+
*/
|
|
4393
|
+
/**
|
|
4394
|
+
* Decodes a Bitcoin address from a Bech32(m) string.
|
|
4395
|
+
* As per BIP 350, the original encoding is expected for version 0 scripts, while
|
|
4396
|
+
* other script versions expect the modified encoding.
|
|
4397
|
+
*
|
|
4398
|
+
* This method does not check whether the address is well-formed;
|
|
4399
|
+
* use `type()` method on returned address to find that out.
|
|
4400
|
+
*
|
|
4401
|
+
* @param {string} message
|
|
4402
|
+
* @returns {BitcoinAddress}
|
|
4403
|
+
*/
|
|
4404
|
+
/* @__PURE__ */ __name(function decode2(message) {
|
|
4405
|
+
var _decodeTo5BitArray2 = decodeTo5BitArray(message), prefix = _decodeTo5BitArray2.prefix, data = _decodeTo5BitArray2.data, encoding = _decodeTo5BitArray2.encoding;
|
|
4406
|
+
if (prefix !== "bc" && prefix !== "tb" && prefix !== "bcrt") {
|
|
4407
|
+
throw new Error('Invalid human-readable prefix, "bc", "tb", or "bcrt" expected');
|
|
4408
|
+
}
|
|
4409
|
+
var scriptVersion = data[0];
|
|
4410
|
+
if (scriptVersion === 0 && encoding !== "bech32") {
|
|
4411
|
+
throw Error("Unexpected encoding ".concat(encoding, " used for version 0 script"));
|
|
4412
|
+
}
|
|
4413
|
+
if (scriptVersion > 0 && encoding !== "bech32m") {
|
|
4414
|
+
throw Error("Unexpected encoding ".concat(encoding, " used for version ").concat(scriptVersion, " script"));
|
|
4415
|
+
}
|
|
4416
|
+
return new this(prefix, scriptVersion, from5BitArray(data.subarray(1)));
|
|
4417
|
+
}, "decode")
|
|
4418
|
+
)
|
|
4419
|
+
}
|
|
4420
|
+
]);
|
|
4421
|
+
return BitcoinAddress3;
|
|
4422
|
+
}();
|
|
4423
|
+
exports.BitcoinAddress = BitcoinAddress2;
|
|
4424
|
+
}
|
|
4425
|
+
});
|
|
4426
|
+
|
|
4427
|
+
// ../shared/src/bitcoin.ts
|
|
4428
|
+
var import_bech32_buffer, isValidSegwitAddress;
|
|
4429
|
+
var init_bitcoin = __esm({
|
|
4430
|
+
"../shared/src/bitcoin.ts"() {
|
|
4431
|
+
import_bech32_buffer = __toESM(require_lib());
|
|
4176
4432
|
isValidSegwitAddress = /* @__PURE__ */ __name((address) => {
|
|
4177
4433
|
const hrp = /^(bc|tb|bcrt)1/.exec(address)?.[1];
|
|
4178
4434
|
if (!hrp)
|
|
4179
4435
|
return false;
|
|
4180
|
-
return
|
|
4436
|
+
return import_bech32_buffer.BitcoinAddress.decode(address).prefix === hrp;
|
|
4181
4437
|
}, "isValidSegwitAddress");
|
|
4182
4438
|
}
|
|
4183
4439
|
});
|
|
4184
4440
|
var assertArraylikeEqual, validateP2PKHOrP2SHAddress, validateSegwitAddress, validateBitcoinAddress, validateBitcoinMainnetAddress, validateBitcoinTestnetAddress, validateBitcoinRegtestAddress;
|
|
4185
4441
|
var init_addressValidation = __esm({
|
|
4186
4442
|
"../shared/src/validation/addressValidation.ts"() {
|
|
4187
|
-
|
|
4443
|
+
init_bitcoin();
|
|
4188
4444
|
init_guards();
|
|
4189
4445
|
assertArraylikeEqual = /* @__PURE__ */ __name((a, b) => {
|
|
4190
4446
|
assert(a.length === b.length, "arraylike lengths must be equal");
|
|
@@ -4247,16 +4503,16 @@ var init_parsers = __esm({
|
|
|
4247
4503
|
errorMap: errorMap2
|
|
4248
4504
|
});
|
|
4249
4505
|
numericString = string.regex(/^[0-9]+$/);
|
|
4250
|
-
hexString =
|
|
4506
|
+
hexString = string.refine((v) => /^0x[0-9a-f]+$/i.test(v));
|
|
4251
4507
|
hexStringWithMaxByteSize = /* @__PURE__ */ __name((maxByteSize) => hexString.refine((val) => val.length / 2 <= maxByteSize + 1, {
|
|
4252
4508
|
message: `String must be less than or equal to ${maxByteSize} bytes`
|
|
4253
4509
|
}), "hexStringWithMaxByteSize");
|
|
4254
4510
|
hexStringFromNumber = numericString.transform((arg) => `0x${BigInt(arg).toString(16)}`);
|
|
4255
4511
|
string.regex(/^[0-9a-f]+$/);
|
|
4256
|
-
btcAddress = /* @__PURE__ */ __name((
|
|
4257
|
-
|
|
4258
|
-
if (network === "mainnet")
|
|
4512
|
+
btcAddress = /* @__PURE__ */ __name((network) => {
|
|
4513
|
+
if (network === "mainnet") {
|
|
4259
4514
|
return string.regex(/^(1|3|bc1)/).refine(validateBitcoinMainnetAddress);
|
|
4515
|
+
}
|
|
4260
4516
|
return z.union([
|
|
4261
4517
|
string.regex(/^(m|n|2|tb1)/).refine(validateBitcoinTestnetAddress),
|
|
4262
4518
|
string.regex(/^bcrt1/).refine(validateBitcoinRegtestAddress)
|
|
@@ -4385,9 +4641,9 @@ var broker_exports = {};
|
|
|
4385
4641
|
__export(broker_exports, {
|
|
4386
4642
|
requestSwapDepositAddress: () => requestSwapDepositAddress
|
|
4387
4643
|
});
|
|
4388
|
-
async function requestSwapDepositAddress(swapRequest, opts) {
|
|
4644
|
+
async function requestSwapDepositAddress(swapRequest, opts, chainflipNetwork2) {
|
|
4389
4645
|
const { srcAsset, srcChain, destAsset, destChain, destAddress } = swapRequest;
|
|
4390
|
-
return makeRpcRequest(opts.url, "requestSwapDepositAddress", {
|
|
4646
|
+
return makeRpcRequest(chainflipNetwork2, opts.url, "requestSwapDepositAddress", {
|
|
4391
4647
|
asset: srcAsset,
|
|
4392
4648
|
chain: srcChain
|
|
4393
4649
|
}, {
|
|
@@ -4436,14 +4692,14 @@ var init_broker = __esm({
|
|
|
4436
4692
|
result: z.unknown()
|
|
4437
4693
|
})
|
|
4438
4694
|
]);
|
|
4439
|
-
requestValidators = {
|
|
4695
|
+
requestValidators = /* @__PURE__ */ __name((network) => ({
|
|
4440
4696
|
requestSwapDepositAddress: z.tuple([
|
|
4441
4697
|
chainflipAssetAndChain,
|
|
4442
4698
|
chainflipAssetAndChain,
|
|
4443
4699
|
z.union([
|
|
4444
4700
|
numericString,
|
|
4445
4701
|
hexString,
|
|
4446
|
-
btcAddress()
|
|
4702
|
+
btcAddress(network)
|
|
4447
4703
|
]),
|
|
4448
4704
|
z.number(),
|
|
4449
4705
|
ccmMetadataSchema.merge(z.object({
|
|
@@ -4460,13 +4716,13 @@ var init_broker = __esm({
|
|
|
4460
4716
|
d,
|
|
4461
4717
|
transformObjToSnakeCase(e)
|
|
4462
4718
|
].filter(isNotNullish))
|
|
4463
|
-
};
|
|
4464
|
-
responseValidators = {
|
|
4719
|
+
}), "requestValidators");
|
|
4720
|
+
responseValidators = /* @__PURE__ */ __name((network) => ({
|
|
4465
4721
|
requestSwapDepositAddress: z.object({
|
|
4466
4722
|
address: z.union([
|
|
4467
4723
|
dotAddress,
|
|
4468
4724
|
hexString,
|
|
4469
|
-
btcAddress()
|
|
4725
|
+
btcAddress(network)
|
|
4470
4726
|
]),
|
|
4471
4727
|
issued_block: z.number(),
|
|
4472
4728
|
channel_id: z.number(),
|
|
@@ -4478,19 +4734,19 @@ var init_broker = __esm({
|
|
|
4478
4734
|
channelId: BigInt(channel_id),
|
|
4479
4735
|
sourceChainExpiryBlock: source_chain_expiry_block
|
|
4480
4736
|
}))
|
|
4481
|
-
};
|
|
4482
|
-
makeRpcRequest = /* @__PURE__ */ __name(async (url, method, ...params) => {
|
|
4737
|
+
}), "responseValidators");
|
|
4738
|
+
makeRpcRequest = /* @__PURE__ */ __name(async (network, url, method, ...params) => {
|
|
4483
4739
|
const res = await axios2__default.default.post(url.toString(), {
|
|
4484
4740
|
jsonrpc: "2.0",
|
|
4485
4741
|
id: 1,
|
|
4486
4742
|
method: `broker_${method}`,
|
|
4487
|
-
params: requestValidators[method].parse(params)
|
|
4743
|
+
params: requestValidators(network)[method].parse(params)
|
|
4488
4744
|
});
|
|
4489
4745
|
const result = rpcResult.parse(res.data);
|
|
4490
4746
|
if ("error" in result) {
|
|
4491
4747
|
throw new Error(`Broker responded with error code ${result.error.code}: ${result.error.message}`);
|
|
4492
4748
|
}
|
|
4493
|
-
return responseValidators[method].parse(result.result);
|
|
4749
|
+
return responseValidators(network)[method].parse(result.result);
|
|
4494
4750
|
}, "makeRpcRequest");
|
|
4495
4751
|
__name(requestSwapDepositAddress, "requestSwapDepositAddress");
|
|
4496
4752
|
}
|
|
@@ -6865,11 +7121,11 @@ var ethToDot = eth.extend({
|
|
|
6865
7121
|
destAddress: dotAddress.transform((addr) => bytesToHex(utilCrypto.decodeAddress(addr))),
|
|
6866
7122
|
destAsset: z.literal(exports.Assets.DOT)
|
|
6867
7123
|
});
|
|
6868
|
-
var ethToBtc = eth.extend({
|
|
7124
|
+
var ethToBtc = /* @__PURE__ */ __name((network) => eth.extend({
|
|
6869
7125
|
destChain: z.literal(exports.Chains.Bitcoin),
|
|
6870
|
-
destAddress: btcAddress().transform(utf8ToHex),
|
|
7126
|
+
destAddress: btcAddress(network).transform(utf8ToHex),
|
|
6871
7127
|
destAsset: z.literal(exports.Assets.BTC)
|
|
6872
|
-
});
|
|
7128
|
+
}), "ethToBtc");
|
|
6873
7129
|
var erc20Asset = z.union([
|
|
6874
7130
|
z.literal(exports.Assets.FLIP),
|
|
6875
7131
|
z.literal(exports.Assets.USDC)
|
|
@@ -6877,11 +7133,11 @@ var erc20Asset = z.union([
|
|
|
6877
7133
|
var ethToERC20 = ethToEthereum.extend({
|
|
6878
7134
|
destAsset: erc20Asset
|
|
6879
7135
|
});
|
|
6880
|
-
var nativeSwapParamsSchema = z.union([
|
|
7136
|
+
var nativeSwapParamsSchema = /* @__PURE__ */ __name((network) => z.union([
|
|
6881
7137
|
ethToERC20,
|
|
6882
7138
|
ethToDot,
|
|
6883
|
-
ethToBtc
|
|
6884
|
-
]);
|
|
7139
|
+
ethToBtc(network)
|
|
7140
|
+
]), "nativeSwapParamsSchema");
|
|
6885
7141
|
var flipToEthereumAsset = ethToEthereum.extend({
|
|
6886
7142
|
srcAsset: z.literal(exports.Assets.FLIP),
|
|
6887
7143
|
destAsset: z.union([
|
|
@@ -6899,15 +7155,15 @@ var usdcToEthereumAsset = ethToEthereum.extend({
|
|
|
6899
7155
|
var erc20ToDot = ethToDot.extend({
|
|
6900
7156
|
srcAsset: erc20Asset
|
|
6901
7157
|
});
|
|
6902
|
-
var erc20ToBtc = ethToBtc.extend({
|
|
7158
|
+
var erc20ToBtc = /* @__PURE__ */ __name((network) => ethToBtc(network).extend({
|
|
6903
7159
|
srcAsset: erc20Asset
|
|
6904
|
-
});
|
|
6905
|
-
var tokenSwapParamsSchema = z.union([
|
|
7160
|
+
}), "erc20ToBtc");
|
|
7161
|
+
var tokenSwapParamsSchema = /* @__PURE__ */ __name((network) => z.union([
|
|
6906
7162
|
flipToEthereumAsset,
|
|
6907
7163
|
usdcToEthereumAsset,
|
|
6908
7164
|
erc20ToDot,
|
|
6909
|
-
erc20ToBtc
|
|
6910
|
-
]);
|
|
7165
|
+
erc20ToBtc(network)
|
|
7166
|
+
]), "tokenSwapParamsSchema");
|
|
6911
7167
|
var ccmFlipToEthereumAssset = flipToEthereumAsset.extend({
|
|
6912
7168
|
ccmMetadata: ccmMetadataSchema
|
|
6913
7169
|
});
|
|
@@ -6921,13 +7177,13 @@ var tokenCallParamsSchema = z.union([
|
|
|
6921
7177
|
var nativeCallParamsSchema = ethToERC20.extend({
|
|
6922
7178
|
ccmMetadata: ccmMetadataSchema
|
|
6923
7179
|
});
|
|
6924
|
-
var executeSwapParamsSchema = z.union([
|
|
7180
|
+
var executeSwapParamsSchema = /* @__PURE__ */ __name((network) => z.union([
|
|
6925
7181
|
// call schemas needs to precede swap schemas
|
|
6926
7182
|
nativeCallParamsSchema,
|
|
6927
7183
|
tokenCallParamsSchema,
|
|
6928
|
-
nativeSwapParamsSchema,
|
|
6929
|
-
tokenSwapParamsSchema
|
|
6930
|
-
]);
|
|
7184
|
+
nativeSwapParamsSchema(network),
|
|
7185
|
+
tokenSwapParamsSchema(network)
|
|
7186
|
+
]), "executeSwapParamsSchema");
|
|
6931
7187
|
var _abi = [
|
|
6932
7188
|
{
|
|
6933
7189
|
inputs: [
|
|
@@ -8342,7 +8598,8 @@ var callToken = /* @__PURE__ */ __name(async (params, networkOpts, txOpts) => {
|
|
|
8342
8598
|
return transaction.wait(txOpts.wait);
|
|
8343
8599
|
}, "callToken");
|
|
8344
8600
|
var executeSwap = /* @__PURE__ */ __name(async (params, networkOpts, txOpts) => {
|
|
8345
|
-
const
|
|
8601
|
+
const network = networkOpts.network === "localnet" ? "backspin" : networkOpts.network;
|
|
8602
|
+
const parsedParams = executeSwapParamsSchema(network).parse(params);
|
|
8346
8603
|
if ("ccmMetadata" in parsedParams) {
|
|
8347
8604
|
return isTokenCall(parsedParams) ? callToken(parsedParams, networkOpts, txOpts) : callNative(parsedParams, networkOpts, txOpts);
|
|
8348
8605
|
}
|
|
@@ -8601,7 +8858,7 @@ var _SwapSDK = class _SwapSDK {
|
|
|
8601
8858
|
let response;
|
|
8602
8859
|
if (this.brokerConfig !== void 0) {
|
|
8603
8860
|
const { requestSwapDepositAddress: requestSwapDepositAddress2 } = await Promise.resolve().then(() => (init_broker(), broker_exports));
|
|
8604
|
-
const result = await requestSwapDepositAddress2(depositAddressRequest, this.brokerConfig);
|
|
8861
|
+
const result = await requestSwapDepositAddress2(depositAddressRequest, this.brokerConfig, this.network);
|
|
8605
8862
|
response = {
|
|
8606
8863
|
id: `${result.issuedBlock}-${depositAddressRequest.srcChain}-${result.channelId}`,
|
|
8607
8864
|
depositAddress: result.address,
|