@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/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
- // ../shared/src/validation/segwitAddr.ts
3983
- var CHARSET, GENERATOR, Encoding, bech32, segwitAddress, isValidSegwitAddress;
3984
- var init_segwitAddr = __esm({
3985
- "../shared/src/validation/segwitAddr.ts"() {
3986
- CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
3987
- 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 = [
3988
4103
  996825010,
3989
4104
  642813549,
3990
4105
  513874426,
3991
4106
  1027748829,
3992
4107
  705979059
3993
4108
  ];
3994
- (function(Encoding2) {
3995
- Encoding2["Bech32"] = "bech32";
3996
- Encoding2["Bech32m"] = "bech32m";
3997
- })(Encoding || (Encoding = {}));
3998
- bech32 = {
3999
- getEncodingConst(enc) {
4000
- if (enc === "bech32")
4001
- return 1;
4002
- if (enc === "bech32m")
4003
- return 734539939;
4004
- return null;
4005
- },
4006
- polymod(values) {
4007
- let chk = 1;
4008
- for (let p = 0; p < values.length; p += 1) {
4009
- const top = chk >> 25;
4010
- chk = (chk & 33554431) << 5 ^ values[p];
4011
- for (let i = 0; i < 5; i += 1) {
4012
- if (top >> i & 1) {
4013
- chk ^= GENERATOR[i];
4014
- }
4015
- }
4016
- }
4017
- return chk;
4018
- },
4019
- hrpExpand(hrp) {
4020
- const ret = [];
4021
- let p;
4022
- for (p = 0; p < hrp.length; p += 1) {
4023
- ret.push(hrp.charCodeAt(p) >> 5);
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
- segwitAddress = {
4098
- convertbits(data, frombits, tobits, pad) {
4099
- let acc = 0;
4100
- let bits = 0;
4101
- const ret = [];
4102
- const maxv = (1 << tobits) - 1;
4103
- for (let p = 0; p < data.length; p += 1) {
4104
- const value = data[p];
4105
- if (value < 0 || value >> frombits !== 0) {
4106
- return null;
4107
- }
4108
- acc = acc << frombits | value;
4109
- bits += frombits;
4110
- while (bits >= tobits) {
4111
- bits -= tobits;
4112
- ret.push(acc >> bits & maxv);
4113
- }
4114
- }
4115
- if (pad) {
4116
- if (bits > 0) {
4117
- ret.push(acc << tobits - bits & maxv);
4118
- }
4119
- } else if (bits >= frombits || acc << tobits - bits & maxv) {
4120
- return null;
4121
- }
4122
- return ret;
4123
- },
4124
- decode(hrp, addr) {
4125
- let bech32m = false;
4126
- let dec = bech32.decode(addr, "bech32");
4127
- if (dec === null) {
4128
- dec = bech32.decode(addr, "bech32m");
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
- return ret;
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 segwitAddress.decode(hrp, address) !== null;
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
- init_segwitAddr();
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 = 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));
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((env) => {
4252
- const network = env ?? process.env.CHAINFLIP_NETWORK;
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, paramsParser) => async (urlOrNetwork, params) => {
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: paramsParser?.parse(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 parsedParams = executeSwapParamsSchema.parse(params);
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,