@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/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
- // ../shared/src/validation/segwitAddr.ts
3988
- var CHARSET, GENERATOR, Encoding, bech32, segwitAddress, isValidSegwitAddress;
3989
- var init_segwitAddr = __esm({
3990
- "../shared/src/validation/segwitAddr.ts"() {
3991
- CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
3992
- GENERATOR = [
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
- (function(Encoding2) {
4000
- Encoding2["Bech32"] = "bech32";
4001
- Encoding2["Bech32m"] = "bech32m";
4002
- })(Encoding || (Encoding = {}));
4003
- bech32 = {
4004
- getEncodingConst(enc) {
4005
- if (enc === "bech32")
4006
- return 1;
4007
- if (enc === "bech32m")
4008
- return 734539939;
4009
- return null;
4010
- },
4011
- polymod(values) {
4012
- let chk = 1;
4013
- for (let p = 0; p < values.length; p += 1) {
4014
- const top = chk >> 25;
4015
- chk = (chk & 33554431) << 5 ^ values[p];
4016
- for (let i = 0; i < 5; i += 1) {
4017
- if (top >> i & 1) {
4018
- chk ^= GENERATOR[i];
4019
- }
4020
- }
4021
- }
4022
- return chk;
4023
- },
4024
- hrpExpand(hrp) {
4025
- const ret = [];
4026
- let p;
4027
- for (p = 0; p < hrp.length; p += 1) {
4028
- ret.push(hrp.charCodeAt(p) >> 5);
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
- segwitAddress = {
4103
- convertbits(data, frombits, tobits, pad) {
4104
- let acc = 0;
4105
- let bits = 0;
4106
- const ret = [];
4107
- const maxv = (1 << tobits) - 1;
4108
- for (let p = 0; p < data.length; p += 1) {
4109
- const value = data[p];
4110
- if (value < 0 || value >> frombits !== 0) {
4111
- return null;
4112
- }
4113
- acc = acc << frombits | value;
4114
- bits += frombits;
4115
- while (bits >= tobits) {
4116
- bits -= tobits;
4117
- ret.push(acc >> bits & maxv);
4118
- }
4119
- }
4120
- if (pad) {
4121
- if (bits > 0) {
4122
- ret.push(acc << tobits - bits & maxv);
4123
- }
4124
- } else if (bits >= frombits || acc << tobits - bits & maxv) {
4125
- return null;
4126
- }
4127
- return ret;
4128
- },
4129
- decode(hrp, addr) {
4130
- let bech32m = false;
4131
- let dec = bech32.decode(addr, "bech32");
4132
- if (dec === null) {
4133
- dec = bech32.decode(addr, "bech32m");
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
- return ret;
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 segwitAddress.decode(hrp, address) !== null;
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
- init_segwitAddr();
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 = z.custom((val) => typeof val === "string" && /^0x[0-9a-f]+$/i.test(val));
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((env) => {
4257
- const network = env ?? process.env.CHAINFLIP_NETWORK;
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 parsedParams = executeSwapParamsSchema.parse(params);
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,