@chainflip/sdk 1.1.1-rc.2 → 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-EAUQOE44.mjs → broker-IPTE3R72.mjs} +13 -13
- package/dist/{chunk-6MSXMH7S.mjs → chunk-4PQXI2DE.mjs} +8 -5
- package/dist/{chunk-O4RYZWBW.mjs → chunk-Q7HQVR3T.mjs} +30 -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.js +12 -4
- package/dist/funding.mjs +2 -2
- package/dist/swap.d.mts +36 -36
- package/dist/swap.d.ts +36 -36
- package/dist/swap.js +483 -218
- package/dist/swap.mjs +23 -22
- package/package.json +1 -1
- package/dist/chunk-LEMOY2A2.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;
|
|
@@ -118,6 +141,11 @@ var init_enums = __esm({
|
|
|
118
141
|
exports.Assets.DOT
|
|
119
142
|
]
|
|
120
143
|
};
|
|
144
|
+
({
|
|
145
|
+
[exports.Chains.Ethereum]: exports.Assets.ETH,
|
|
146
|
+
[exports.Chains.Bitcoin]: exports.Assets.BTC,
|
|
147
|
+
[exports.Chains.Polkadot]: exports.Assets.DOT
|
|
148
|
+
});
|
|
121
149
|
exports.chainContractIds = {
|
|
122
150
|
[exports.Chains.Ethereum]: 1,
|
|
123
151
|
[exports.Chains.Polkadot]: 2,
|
|
@@ -3979,207 +4007,440 @@ var init_lib = __esm({
|
|
|
3979
4007
|
}
|
|
3980
4008
|
});
|
|
3981
4009
|
|
|
3982
|
-
//
|
|
3983
|
-
var
|
|
3984
|
-
|
|
3985
|
-
|
|
3986
|
-
|
|
3987
|
-
|
|
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 = [
|
|
3988
4103
|
996825010,
|
|
3989
4104
|
642813549,
|
|
3990
4105
|
513874426,
|
|
3991
4106
|
1027748829,
|
|
3992
4107
|
705979059
|
|
3993
4108
|
];
|
|
3994
|
-
|
|
3995
|
-
|
|
3996
|
-
|
|
3997
|
-
|
|
3998
|
-
|
|
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
|
-
ret.push(0);
|
|
4026
|
-
for (p = 0; p < hrp.length; p += 1) {
|
|
4027
|
-
ret.push(hrp.charCodeAt(p) & 31);
|
|
4028
|
-
}
|
|
4029
|
-
return ret;
|
|
4030
|
-
},
|
|
4031
|
-
verifyChecksum(hrp, data, enc) {
|
|
4032
|
-
return this.polymod(this.hrpExpand(hrp).concat(data)) === this.getEncodingConst(enc);
|
|
4033
|
-
},
|
|
4034
|
-
createChecksum(hrp, data, enc) {
|
|
4035
|
-
const values = this.hrpExpand(hrp).concat(data).concat([
|
|
4036
|
-
0,
|
|
4037
|
-
0,
|
|
4038
|
-
0,
|
|
4039
|
-
0,
|
|
4040
|
-
0,
|
|
4041
|
-
0
|
|
4042
|
-
]);
|
|
4043
|
-
const mod = this.polymod(values) ^ this.getEncodingConst(enc);
|
|
4044
|
-
const ret = [];
|
|
4045
|
-
for (let p = 0; p < 6; p += 1) {
|
|
4046
|
-
ret.push(mod >> 5 * (5 - p) & 31);
|
|
4047
|
-
}
|
|
4048
|
-
return ret;
|
|
4049
|
-
},
|
|
4050
|
-
encode(hrp, data, enc) {
|
|
4051
|
-
const combined = data.concat(this.createChecksum(hrp, data, enc));
|
|
4052
|
-
let ret = `${hrp}1`;
|
|
4053
|
-
for (let p = 0; p < combined.length; p += 1) {
|
|
4054
|
-
ret += CHARSET.charAt(combined[p]);
|
|
4055
|
-
}
|
|
4056
|
-
return ret;
|
|
4057
|
-
},
|
|
4058
|
-
decode(bechString, enc) {
|
|
4059
|
-
let p;
|
|
4060
|
-
let hasLower = false;
|
|
4061
|
-
let hasUpper = false;
|
|
4062
|
-
for (p = 0; p < bechString.length; p += 1) {
|
|
4063
|
-
if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126) {
|
|
4064
|
-
return null;
|
|
4065
|
-
}
|
|
4066
|
-
if (bechString.charCodeAt(p) >= 97 && bechString.charCodeAt(p) <= 122) {
|
|
4067
|
-
hasLower = true;
|
|
4068
|
-
}
|
|
4069
|
-
if (bechString.charCodeAt(p) >= 65 && bechString.charCodeAt(p) <= 90) {
|
|
4070
|
-
hasUpper = true;
|
|
4071
|
-
}
|
|
4072
|
-
}
|
|
4073
|
-
if (hasLower && hasUpper)
|
|
4074
|
-
return null;
|
|
4075
|
-
const lowercase = bechString.toLowerCase();
|
|
4076
|
-
const pos = lowercase.lastIndexOf("1");
|
|
4077
|
-
if (pos < 1 || pos + 7 > lowercase.length || lowercase.length > 90) {
|
|
4078
|
-
return null;
|
|
4079
|
-
}
|
|
4080
|
-
const hrp = lowercase.substring(0, pos);
|
|
4081
|
-
const data = [];
|
|
4082
|
-
for (p = pos + 1; p < lowercase.length; p += 1) {
|
|
4083
|
-
const d = CHARSET.indexOf(lowercase.charAt(p));
|
|
4084
|
-
if (d === -1)
|
|
4085
|
-
return null;
|
|
4086
|
-
data.push(d);
|
|
4087
|
-
}
|
|
4088
|
-
if (!this.verifyChecksum(hrp, data, enc)) {
|
|
4089
|
-
return null;
|
|
4090
|
-
}
|
|
4091
|
-
return {
|
|
4092
|
-
hrp,
|
|
4093
|
-
data: data.slice(0, data.length - 6)
|
|
4094
|
-
};
|
|
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;
|
|
4095
4140
|
}
|
|
4096
|
-
}
|
|
4097
|
-
|
|
4098
|
-
|
|
4099
|
-
|
|
4100
|
-
|
|
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
|
-
if (
|
|
4128
|
-
|
|
4129
|
-
bech32m = true;
|
|
4130
|
-
}
|
|
4131
|
-
if (dec === null || dec.hrp !== hrp || dec.data.length < 1 || dec.data[0] > 16) {
|
|
4132
|
-
return null;
|
|
4133
|
-
}
|
|
4134
|
-
const res = this.convertbits(dec.data.slice(1), 5, 8, false);
|
|
4135
|
-
if (res === null || res.length < 2 || res.length > 40) {
|
|
4136
|
-
return null;
|
|
4137
|
-
}
|
|
4138
|
-
if (dec.data[0] === 0 && res.length !== 20 && res.length !== 32) {
|
|
4139
|
-
return null;
|
|
4140
|
-
}
|
|
4141
|
-
if (dec.data[0] === 0 && bech32m) {
|
|
4142
|
-
return null;
|
|
4143
|
-
}
|
|
4144
|
-
if (dec.data[0] !== 0 && !bech32m) {
|
|
4145
|
-
return null;
|
|
4146
|
-
}
|
|
4147
|
-
return {
|
|
4148
|
-
version: dec.data[0],
|
|
4149
|
-
program: res
|
|
4150
|
-
};
|
|
4151
|
-
},
|
|
4152
|
-
encode(hrp, version, program) {
|
|
4153
|
-
let enc = "bech32";
|
|
4154
|
-
if (version > 0) {
|
|
4155
|
-
enc = "bech32m";
|
|
4156
|
-
}
|
|
4157
|
-
const ret = bech32.encode(
|
|
4158
|
-
hrp,
|
|
4159
|
-
// @ts-expect-error can be null
|
|
4160
|
-
[
|
|
4161
|
-
version
|
|
4162
|
-
].concat(this.convertbits(program, 8, 5, true)),
|
|
4163
|
-
enc
|
|
4164
|
-
);
|
|
4165
|
-
if (this.decode(hrp, ret) === null) {
|
|
4166
|
-
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]));
|
|
4167
4174
|
}
|
|
4168
|
-
|
|
4175
|
+
realDst[i] = idx;
|
|
4169
4176
|
}
|
|
4170
|
-
|
|
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());
|
|
4171
4432
|
isValidSegwitAddress = /* @__PURE__ */ __name((address) => {
|
|
4172
4433
|
const hrp = /^(bc|tb|bcrt)1/.exec(address)?.[1];
|
|
4173
4434
|
if (!hrp)
|
|
4174
4435
|
return false;
|
|
4175
|
-
return
|
|
4436
|
+
return import_bech32_buffer.BitcoinAddress.decode(address).prefix === hrp;
|
|
4176
4437
|
}, "isValidSegwitAddress");
|
|
4177
4438
|
}
|
|
4178
4439
|
});
|
|
4179
4440
|
var assertArraylikeEqual, validateP2PKHOrP2SHAddress, validateSegwitAddress, validateBitcoinAddress, validateBitcoinMainnetAddress, validateBitcoinTestnetAddress, validateBitcoinRegtestAddress;
|
|
4180
4441
|
var init_addressValidation = __esm({
|
|
4181
4442
|
"../shared/src/validation/addressValidation.ts"() {
|
|
4182
|
-
|
|
4443
|
+
init_bitcoin();
|
|
4183
4444
|
init_guards();
|
|
4184
4445
|
assertArraylikeEqual = /* @__PURE__ */ __name((a, b) => {
|
|
4185
4446
|
assert(a.length === b.length, "arraylike lengths must be equal");
|
|
@@ -4242,16 +4503,16 @@ var init_parsers = __esm({
|
|
|
4242
4503
|
errorMap: errorMap2
|
|
4243
4504
|
});
|
|
4244
4505
|
numericString = string.regex(/^[0-9]+$/);
|
|
4245
|
-
hexString =
|
|
4506
|
+
hexString = string.refine((v) => /^0x[0-9a-f]+$/i.test(v));
|
|
4246
4507
|
hexStringWithMaxByteSize = /* @__PURE__ */ __name((maxByteSize) => hexString.refine((val) => val.length / 2 <= maxByteSize + 1, {
|
|
4247
4508
|
message: `String must be less than or equal to ${maxByteSize} bytes`
|
|
4248
4509
|
}), "hexStringWithMaxByteSize");
|
|
4249
4510
|
hexStringFromNumber = numericString.transform((arg) => `0x${BigInt(arg).toString(16)}`);
|
|
4250
4511
|
string.regex(/^[0-9a-f]+$/);
|
|
4251
|
-
btcAddress = /* @__PURE__ */ __name((
|
|
4252
|
-
|
|
4253
|
-
if (network === "mainnet")
|
|
4512
|
+
btcAddress = /* @__PURE__ */ __name((network) => {
|
|
4513
|
+
if (network === "mainnet") {
|
|
4254
4514
|
return string.regex(/^(1|3|bc1)/).refine(validateBitcoinMainnetAddress);
|
|
4515
|
+
}
|
|
4255
4516
|
return z.union([
|
|
4256
4517
|
string.regex(/^(m|n|2|tb1)/).refine(validateBitcoinTestnetAddress),
|
|
4257
4518
|
string.regex(/^bcrt1/).refine(validateBitcoinRegtestAddress)
|
|
@@ -4380,9 +4641,9 @@ var broker_exports = {};
|
|
|
4380
4641
|
__export(broker_exports, {
|
|
4381
4642
|
requestSwapDepositAddress: () => requestSwapDepositAddress
|
|
4382
4643
|
});
|
|
4383
|
-
async function requestSwapDepositAddress(swapRequest, opts) {
|
|
4644
|
+
async function requestSwapDepositAddress(swapRequest, opts, chainflipNetwork2) {
|
|
4384
4645
|
const { srcAsset, srcChain, destAsset, destChain, destAddress } = swapRequest;
|
|
4385
|
-
return makeRpcRequest(opts.url, "requestSwapDepositAddress", {
|
|
4646
|
+
return makeRpcRequest(chainflipNetwork2, opts.url, "requestSwapDepositAddress", {
|
|
4386
4647
|
asset: srcAsset,
|
|
4387
4648
|
chain: srcChain
|
|
4388
4649
|
}, {
|
|
@@ -4431,14 +4692,14 @@ var init_broker = __esm({
|
|
|
4431
4692
|
result: z.unknown()
|
|
4432
4693
|
})
|
|
4433
4694
|
]);
|
|
4434
|
-
requestValidators = {
|
|
4695
|
+
requestValidators = /* @__PURE__ */ __name((network) => ({
|
|
4435
4696
|
requestSwapDepositAddress: z.tuple([
|
|
4436
4697
|
chainflipAssetAndChain,
|
|
4437
4698
|
chainflipAssetAndChain,
|
|
4438
4699
|
z.union([
|
|
4439
4700
|
numericString,
|
|
4440
4701
|
hexString,
|
|
4441
|
-
btcAddress()
|
|
4702
|
+
btcAddress(network)
|
|
4442
4703
|
]),
|
|
4443
4704
|
z.number(),
|
|
4444
4705
|
ccmMetadataSchema.merge(z.object({
|
|
@@ -4455,13 +4716,13 @@ var init_broker = __esm({
|
|
|
4455
4716
|
d,
|
|
4456
4717
|
transformObjToSnakeCase(e)
|
|
4457
4718
|
].filter(isNotNullish))
|
|
4458
|
-
};
|
|
4459
|
-
responseValidators = {
|
|
4719
|
+
}), "requestValidators");
|
|
4720
|
+
responseValidators = /* @__PURE__ */ __name((network) => ({
|
|
4460
4721
|
requestSwapDepositAddress: z.object({
|
|
4461
4722
|
address: z.union([
|
|
4462
4723
|
dotAddress,
|
|
4463
4724
|
hexString,
|
|
4464
|
-
btcAddress()
|
|
4725
|
+
btcAddress(network)
|
|
4465
4726
|
]),
|
|
4466
4727
|
issued_block: z.number(),
|
|
4467
4728
|
channel_id: z.number(),
|
|
@@ -4473,19 +4734,19 @@ var init_broker = __esm({
|
|
|
4473
4734
|
channelId: BigInt(channel_id),
|
|
4474
4735
|
sourceChainExpiryBlock: source_chain_expiry_block
|
|
4475
4736
|
}))
|
|
4476
|
-
};
|
|
4477
|
-
makeRpcRequest = /* @__PURE__ */ __name(async (url, method, ...params) => {
|
|
4737
|
+
}), "responseValidators");
|
|
4738
|
+
makeRpcRequest = /* @__PURE__ */ __name(async (network, url, method, ...params) => {
|
|
4478
4739
|
const res = await axios2__default.default.post(url.toString(), {
|
|
4479
4740
|
jsonrpc: "2.0",
|
|
4480
4741
|
id: 1,
|
|
4481
4742
|
method: `broker_${method}`,
|
|
4482
|
-
params: requestValidators[method].parse(params)
|
|
4743
|
+
params: requestValidators(network)[method].parse(params)
|
|
4483
4744
|
});
|
|
4484
4745
|
const result = rpcResult.parse(res.data);
|
|
4485
4746
|
if ("error" in result) {
|
|
4486
4747
|
throw new Error(`Broker responded with error code ${result.error.code}: ${result.error.message}`);
|
|
4487
4748
|
}
|
|
4488
|
-
return responseValidators[method].parse(result.result);
|
|
4749
|
+
return responseValidators(network)[method].parse(result.result);
|
|
4489
4750
|
}, "makeRpcRequest");
|
|
4490
4751
|
__name(requestSwapDepositAddress, "requestSwapDepositAddress");
|
|
4491
4752
|
}
|
|
@@ -6686,12 +6947,12 @@ var RPC_URLS = {
|
|
|
6686
6947
|
[exports.ChainflipNetworks.perseverance]: "https://perseverance.chainflip.xyz",
|
|
6687
6948
|
[exports.ChainflipNetworks.mainnet]: "https://mainnet-rpc.chainflip.io"
|
|
6688
6949
|
};
|
|
6689
|
-
var createRequest = /* @__PURE__ */ __name((method, responseParser
|
|
6950
|
+
var createRequest = /* @__PURE__ */ __name((method, responseParser) => async (urlOrNetwork, ...params) => {
|
|
6690
6951
|
const url = "network" in urlOrNetwork ? RPC_URLS[urlOrNetwork.network] : urlOrNetwork.rpcUrl;
|
|
6691
6952
|
const { data } = await axios2__default.default.post(url, {
|
|
6692
6953
|
jsonrpc: "2.0",
|
|
6693
6954
|
method,
|
|
6694
|
-
params
|
|
6955
|
+
params,
|
|
6695
6956
|
id: 1
|
|
6696
6957
|
});
|
|
6697
6958
|
const result = responseParser.safeParse(data.result);
|
|
@@ -6792,10 +7053,13 @@ createRequest("cf_pool_info", poolsEnvironment);
|
|
|
6792
7053
|
var environment = z.object({
|
|
6793
7054
|
ingress_egress: ingressEgressEnvironment,
|
|
6794
7055
|
swapping: swappingEnvironment,
|
|
6795
|
-
funding: fundingEnvironment
|
|
6796
|
-
pools: poolsEnvironment
|
|
7056
|
+
funding: fundingEnvironment
|
|
6797
7057
|
});
|
|
6798
7058
|
var getEnvironment = createRequest("cf_environment", environment);
|
|
7059
|
+
var swapRate = z.object({
|
|
7060
|
+
output: numberOrHex
|
|
7061
|
+
});
|
|
7062
|
+
createRequest("cf_swap_rate", swapRate);
|
|
6799
7063
|
|
|
6800
7064
|
// ../shared/src/rpc/utils.ts
|
|
6801
7065
|
init_enums();
|
|
@@ -6857,11 +7121,11 @@ var ethToDot = eth.extend({
|
|
|
6857
7121
|
destAddress: dotAddress.transform((addr) => bytesToHex(utilCrypto.decodeAddress(addr))),
|
|
6858
7122
|
destAsset: z.literal(exports.Assets.DOT)
|
|
6859
7123
|
});
|
|
6860
|
-
var ethToBtc = eth.extend({
|
|
7124
|
+
var ethToBtc = /* @__PURE__ */ __name((network) => eth.extend({
|
|
6861
7125
|
destChain: z.literal(exports.Chains.Bitcoin),
|
|
6862
|
-
destAddress: btcAddress().transform(utf8ToHex),
|
|
7126
|
+
destAddress: btcAddress(network).transform(utf8ToHex),
|
|
6863
7127
|
destAsset: z.literal(exports.Assets.BTC)
|
|
6864
|
-
});
|
|
7128
|
+
}), "ethToBtc");
|
|
6865
7129
|
var erc20Asset = z.union([
|
|
6866
7130
|
z.literal(exports.Assets.FLIP),
|
|
6867
7131
|
z.literal(exports.Assets.USDC)
|
|
@@ -6869,11 +7133,11 @@ var erc20Asset = z.union([
|
|
|
6869
7133
|
var ethToERC20 = ethToEthereum.extend({
|
|
6870
7134
|
destAsset: erc20Asset
|
|
6871
7135
|
});
|
|
6872
|
-
var nativeSwapParamsSchema = z.union([
|
|
7136
|
+
var nativeSwapParamsSchema = /* @__PURE__ */ __name((network) => z.union([
|
|
6873
7137
|
ethToERC20,
|
|
6874
7138
|
ethToDot,
|
|
6875
|
-
ethToBtc
|
|
6876
|
-
]);
|
|
7139
|
+
ethToBtc(network)
|
|
7140
|
+
]), "nativeSwapParamsSchema");
|
|
6877
7141
|
var flipToEthereumAsset = ethToEthereum.extend({
|
|
6878
7142
|
srcAsset: z.literal(exports.Assets.FLIP),
|
|
6879
7143
|
destAsset: z.union([
|
|
@@ -6891,15 +7155,15 @@ var usdcToEthereumAsset = ethToEthereum.extend({
|
|
|
6891
7155
|
var erc20ToDot = ethToDot.extend({
|
|
6892
7156
|
srcAsset: erc20Asset
|
|
6893
7157
|
});
|
|
6894
|
-
var erc20ToBtc = ethToBtc.extend({
|
|
7158
|
+
var erc20ToBtc = /* @__PURE__ */ __name((network) => ethToBtc(network).extend({
|
|
6895
7159
|
srcAsset: erc20Asset
|
|
6896
|
-
});
|
|
6897
|
-
var tokenSwapParamsSchema = z.union([
|
|
7160
|
+
}), "erc20ToBtc");
|
|
7161
|
+
var tokenSwapParamsSchema = /* @__PURE__ */ __name((network) => z.union([
|
|
6898
7162
|
flipToEthereumAsset,
|
|
6899
7163
|
usdcToEthereumAsset,
|
|
6900
7164
|
erc20ToDot,
|
|
6901
|
-
erc20ToBtc
|
|
6902
|
-
]);
|
|
7165
|
+
erc20ToBtc(network)
|
|
7166
|
+
]), "tokenSwapParamsSchema");
|
|
6903
7167
|
var ccmFlipToEthereumAssset = flipToEthereumAsset.extend({
|
|
6904
7168
|
ccmMetadata: ccmMetadataSchema
|
|
6905
7169
|
});
|
|
@@ -6913,13 +7177,13 @@ var tokenCallParamsSchema = z.union([
|
|
|
6913
7177
|
var nativeCallParamsSchema = ethToERC20.extend({
|
|
6914
7178
|
ccmMetadata: ccmMetadataSchema
|
|
6915
7179
|
});
|
|
6916
|
-
var executeSwapParamsSchema = z.union([
|
|
7180
|
+
var executeSwapParamsSchema = /* @__PURE__ */ __name((network) => z.union([
|
|
6917
7181
|
// call schemas needs to precede swap schemas
|
|
6918
7182
|
nativeCallParamsSchema,
|
|
6919
7183
|
tokenCallParamsSchema,
|
|
6920
|
-
nativeSwapParamsSchema,
|
|
6921
|
-
tokenSwapParamsSchema
|
|
6922
|
-
]);
|
|
7184
|
+
nativeSwapParamsSchema(network),
|
|
7185
|
+
tokenSwapParamsSchema(network)
|
|
7186
|
+
]), "executeSwapParamsSchema");
|
|
6923
7187
|
var _abi = [
|
|
6924
7188
|
{
|
|
6925
7189
|
inputs: [
|
|
@@ -8334,7 +8598,8 @@ var callToken = /* @__PURE__ */ __name(async (params, networkOpts, txOpts) => {
|
|
|
8334
8598
|
return transaction.wait(txOpts.wait);
|
|
8335
8599
|
}, "callToken");
|
|
8336
8600
|
var executeSwap = /* @__PURE__ */ __name(async (params, networkOpts, txOpts) => {
|
|
8337
|
-
const
|
|
8601
|
+
const network = networkOpts.network === "localnet" ? "backspin" : networkOpts.network;
|
|
8602
|
+
const parsedParams = executeSwapParamsSchema(network).parse(params);
|
|
8338
8603
|
if ("ccmMetadata" in parsedParams) {
|
|
8339
8604
|
return isTokenCall(parsedParams) ? callToken(parsedParams, networkOpts, txOpts) : callNative(parsedParams, networkOpts, txOpts);
|
|
8340
8605
|
}
|
|
@@ -8593,7 +8858,7 @@ var _SwapSDK = class _SwapSDK {
|
|
|
8593
8858
|
let response;
|
|
8594
8859
|
if (this.brokerConfig !== void 0) {
|
|
8595
8860
|
const { requestSwapDepositAddress: requestSwapDepositAddress2 } = await Promise.resolve().then(() => (init_broker(), broker_exports));
|
|
8596
|
-
const result = await requestSwapDepositAddress2(depositAddressRequest, this.brokerConfig);
|
|
8861
|
+
const result = await requestSwapDepositAddress2(depositAddressRequest, this.brokerConfig, this.network);
|
|
8597
8862
|
response = {
|
|
8598
8863
|
id: `${result.issuedBlock}-${depositAddressRequest.srcChain}-${result.channelId}`,
|
|
8599
8864
|
depositAddress: result.address,
|