@chainflip/sdk 1.5.1-react-native.1 → 1.5.1-react-native.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.
@@ -1,8 +1,12 @@
1
- import { __name, isString, InternalAssets, Chains, Assets, ChainflipNetworks, isValidAssetAndChain, getInternalAssets, assert } from './chunk-3V7QJANN.mjs';
1
+ import { __name, isString, InternalAssets, Chains, Assets, ChainflipNetworks, isValidAssetAndChain, getInternalAssets, assert as assert$1 } from './chunk-EBZERIHA.mjs';
2
+ import { assert } from '@chainflip/utils/assertion';
3
+ import * as base58 from '@chainflip/utils/base58';
4
+ import { hexToBytes } from '@chainflip/utils/bytes';
5
+ import * as nc from 'crypto';
2
6
  import * as ss582 from '@chainflip/utils/ss58';
3
7
  import '@chainflip/utils/string';
4
8
  import * as ethers from 'ethers';
5
- import { BitcoinAddress } from 'bech32-buffer';
9
+ import { hexEncodeNumber } from '@chainflip/utils/number';
6
10
 
7
11
  // ../../node_modules/.pnpm/zod@3.23.8/node_modules/zod/lib/index.mjs
8
12
  var util;
@@ -541,13 +545,13 @@ function processCreateParams(params) {
541
545
  if (errorMap3)
542
546
  return { errorMap: errorMap3, description };
543
547
  const customMap = /* @__PURE__ */ __name((iss, ctx) => {
544
- var _a, _b;
548
+ var _a2, _b;
545
549
  const { message } = params;
546
550
  if (iss.code === "invalid_enum_value") {
547
551
  return { message: message !== null && message !== void 0 ? message : ctx.defaultError };
548
552
  }
549
553
  if (typeof ctx.data === "undefined") {
550
- return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError };
554
+ return { message: (_a2 = message !== null && message !== void 0 ? message : required_error) !== null && _a2 !== void 0 ? _a2 : ctx.defaultError };
551
555
  }
552
556
  if (iss.code !== "invalid_type")
553
557
  return { message: ctx.defaultError };
@@ -632,11 +636,11 @@ var _ZodType = class _ZodType {
632
636
  throw result.error;
633
637
  }
634
638
  safeParse(data, params) {
635
- var _a;
639
+ var _a2;
636
640
  const ctx = {
637
641
  common: {
638
642
  issues: [],
639
- async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
643
+ async: (_a2 = params === null || params === void 0 ? void 0 : params.async) !== null && _a2 !== void 0 ? _a2 : false,
640
644
  contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap
641
645
  },
642
646
  path: (params === null || params === void 0 ? void 0 : params.path) || [],
@@ -995,7 +999,7 @@ var _ZodString = class _ZodString extends ZodType {
995
999
  } else if (check.kind === "url") {
996
1000
  try {
997
1001
  new URL(input.data);
998
- } catch (_a) {
1002
+ } catch (_a2) {
999
1003
  ctx = this._getOrReturnCtx(input, ctx);
1000
1004
  addIssueToContext(ctx, {
1001
1005
  validation: "url",
@@ -1165,7 +1169,7 @@ var _ZodString = class _ZodString extends ZodType {
1165
1169
  return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) });
1166
1170
  }
1167
1171
  datetime(options) {
1168
- var _a, _b;
1172
+ var _a2, _b;
1169
1173
  if (typeof options === "string") {
1170
1174
  return this._addCheck({
1171
1175
  kind: "datetime",
@@ -1178,7 +1182,7 @@ var _ZodString = class _ZodString extends ZodType {
1178
1182
  return this._addCheck({
1179
1183
  kind: "datetime",
1180
1184
  precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
1181
- offset: (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : false,
1185
+ offset: (_a2 = options === null || options === void 0 ? void 0 : options.offset) !== null && _a2 !== void 0 ? _a2 : false,
1182
1186
  local: (_b = options === null || options === void 0 ? void 0 : options.local) !== null && _b !== void 0 ? _b : false,
1183
1187
  ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message)
1184
1188
  });
@@ -1344,11 +1348,11 @@ var _ZodString = class _ZodString extends ZodType {
1344
1348
  __name(_ZodString, "ZodString");
1345
1349
  var ZodString = _ZodString;
1346
1350
  ZodString.create = (params) => {
1347
- var _a;
1351
+ var _a2;
1348
1352
  return new ZodString({
1349
1353
  checks: [],
1350
1354
  typeName: ZodFirstPartyTypeKind.ZodString,
1351
- coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
1355
+ coerce: (_a2 = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a2 !== void 0 ? _a2 : false,
1352
1356
  ...processCreateParams(params)
1353
1357
  });
1354
1358
  };
@@ -1754,11 +1758,11 @@ var _ZodBigInt = class _ZodBigInt extends ZodType {
1754
1758
  __name(_ZodBigInt, "ZodBigInt");
1755
1759
  var ZodBigInt = _ZodBigInt;
1756
1760
  ZodBigInt.create = (params) => {
1757
- var _a;
1761
+ var _a2;
1758
1762
  return new ZodBigInt({
1759
1763
  checks: [],
1760
1764
  typeName: ZodFirstPartyTypeKind.ZodBigInt,
1761
- coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
1765
+ coerce: (_a2 = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a2 !== void 0 ? _a2 : false,
1762
1766
  ...processCreateParams(params)
1763
1767
  });
1764
1768
  };
@@ -2285,8 +2289,8 @@ var _ZodObject = class _ZodObject extends ZodType {
2285
2289
  unknownKeys: "strict",
2286
2290
  ...message !== void 0 ? {
2287
2291
  errorMap: /* @__PURE__ */ __name((issue, ctx) => {
2288
- var _a, _b, _c, _d;
2289
- const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
2292
+ var _a2, _b, _c, _d;
2293
+ const defaultError = (_c = (_b = (_a2 = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a2, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
2290
2294
  if (issue.code === "unrecognized_keys")
2291
2295
  return {
2292
2296
  message: (_d = errorUtil.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError
@@ -3799,10 +3803,10 @@ ZodReadonly.create = (type, params) => {
3799
3803
  function custom(check, params = {}, fatal) {
3800
3804
  if (check)
3801
3805
  return ZodAny.create().superRefine((data, ctx) => {
3802
- var _a, _b;
3806
+ var _a2, _b;
3803
3807
  if (!check(data)) {
3804
3808
  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
3805
- const _fatal = (_b = (_a = p.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
3809
+ const _fatal = (_b = (_a2 = p.fatal) !== null && _a2 !== void 0 ? _a2 : fatal) !== null && _b !== void 0 ? _b : true;
3806
3810
  const p2 = typeof p === "string" ? { message: p } : p;
3807
3811
  ctx.addIssue({ code: "custom", ...p2, fatal: _fatal });
3808
3812
  }
@@ -4020,219 +4024,1810 @@ var z = /* @__PURE__ */ Object.freeze({
4020
4024
  ZodError
4021
4025
  });
4022
4026
 
4023
- // ../../node_modules/.pnpm/@chainflip+bitcoin@0.2.2/node_modules/@chainflip/bitcoin/dist/index.mjs
4024
- var __create = Object.create;
4025
- var __defProp = Object.defineProperty;
4026
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4027
- var __getOwnPropNames = Object.getOwnPropertyNames;
4028
- var __getProtoOf = Object.getPrototypeOf;
4029
- var __hasOwnProp = Object.prototype.hasOwnProperty;
4030
- var __commonJS = /* @__PURE__ */ __name((cb, mod) => /* @__PURE__ */ __name(function __require() {
4031
- return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
4032
- }, "__require"), "__commonJS");
4033
- var __copyProps = /* @__PURE__ */ __name((to, from, except, desc) => {
4034
- if (from && typeof from === "object" || typeof from === "function") {
4035
- for (let key of __getOwnPropNames(from))
4036
- if (!__hasOwnProp.call(to, key) && key !== except)
4037
- __defProp(to, key, { get: /* @__PURE__ */ __name(() => from[key], "get"), enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
4038
- }
4039
- return to;
4040
- }, "__copyProps");
4041
- var __toESM = /* @__PURE__ */ __name((mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
4042
- // If the importer is in node compatibility mode or this is not an ESM
4043
- // file that has been converted to a CommonJS file using a Babel-
4044
- // compatible transform (i.e. "__esModule" has not been set), then set
4045
- // "default" to the CommonJS "module.exports" for node compatibility.
4046
- isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
4047
- mod
4048
- )), "__toESM");
4049
- var require_bitcoin = __commonJS({
4050
- "wasm:./built/bitcoin.js"(exports, module) {
4051
- var imports = {};
4052
- imports["__wbindgen_placeholder__"] = module.exports;
4053
- var wasm;
4054
- var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
4055
- cachedTextDecoder.decode();
4056
- var cachedUint8Memory0 = null;
4057
- function getUint8Memory0() {
4058
- if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
4059
- cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
4027
+ // ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/_assert.js
4028
+ function isBytes(a) {
4029
+ return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
4030
+ }
4031
+ __name(isBytes, "isBytes");
4032
+ function bytes(b, ...lengths) {
4033
+ if (!isBytes(b)) throw new Error("Uint8Array expected");
4034
+ if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
4035
+ }
4036
+ __name(bytes, "bytes");
4037
+ function exists(instance, checkFinished = true) {
4038
+ if (instance.destroyed) throw new Error("Hash instance has been destroyed");
4039
+ if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
4040
+ }
4041
+ __name(exists, "exists");
4042
+ function output(out, instance) {
4043
+ bytes(out);
4044
+ const min = instance.outputLen;
4045
+ if (out.length < min) {
4046
+ throw new Error(`digestInto() expects output buffer of length at least ${min}`);
4047
+ }
4048
+ }
4049
+ __name(output, "output");
4050
+ var crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : void 0;
4051
+
4052
+ // ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/utils.js
4053
+ var createView = /* @__PURE__ */ __name((arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength), "createView");
4054
+ var rotr = /* @__PURE__ */ __name((word, shift) => word << 32 - shift | word >>> shift, "rotr");
4055
+ new Uint8Array(new Uint32Array([
4056
+ 287454020
4057
+ ]).buffer)[0] === 68;
4058
+ function utf8ToBytes(str) {
4059
+ if (typeof str !== "string") throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
4060
+ return new Uint8Array(new TextEncoder().encode(str));
4061
+ }
4062
+ __name(utf8ToBytes, "utf8ToBytes");
4063
+ function toBytes(data) {
4064
+ if (typeof data === "string") data = utf8ToBytes(data);
4065
+ bytes(data);
4066
+ return data;
4067
+ }
4068
+ __name(toBytes, "toBytes");
4069
+ var _Hash = class _Hash {
4070
+ // Safe version that clones internal state
4071
+ clone() {
4072
+ return this._cloneInto();
4073
+ }
4074
+ };
4075
+ __name(_Hash, "Hash");
4076
+ var Hash = _Hash;
4077
+ function wrapConstructor(hashCons) {
4078
+ const hashC = /* @__PURE__ */ __name((msg) => hashCons().update(toBytes(msg)).digest(), "hashC");
4079
+ const tmp = hashCons();
4080
+ hashC.outputLen = tmp.outputLen;
4081
+ hashC.blockLen = tmp.blockLen;
4082
+ hashC.create = () => hashCons();
4083
+ return hashC;
4084
+ }
4085
+ __name(wrapConstructor, "wrapConstructor");
4086
+ function randomBytes(bytesLength = 32) {
4087
+ if (crypto && typeof crypto.getRandomValues === "function") {
4088
+ return crypto.getRandomValues(new Uint8Array(bytesLength));
4089
+ }
4090
+ throw new Error("crypto.getRandomValues must be defined");
4091
+ }
4092
+ __name(randomBytes, "randomBytes");
4093
+
4094
+ // ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/_md.js
4095
+ function setBigUint64(view, byteOffset, value, isLE2) {
4096
+ if (typeof view.setBigUint64 === "function") return view.setBigUint64(byteOffset, value, isLE2);
4097
+ const _32n2 = BigInt(32);
4098
+ const _u32_max = BigInt(4294967295);
4099
+ const wh = Number(value >> _32n2 & _u32_max);
4100
+ const wl = Number(value & _u32_max);
4101
+ const h = isLE2 ? 4 : 0;
4102
+ const l = isLE2 ? 0 : 4;
4103
+ view.setUint32(byteOffset + h, wh, isLE2);
4104
+ view.setUint32(byteOffset + l, wl, isLE2);
4105
+ }
4106
+ __name(setBigUint64, "setBigUint64");
4107
+ var Chi = /* @__PURE__ */ __name((a, b, c) => a & b ^ ~a & c, "Chi");
4108
+ var Maj = /* @__PURE__ */ __name((a, b, c) => a & b ^ a & c ^ b & c, "Maj");
4109
+ var _HashMD = class _HashMD extends Hash {
4110
+ constructor(blockLen, outputLen, padOffset, isLE2) {
4111
+ super();
4112
+ this.blockLen = blockLen;
4113
+ this.outputLen = outputLen;
4114
+ this.padOffset = padOffset;
4115
+ this.isLE = isLE2;
4116
+ this.finished = false;
4117
+ this.length = 0;
4118
+ this.pos = 0;
4119
+ this.destroyed = false;
4120
+ this.buffer = new Uint8Array(blockLen);
4121
+ this.view = createView(this.buffer);
4122
+ }
4123
+ update(data) {
4124
+ exists(this);
4125
+ const { view, buffer, blockLen } = this;
4126
+ data = toBytes(data);
4127
+ const len = data.length;
4128
+ for (let pos = 0; pos < len; ) {
4129
+ const take = Math.min(blockLen - this.pos, len - pos);
4130
+ if (take === blockLen) {
4131
+ const dataView = createView(data);
4132
+ for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
4133
+ continue;
4060
4134
  }
4061
- return cachedUint8Memory0;
4062
- }
4063
- __name(getUint8Memory0, "getUint8Memory0");
4064
- function getStringFromWasm0(ptr, len) {
4065
- ptr = ptr >>> 0;
4066
- return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
4067
- }
4068
- __name(getStringFromWasm0, "getStringFromWasm0");
4069
- var heap = new Array(128).fill(void 0);
4070
- heap.push(void 0, null, true, false);
4071
- var heap_next = heap.length;
4072
- function addHeapObject(obj) {
4073
- if (heap_next === heap.length)
4074
- heap.push(heap.length + 1);
4075
- const idx = heap_next;
4076
- heap_next = heap[idx];
4077
- heap[idx] = obj;
4078
- return idx;
4079
- }
4080
- __name(addHeapObject, "addHeapObject");
4081
- function getObject(idx) {
4082
- return heap[idx];
4083
- }
4084
- __name(getObject, "getObject");
4085
- function dropObject(idx) {
4086
- if (idx < 132)
4087
- return;
4088
- heap[idx] = heap_next;
4089
- heap_next = idx;
4090
- }
4091
- __name(dropObject, "dropObject");
4092
- function takeObject(idx) {
4093
- const ret = getObject(idx);
4094
- dropObject(idx);
4095
- return ret;
4096
- }
4097
- __name(takeObject, "takeObject");
4098
- var WASM_VECTOR_LEN = 0;
4099
- var cachedTextEncoder = new TextEncoder("utf-8");
4100
- var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
4101
- return cachedTextEncoder.encodeInto(arg, view);
4102
- } : function(arg, view) {
4103
- const buf = cachedTextEncoder.encode(arg);
4104
- view.set(buf);
4105
- return {
4106
- read: arg.length,
4107
- written: buf.length
4108
- };
4109
- };
4110
- function passStringToWasm0(arg, malloc, realloc) {
4111
- if (realloc === void 0) {
4112
- const buf = cachedTextEncoder.encode(arg);
4113
- const ptr2 = malloc(buf.length, 1) >>> 0;
4114
- getUint8Memory0().subarray(ptr2, ptr2 + buf.length).set(buf);
4115
- WASM_VECTOR_LEN = buf.length;
4116
- return ptr2;
4135
+ buffer.set(data.subarray(pos, pos + take), this.pos);
4136
+ this.pos += take;
4137
+ pos += take;
4138
+ if (this.pos === blockLen) {
4139
+ this.process(view, 0);
4140
+ this.pos = 0;
4117
4141
  }
4118
- let len = arg.length;
4119
- let ptr = malloc(len, 1) >>> 0;
4120
- const mem = getUint8Memory0();
4121
- let offset = 0;
4122
- for (; offset < len; offset++) {
4123
- const code = arg.charCodeAt(offset);
4124
- if (code > 127)
4125
- break;
4126
- mem[ptr + offset] = code;
4142
+ }
4143
+ this.length += data.length;
4144
+ this.roundClean();
4145
+ return this;
4146
+ }
4147
+ digestInto(out) {
4148
+ exists(this);
4149
+ output(out, this);
4150
+ this.finished = true;
4151
+ const { buffer, view, blockLen, isLE: isLE2 } = this;
4152
+ let { pos } = this;
4153
+ buffer[pos++] = 128;
4154
+ this.buffer.subarray(pos).fill(0);
4155
+ if (this.padOffset > blockLen - pos) {
4156
+ this.process(view, 0);
4157
+ pos = 0;
4158
+ }
4159
+ for (let i = pos; i < blockLen; i++) buffer[i] = 0;
4160
+ setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
4161
+ this.process(view, 0);
4162
+ const oview = createView(out);
4163
+ const len = this.outputLen;
4164
+ if (len % 4) throw new Error("_sha2: outputLen should be aligned to 32bit");
4165
+ const outLen = len / 4;
4166
+ const state = this.get();
4167
+ if (outLen > state.length) throw new Error("_sha2: outputLen bigger than state");
4168
+ for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE2);
4169
+ }
4170
+ digest() {
4171
+ const { buffer, outputLen } = this;
4172
+ this.digestInto(buffer);
4173
+ const res = buffer.slice(0, outputLen);
4174
+ this.destroy();
4175
+ return res;
4176
+ }
4177
+ _cloneInto(to) {
4178
+ to || (to = new this.constructor());
4179
+ to.set(...this.get());
4180
+ const { blockLen, buffer, length, finished, destroyed, pos } = this;
4181
+ to.length = length;
4182
+ to.pos = pos;
4183
+ to.finished = finished;
4184
+ to.destroyed = destroyed;
4185
+ if (length % blockLen) to.buffer.set(buffer);
4186
+ return to;
4187
+ }
4188
+ };
4189
+ __name(_HashMD, "HashMD");
4190
+ var HashMD = _HashMD;
4191
+
4192
+ // ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/sha256.js
4193
+ var SHA256_K = /* @__PURE__ */ new Uint32Array([
4194
+ 1116352408,
4195
+ 1899447441,
4196
+ 3049323471,
4197
+ 3921009573,
4198
+ 961987163,
4199
+ 1508970993,
4200
+ 2453635748,
4201
+ 2870763221,
4202
+ 3624381080,
4203
+ 310598401,
4204
+ 607225278,
4205
+ 1426881987,
4206
+ 1925078388,
4207
+ 2162078206,
4208
+ 2614888103,
4209
+ 3248222580,
4210
+ 3835390401,
4211
+ 4022224774,
4212
+ 264347078,
4213
+ 604807628,
4214
+ 770255983,
4215
+ 1249150122,
4216
+ 1555081692,
4217
+ 1996064986,
4218
+ 2554220882,
4219
+ 2821834349,
4220
+ 2952996808,
4221
+ 3210313671,
4222
+ 3336571891,
4223
+ 3584528711,
4224
+ 113926993,
4225
+ 338241895,
4226
+ 666307205,
4227
+ 773529912,
4228
+ 1294757372,
4229
+ 1396182291,
4230
+ 1695183700,
4231
+ 1986661051,
4232
+ 2177026350,
4233
+ 2456956037,
4234
+ 2730485921,
4235
+ 2820302411,
4236
+ 3259730800,
4237
+ 3345764771,
4238
+ 3516065817,
4239
+ 3600352804,
4240
+ 4094571909,
4241
+ 275423344,
4242
+ 430227734,
4243
+ 506948616,
4244
+ 659060556,
4245
+ 883997877,
4246
+ 958139571,
4247
+ 1322822218,
4248
+ 1537002063,
4249
+ 1747873779,
4250
+ 1955562222,
4251
+ 2024104815,
4252
+ 2227730452,
4253
+ 2361852424,
4254
+ 2428436474,
4255
+ 2756734187,
4256
+ 3204031479,
4257
+ 3329325298
4258
+ ]);
4259
+ var SHA256_IV = /* @__PURE__ */ new Uint32Array([
4260
+ 1779033703,
4261
+ 3144134277,
4262
+ 1013904242,
4263
+ 2773480762,
4264
+ 1359893119,
4265
+ 2600822924,
4266
+ 528734635,
4267
+ 1541459225
4268
+ ]);
4269
+ var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
4270
+ var _a;
4271
+ var SHA256 = (_a = class extends HashMD {
4272
+ constructor() {
4273
+ super(64, 32, 8, false);
4274
+ this.A = SHA256_IV[0] | 0;
4275
+ this.B = SHA256_IV[1] | 0;
4276
+ this.C = SHA256_IV[2] | 0;
4277
+ this.D = SHA256_IV[3] | 0;
4278
+ this.E = SHA256_IV[4] | 0;
4279
+ this.F = SHA256_IV[5] | 0;
4280
+ this.G = SHA256_IV[6] | 0;
4281
+ this.H = SHA256_IV[7] | 0;
4282
+ }
4283
+ get() {
4284
+ const { A, B, C, D, E, F, G, H } = this;
4285
+ return [
4286
+ A,
4287
+ B,
4288
+ C,
4289
+ D,
4290
+ E,
4291
+ F,
4292
+ G,
4293
+ H
4294
+ ];
4295
+ }
4296
+ // prettier-ignore
4297
+ set(A, B, C, D, E, F, G, H) {
4298
+ this.A = A | 0;
4299
+ this.B = B | 0;
4300
+ this.C = C | 0;
4301
+ this.D = D | 0;
4302
+ this.E = E | 0;
4303
+ this.F = F | 0;
4304
+ this.G = G | 0;
4305
+ this.H = H | 0;
4306
+ }
4307
+ process(view, offset) {
4308
+ for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
4309
+ for (let i = 16; i < 64; i++) {
4310
+ const W15 = SHA256_W[i - 15];
4311
+ const W2 = SHA256_W[i - 2];
4312
+ const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
4313
+ const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
4314
+ SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
4315
+ }
4316
+ let { A, B, C, D, E, F, G, H } = this;
4317
+ for (let i = 0; i < 64; i++) {
4318
+ const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
4319
+ const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
4320
+ const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
4321
+ const T2 = sigma0 + Maj(A, B, C) | 0;
4322
+ H = G;
4323
+ G = F;
4324
+ F = E;
4325
+ E = D + T1 | 0;
4326
+ D = C;
4327
+ C = B;
4328
+ B = A;
4329
+ A = T1 + T2 | 0;
4330
+ }
4331
+ A = A + this.A | 0;
4332
+ B = B + this.B | 0;
4333
+ C = C + this.C | 0;
4334
+ D = D + this.D | 0;
4335
+ E = E + this.E | 0;
4336
+ F = F + this.F | 0;
4337
+ G = G + this.G | 0;
4338
+ H = H + this.H | 0;
4339
+ this.set(A, B, C, D, E, F, G, H);
4340
+ }
4341
+ roundClean() {
4342
+ SHA256_W.fill(0);
4343
+ }
4344
+ destroy() {
4345
+ this.set(0, 0, 0, 0, 0, 0, 0, 0);
4346
+ this.buffer.fill(0);
4347
+ }
4348
+ }, __name(_a, "SHA256"), _a);
4349
+ var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
4350
+
4351
+ // ../../node_modules/.pnpm/@chainflip+bitcoin@1.0.1/node_modules/@chainflip/bitcoin/dist/index.mjs
4352
+ var p2pkhAddressVersion = {
4353
+ mainnet: 0,
4354
+ testnet: 111,
4355
+ regtest: 111
4356
+ };
4357
+ var p2shAddressVersion = {
4358
+ mainnet: 5,
4359
+ testnet: 196,
4360
+ regtest: 196
4361
+ };
4362
+ function parseBase58Address(address, network) {
4363
+ const checksumLength = 4;
4364
+ const payloadLength = 21;
4365
+ const data = base58.decode(address);
4366
+ if (data.length !== payloadLength + checksumLength)
4367
+ return null;
4368
+ const payload = data.slice(0, payloadLength);
4369
+ const checksum = data.slice(-checksumLength);
4370
+ const computedChecksum = sha256(sha256(payload)).slice(0, checksumLength);
4371
+ if (!computedChecksum.every((byte, i) => byte === checksum[i]))
4372
+ return null;
4373
+ const [version, ...hash] = payload;
4374
+ if (version === p2pkhAddressVersion[network]) {
4375
+ return { type: "p2pkh", hash };
4376
+ }
4377
+ if (version === p2shAddressVersion[network]) {
4378
+ return { type: "p2sh", hash };
4379
+ }
4380
+ return null;
4381
+ }
4382
+ __name(parseBase58Address, "parseBase58Address");
4383
+ var BECH32_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
4384
+ function decodeBech32(address) {
4385
+ const pos = address.lastIndexOf("1");
4386
+ if (pos === -1 || pos === 0 || pos + 7 > address.length) {
4387
+ return null;
4388
+ }
4389
+ const hrp = address.substring(0, pos);
4390
+ const data = [];
4391
+ for (let i = pos + 1; i < address.length; i++) {
4392
+ const charIndex = BECH32_CHARSET.indexOf(address[i]);
4393
+ if (charIndex === -1)
4394
+ return null;
4395
+ data.push(charIndex);
4396
+ }
4397
+ return { hrp, data };
4398
+ }
4399
+ __name(decodeBech32, "decodeBech32");
4400
+ function polymod(values) {
4401
+ const generators = [996825010, 642813549, 513874426, 1027748829, 705979059];
4402
+ let chk = 1;
4403
+ for (const value of values) {
4404
+ const top = chk >> 25;
4405
+ chk = (chk & 33554431) << 5 ^ value;
4406
+ for (let i = 0; i < 5; i++) {
4407
+ if (top >> i & 1) {
4408
+ chk ^= generators[i];
4127
4409
  }
4128
- if (offset !== len) {
4129
- if (offset !== 0) {
4130
- arg = arg.slice(offset);
4131
- }
4132
- ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
4133
- const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
4134
- const ret = encodeString(arg, view);
4135
- offset += ret.written;
4136
- ptr = realloc(ptr, len, offset, 1) >>> 0;
4410
+ }
4411
+ }
4412
+ return chk;
4413
+ }
4414
+ __name(polymod, "polymod");
4415
+ function hrpExpand(hrp) {
4416
+ const ret = [];
4417
+ for (let i = 0; i < hrp.length; i++) {
4418
+ ret.push(hrp.charCodeAt(i) >> 5);
4419
+ }
4420
+ ret.push(0);
4421
+ for (let i = 0; i < hrp.length; i++) {
4422
+ ret.push(hrp.charCodeAt(i) & 31);
4423
+ }
4424
+ return ret;
4425
+ }
4426
+ __name(hrpExpand, "hrpExpand");
4427
+ function computeChecksum(hrp, data) {
4428
+ return polymod(hrpExpand(hrp).concat(data));
4429
+ }
4430
+ __name(computeChecksum, "computeChecksum");
4431
+ function convert5BitGroupsToBytes(data) {
4432
+ let acc = 0;
4433
+ let bits = 0;
4434
+ const result = [];
4435
+ for (let i = 0; i < data.length; i++) {
4436
+ acc = acc << 5 | data[i];
4437
+ bits += 5;
4438
+ if (bits >= 8) {
4439
+ result.push(acc >> bits - 8 & 255);
4440
+ bits -= 8;
4441
+ }
4442
+ }
4443
+ if (bits > 0) {
4444
+ const remainingByte = acc << 8 - bits & 255;
4445
+ if (remainingByte !== 0 || bits > 5) {
4446
+ result.push(remainingByte);
4447
+ }
4448
+ }
4449
+ return new Uint8Array(result);
4450
+ }
4451
+ __name(convert5BitGroupsToBytes, "convert5BitGroupsToBytes");
4452
+ function decodeSegwitAddress(address) {
4453
+ const decoded = decodeBech32(address.toLowerCase());
4454
+ if (!decoded) {
4455
+ return null;
4456
+ }
4457
+ const { hrp, data: dataWithChecksum } = decoded;
4458
+ const checksum = computeChecksum(hrp, dataWithChecksum);
4459
+ let type;
4460
+ if (checksum === 1) {
4461
+ type = "bech32";
4462
+ } else if (checksum === 734539939) {
4463
+ type = "bech32m";
4464
+ } else {
4465
+ return null;
4466
+ }
4467
+ const data = convert5BitGroupsToBytes(dataWithChecksum.slice(1, -6));
4468
+ const [version] = dataWithChecksum;
4469
+ assert(data.length >= 2 && data.length <= 40, "Invalid address");
4470
+ assert(version !== 0 || data.length === 20 || data.length === 32, "Invalid address");
4471
+ return { hrp, data, type, version };
4472
+ }
4473
+ __name(decodeSegwitAddress, "decodeSegwitAddress");
4474
+ var isValidAddressForNetwork = /* @__PURE__ */ __name((address, network) => {
4475
+ if (network === "mainnet") {
4476
+ if (/^(1|3)/.test(address)) {
4477
+ return parseBase58Address(address, network) !== null;
4478
+ }
4479
+ if (/^bc1/.test(address)) {
4480
+ return decodeSegwitAddress(address) !== null;
4481
+ }
4482
+ } else {
4483
+ if (/^(m|n|2)/.test(address)) {
4484
+ return parseBase58Address(address, network) !== null;
4485
+ }
4486
+ if (network === "regtest" && /^bcrt1/.test(address)) {
4487
+ return decodeSegwitAddress(address) !== null;
4488
+ }
4489
+ if (network === "testnet" && /^tb1/.test(address)) {
4490
+ return decodeSegwitAddress(address) !== null;
4491
+ }
4492
+ }
4493
+ return false;
4494
+ }, "isValidAddressForNetwork");
4495
+
4496
+ // ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/_u64.js
4497
+ var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
4498
+ var _32n = /* @__PURE__ */ BigInt(32);
4499
+ function fromBig(n, le = false) {
4500
+ if (le) return {
4501
+ h: Number(n & U32_MASK64),
4502
+ l: Number(n >> _32n & U32_MASK64)
4503
+ };
4504
+ return {
4505
+ h: Number(n >> _32n & U32_MASK64) | 0,
4506
+ l: Number(n & U32_MASK64) | 0
4507
+ };
4508
+ }
4509
+ __name(fromBig, "fromBig");
4510
+ function split(lst, le = false) {
4511
+ let Ah = new Uint32Array(lst.length);
4512
+ let Al = new Uint32Array(lst.length);
4513
+ for (let i = 0; i < lst.length; i++) {
4514
+ const { h, l } = fromBig(lst[i], le);
4515
+ [Ah[i], Al[i]] = [
4516
+ h,
4517
+ l
4518
+ ];
4519
+ }
4520
+ return [
4521
+ Ah,
4522
+ Al
4523
+ ];
4524
+ }
4525
+ __name(split, "split");
4526
+ var toBig = /* @__PURE__ */ __name((h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0), "toBig");
4527
+ var shrSH = /* @__PURE__ */ __name((h, _l, s) => h >>> s, "shrSH");
4528
+ var shrSL = /* @__PURE__ */ __name((h, l, s) => h << 32 - s | l >>> s, "shrSL");
4529
+ var rotrSH = /* @__PURE__ */ __name((h, l, s) => h >>> s | l << 32 - s, "rotrSH");
4530
+ var rotrSL = /* @__PURE__ */ __name((h, l, s) => h << 32 - s | l >>> s, "rotrSL");
4531
+ var rotrBH = /* @__PURE__ */ __name((h, l, s) => h << 64 - s | l >>> s - 32, "rotrBH");
4532
+ var rotrBL = /* @__PURE__ */ __name((h, l, s) => h >>> s - 32 | l << 64 - s, "rotrBL");
4533
+ var rotr32H = /* @__PURE__ */ __name((_h, l) => l, "rotr32H");
4534
+ var rotr32L = /* @__PURE__ */ __name((h, _l) => h, "rotr32L");
4535
+ var rotlSH = /* @__PURE__ */ __name((h, l, s) => h << s | l >>> 32 - s, "rotlSH");
4536
+ var rotlSL = /* @__PURE__ */ __name((h, l, s) => l << s | h >>> 32 - s, "rotlSL");
4537
+ var rotlBH = /* @__PURE__ */ __name((h, l, s) => l << s - 32 | h >>> 64 - s, "rotlBH");
4538
+ var rotlBL = /* @__PURE__ */ __name((h, l, s) => h << s - 32 | l >>> 64 - s, "rotlBL");
4539
+ function add(Ah, Al, Bh, Bl) {
4540
+ const l = (Al >>> 0) + (Bl >>> 0);
4541
+ return {
4542
+ h: Ah + Bh + (l / 2 ** 32 | 0) | 0,
4543
+ l: l | 0
4544
+ };
4545
+ }
4546
+ __name(add, "add");
4547
+ var add3L = /* @__PURE__ */ __name((Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0), "add3L");
4548
+ var add3H = /* @__PURE__ */ __name((low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0, "add3H");
4549
+ var add4L = /* @__PURE__ */ __name((Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0), "add4L");
4550
+ var add4H = /* @__PURE__ */ __name((low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0, "add4H");
4551
+ var add5L = /* @__PURE__ */ __name((Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0), "add5L");
4552
+ var add5H = /* @__PURE__ */ __name((low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0, "add5H");
4553
+ var u64 = {
4554
+ fromBig,
4555
+ split,
4556
+ toBig,
4557
+ shrSH,
4558
+ shrSL,
4559
+ rotrSH,
4560
+ rotrSL,
4561
+ rotrBH,
4562
+ rotrBL,
4563
+ rotr32H,
4564
+ rotr32L,
4565
+ rotlSH,
4566
+ rotlSL,
4567
+ rotlBH,
4568
+ rotlBL,
4569
+ add,
4570
+ add3L,
4571
+ add3H,
4572
+ add4L,
4573
+ add4H,
4574
+ add5H,
4575
+ add5L
4576
+ };
4577
+ var u64_default = u64;
4578
+
4579
+ // ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/sha512.js
4580
+ var [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => u64_default.split([
4581
+ "0x428a2f98d728ae22",
4582
+ "0x7137449123ef65cd",
4583
+ "0xb5c0fbcfec4d3b2f",
4584
+ "0xe9b5dba58189dbbc",
4585
+ "0x3956c25bf348b538",
4586
+ "0x59f111f1b605d019",
4587
+ "0x923f82a4af194f9b",
4588
+ "0xab1c5ed5da6d8118",
4589
+ "0xd807aa98a3030242",
4590
+ "0x12835b0145706fbe",
4591
+ "0x243185be4ee4b28c",
4592
+ "0x550c7dc3d5ffb4e2",
4593
+ "0x72be5d74f27b896f",
4594
+ "0x80deb1fe3b1696b1",
4595
+ "0x9bdc06a725c71235",
4596
+ "0xc19bf174cf692694",
4597
+ "0xe49b69c19ef14ad2",
4598
+ "0xefbe4786384f25e3",
4599
+ "0x0fc19dc68b8cd5b5",
4600
+ "0x240ca1cc77ac9c65",
4601
+ "0x2de92c6f592b0275",
4602
+ "0x4a7484aa6ea6e483",
4603
+ "0x5cb0a9dcbd41fbd4",
4604
+ "0x76f988da831153b5",
4605
+ "0x983e5152ee66dfab",
4606
+ "0xa831c66d2db43210",
4607
+ "0xb00327c898fb213f",
4608
+ "0xbf597fc7beef0ee4",
4609
+ "0xc6e00bf33da88fc2",
4610
+ "0xd5a79147930aa725",
4611
+ "0x06ca6351e003826f",
4612
+ "0x142929670a0e6e70",
4613
+ "0x27b70a8546d22ffc",
4614
+ "0x2e1b21385c26c926",
4615
+ "0x4d2c6dfc5ac42aed",
4616
+ "0x53380d139d95b3df",
4617
+ "0x650a73548baf63de",
4618
+ "0x766a0abb3c77b2a8",
4619
+ "0x81c2c92e47edaee6",
4620
+ "0x92722c851482353b",
4621
+ "0xa2bfe8a14cf10364",
4622
+ "0xa81a664bbc423001",
4623
+ "0xc24b8b70d0f89791",
4624
+ "0xc76c51a30654be30",
4625
+ "0xd192e819d6ef5218",
4626
+ "0xd69906245565a910",
4627
+ "0xf40e35855771202a",
4628
+ "0x106aa07032bbd1b8",
4629
+ "0x19a4c116b8d2d0c8",
4630
+ "0x1e376c085141ab53",
4631
+ "0x2748774cdf8eeb99",
4632
+ "0x34b0bcb5e19b48a8",
4633
+ "0x391c0cb3c5c95a63",
4634
+ "0x4ed8aa4ae3418acb",
4635
+ "0x5b9cca4f7763e373",
4636
+ "0x682e6ff3d6b2b8a3",
4637
+ "0x748f82ee5defb2fc",
4638
+ "0x78a5636f43172f60",
4639
+ "0x84c87814a1f0ab72",
4640
+ "0x8cc702081a6439ec",
4641
+ "0x90befffa23631e28",
4642
+ "0xa4506cebde82bde9",
4643
+ "0xbef9a3f7b2c67915",
4644
+ "0xc67178f2e372532b",
4645
+ "0xca273eceea26619c",
4646
+ "0xd186b8c721c0c207",
4647
+ "0xeada7dd6cde0eb1e",
4648
+ "0xf57d4f7fee6ed178",
4649
+ "0x06f067aa72176fba",
4650
+ "0x0a637dc5a2c898a6",
4651
+ "0x113f9804bef90dae",
4652
+ "0x1b710b35131c471b",
4653
+ "0x28db77f523047d84",
4654
+ "0x32caab7b40c72493",
4655
+ "0x3c9ebe0a15c9bebc",
4656
+ "0x431d67c49c100d4c",
4657
+ "0x4cc5d4becb3e42b6",
4658
+ "0x597f299cfc657e2a",
4659
+ "0x5fcb6fab3ad6faec",
4660
+ "0x6c44198c4a475817"
4661
+ ].map((n) => BigInt(n))))();
4662
+ var SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
4663
+ var SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
4664
+ var _SHA512 = class _SHA512 extends HashMD {
4665
+ constructor() {
4666
+ super(128, 64, 16, false);
4667
+ this.Ah = 1779033703 | 0;
4668
+ this.Al = 4089235720 | 0;
4669
+ this.Bh = 3144134277 | 0;
4670
+ this.Bl = 2227873595 | 0;
4671
+ this.Ch = 1013904242 | 0;
4672
+ this.Cl = 4271175723 | 0;
4673
+ this.Dh = 2773480762 | 0;
4674
+ this.Dl = 1595750129 | 0;
4675
+ this.Eh = 1359893119 | 0;
4676
+ this.El = 2917565137 | 0;
4677
+ this.Fh = 2600822924 | 0;
4678
+ this.Fl = 725511199 | 0;
4679
+ this.Gh = 528734635 | 0;
4680
+ this.Gl = 4215389547 | 0;
4681
+ this.Hh = 1541459225 | 0;
4682
+ this.Hl = 327033209 | 0;
4683
+ }
4684
+ // prettier-ignore
4685
+ get() {
4686
+ const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
4687
+ return [
4688
+ Ah,
4689
+ Al,
4690
+ Bh,
4691
+ Bl,
4692
+ Ch,
4693
+ Cl,
4694
+ Dh,
4695
+ Dl,
4696
+ Eh,
4697
+ El,
4698
+ Fh,
4699
+ Fl,
4700
+ Gh,
4701
+ Gl,
4702
+ Hh,
4703
+ Hl
4704
+ ];
4705
+ }
4706
+ // prettier-ignore
4707
+ set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
4708
+ this.Ah = Ah | 0;
4709
+ this.Al = Al | 0;
4710
+ this.Bh = Bh | 0;
4711
+ this.Bl = Bl | 0;
4712
+ this.Ch = Ch | 0;
4713
+ this.Cl = Cl | 0;
4714
+ this.Dh = Dh | 0;
4715
+ this.Dl = Dl | 0;
4716
+ this.Eh = Eh | 0;
4717
+ this.El = El | 0;
4718
+ this.Fh = Fh | 0;
4719
+ this.Fl = Fl | 0;
4720
+ this.Gh = Gh | 0;
4721
+ this.Gl = Gl | 0;
4722
+ this.Hh = Hh | 0;
4723
+ this.Hl = Hl | 0;
4724
+ }
4725
+ process(view, offset) {
4726
+ for (let i = 0; i < 16; i++, offset += 4) {
4727
+ SHA512_W_H[i] = view.getUint32(offset);
4728
+ SHA512_W_L[i] = view.getUint32(offset += 4);
4729
+ }
4730
+ for (let i = 16; i < 80; i++) {
4731
+ const W15h = SHA512_W_H[i - 15] | 0;
4732
+ const W15l = SHA512_W_L[i - 15] | 0;
4733
+ const s0h = u64_default.rotrSH(W15h, W15l, 1) ^ u64_default.rotrSH(W15h, W15l, 8) ^ u64_default.shrSH(W15h, W15l, 7);
4734
+ const s0l = u64_default.rotrSL(W15h, W15l, 1) ^ u64_default.rotrSL(W15h, W15l, 8) ^ u64_default.shrSL(W15h, W15l, 7);
4735
+ const W2h = SHA512_W_H[i - 2] | 0;
4736
+ const W2l = SHA512_W_L[i - 2] | 0;
4737
+ const s1h = u64_default.rotrSH(W2h, W2l, 19) ^ u64_default.rotrBH(W2h, W2l, 61) ^ u64_default.shrSH(W2h, W2l, 6);
4738
+ const s1l = u64_default.rotrSL(W2h, W2l, 19) ^ u64_default.rotrBL(W2h, W2l, 61) ^ u64_default.shrSL(W2h, W2l, 6);
4739
+ const SUMl = u64_default.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
4740
+ const SUMh = u64_default.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
4741
+ SHA512_W_H[i] = SUMh | 0;
4742
+ SHA512_W_L[i] = SUMl | 0;
4743
+ }
4744
+ let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
4745
+ for (let i = 0; i < 80; i++) {
4746
+ const sigma1h = u64_default.rotrSH(Eh, El, 14) ^ u64_default.rotrSH(Eh, El, 18) ^ u64_default.rotrBH(Eh, El, 41);
4747
+ const sigma1l = u64_default.rotrSL(Eh, El, 14) ^ u64_default.rotrSL(Eh, El, 18) ^ u64_default.rotrBL(Eh, El, 41);
4748
+ const CHIh = Eh & Fh ^ ~Eh & Gh;
4749
+ const CHIl = El & Fl ^ ~El & Gl;
4750
+ const T1ll = u64_default.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
4751
+ const T1h = u64_default.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
4752
+ const T1l = T1ll | 0;
4753
+ const sigma0h = u64_default.rotrSH(Ah, Al, 28) ^ u64_default.rotrBH(Ah, Al, 34) ^ u64_default.rotrBH(Ah, Al, 39);
4754
+ const sigma0l = u64_default.rotrSL(Ah, Al, 28) ^ u64_default.rotrBL(Ah, Al, 34) ^ u64_default.rotrBL(Ah, Al, 39);
4755
+ const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
4756
+ const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
4757
+ Hh = Gh | 0;
4758
+ Hl = Gl | 0;
4759
+ Gh = Fh | 0;
4760
+ Gl = Fl | 0;
4761
+ Fh = Eh | 0;
4762
+ Fl = El | 0;
4763
+ ({ h: Eh, l: El } = u64_default.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
4764
+ Dh = Ch | 0;
4765
+ Dl = Cl | 0;
4766
+ Ch = Bh | 0;
4767
+ Cl = Bl | 0;
4768
+ Bh = Ah | 0;
4769
+ Bl = Al | 0;
4770
+ const All = u64_default.add3L(T1l, sigma0l, MAJl);
4771
+ Ah = u64_default.add3H(All, T1h, sigma0h, MAJh);
4772
+ Al = All | 0;
4773
+ }
4774
+ ({ h: Ah, l: Al } = u64_default.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
4775
+ ({ h: Bh, l: Bl } = u64_default.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
4776
+ ({ h: Ch, l: Cl } = u64_default.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
4777
+ ({ h: Dh, l: Dl } = u64_default.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
4778
+ ({ h: Eh, l: El } = u64_default.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
4779
+ ({ h: Fh, l: Fl } = u64_default.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
4780
+ ({ h: Gh, l: Gl } = u64_default.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
4781
+ ({ h: Hh, l: Hl } = u64_default.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
4782
+ this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
4783
+ }
4784
+ roundClean() {
4785
+ SHA512_W_H.fill(0);
4786
+ SHA512_W_L.fill(0);
4787
+ }
4788
+ destroy() {
4789
+ this.buffer.fill(0);
4790
+ this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
4791
+ }
4792
+ };
4793
+ __name(_SHA512, "SHA512");
4794
+ var SHA512 = _SHA512;
4795
+ var sha512 = /* @__PURE__ */ wrapConstructor(() => new SHA512());
4796
+
4797
+ // ../../node_modules/.pnpm/@noble+curves@1.5.0/node_modules/@noble/curves/esm/abstract/utils.js
4798
+ var _0n = /* @__PURE__ */ BigInt(0);
4799
+ var _1n = /* @__PURE__ */ BigInt(1);
4800
+ var _2n = /* @__PURE__ */ BigInt(2);
4801
+ function isBytes2(a) {
4802
+ return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
4803
+ }
4804
+ __name(isBytes2, "isBytes");
4805
+ function abytes(item) {
4806
+ if (!isBytes2(item)) throw new Error("Uint8Array expected");
4807
+ }
4808
+ __name(abytes, "abytes");
4809
+ function abool(title, value) {
4810
+ if (typeof value !== "boolean") throw new Error(`${title} must be valid boolean, got "${value}".`);
4811
+ }
4812
+ __name(abool, "abool");
4813
+ var hexes = /* @__PURE__ */ Array.from({
4814
+ length: 256
4815
+ }, (_, i) => i.toString(16).padStart(2, "0"));
4816
+ function bytesToHex(bytes2) {
4817
+ abytes(bytes2);
4818
+ let hex = "";
4819
+ for (let i = 0; i < bytes2.length; i++) {
4820
+ hex += hexes[bytes2[i]];
4821
+ }
4822
+ return hex;
4823
+ }
4824
+ __name(bytesToHex, "bytesToHex");
4825
+ function hexToNumber(hex) {
4826
+ if (typeof hex !== "string") throw new Error("hex string expected, got " + typeof hex);
4827
+ return BigInt(hex === "" ? "0" : `0x${hex}`);
4828
+ }
4829
+ __name(hexToNumber, "hexToNumber");
4830
+ var asciis = {
4831
+ _0: 48,
4832
+ _9: 57,
4833
+ _A: 65,
4834
+ _F: 70,
4835
+ _a: 97,
4836
+ _f: 102
4837
+ };
4838
+ function asciiToBase16(char) {
4839
+ if (char >= asciis._0 && char <= asciis._9) return char - asciis._0;
4840
+ if (char >= asciis._A && char <= asciis._F) return char - (asciis._A - 10);
4841
+ if (char >= asciis._a && char <= asciis._f) return char - (asciis._a - 10);
4842
+ return;
4843
+ }
4844
+ __name(asciiToBase16, "asciiToBase16");
4845
+ function hexToBytes2(hex) {
4846
+ if (typeof hex !== "string") throw new Error("hex string expected, got " + typeof hex);
4847
+ const hl = hex.length;
4848
+ const al = hl / 2;
4849
+ if (hl % 2) throw new Error("padded hex string expected, got unpadded hex of length " + hl);
4850
+ const array = new Uint8Array(al);
4851
+ for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
4852
+ const n1 = asciiToBase16(hex.charCodeAt(hi));
4853
+ const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
4854
+ if (n1 === void 0 || n2 === void 0) {
4855
+ const char = hex[hi] + hex[hi + 1];
4856
+ throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
4857
+ }
4858
+ array[ai] = n1 * 16 + n2;
4859
+ }
4860
+ return array;
4861
+ }
4862
+ __name(hexToBytes2, "hexToBytes");
4863
+ function bytesToNumberBE(bytes2) {
4864
+ return hexToNumber(bytesToHex(bytes2));
4865
+ }
4866
+ __name(bytesToNumberBE, "bytesToNumberBE");
4867
+ function bytesToNumberLE(bytes2) {
4868
+ abytes(bytes2);
4869
+ return hexToNumber(bytesToHex(Uint8Array.from(bytes2).reverse()));
4870
+ }
4871
+ __name(bytesToNumberLE, "bytesToNumberLE");
4872
+ function numberToBytesBE(n, len) {
4873
+ return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
4874
+ }
4875
+ __name(numberToBytesBE, "numberToBytesBE");
4876
+ function numberToBytesLE(n, len) {
4877
+ return numberToBytesBE(n, len).reverse();
4878
+ }
4879
+ __name(numberToBytesLE, "numberToBytesLE");
4880
+ function ensureBytes(title, hex, expectedLength) {
4881
+ let res;
4882
+ if (typeof hex === "string") {
4883
+ try {
4884
+ res = hexToBytes2(hex);
4885
+ } catch (e) {
4886
+ throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
4887
+ }
4888
+ } else if (isBytes2(hex)) {
4889
+ res = Uint8Array.from(hex);
4890
+ } else {
4891
+ throw new Error(`${title} must be hex string or Uint8Array`);
4892
+ }
4893
+ const len = res.length;
4894
+ if (typeof expectedLength === "number" && len !== expectedLength) throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
4895
+ return res;
4896
+ }
4897
+ __name(ensureBytes, "ensureBytes");
4898
+ function concatBytes(...arrays) {
4899
+ let sum = 0;
4900
+ for (let i = 0; i < arrays.length; i++) {
4901
+ const a = arrays[i];
4902
+ abytes(a);
4903
+ sum += a.length;
4904
+ }
4905
+ const res = new Uint8Array(sum);
4906
+ for (let i = 0, pad = 0; i < arrays.length; i++) {
4907
+ const a = arrays[i];
4908
+ res.set(a, pad);
4909
+ pad += a.length;
4910
+ }
4911
+ return res;
4912
+ }
4913
+ __name(concatBytes, "concatBytes");
4914
+ var isPosBig = /* @__PURE__ */ __name((n) => typeof n === "bigint" && _0n <= n, "isPosBig");
4915
+ function inRange(n, min, max) {
4916
+ return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
4917
+ }
4918
+ __name(inRange, "inRange");
4919
+ function aInRange(title, n, min, max) {
4920
+ if (!inRange(n, min, max)) throw new Error(`expected valid ${title}: ${min} <= n < ${max}, got ${typeof n} ${n}`);
4921
+ }
4922
+ __name(aInRange, "aInRange");
4923
+ var bitMask = /* @__PURE__ */ __name((n) => (_2n << BigInt(n - 1)) - _1n, "bitMask");
4924
+ var validatorFns = {
4925
+ bigint: /* @__PURE__ */ __name((val) => typeof val === "bigint", "bigint"),
4926
+ function: /* @__PURE__ */ __name((val) => typeof val === "function", "function"),
4927
+ boolean: /* @__PURE__ */ __name((val) => typeof val === "boolean", "boolean"),
4928
+ string: /* @__PURE__ */ __name((val) => typeof val === "string", "string"),
4929
+ stringOrUint8Array: /* @__PURE__ */ __name((val) => typeof val === "string" || isBytes2(val), "stringOrUint8Array"),
4930
+ isSafeInteger: /* @__PURE__ */ __name((val) => Number.isSafeInteger(val), "isSafeInteger"),
4931
+ array: /* @__PURE__ */ __name((val) => Array.isArray(val), "array"),
4932
+ field: /* @__PURE__ */ __name((val, object) => object.Fp.isValid(val), "field"),
4933
+ hash: /* @__PURE__ */ __name((val) => typeof val === "function" && Number.isSafeInteger(val.outputLen), "hash")
4934
+ };
4935
+ function validateObject(object, validators2, optValidators = {}) {
4936
+ const checkField = /* @__PURE__ */ __name((fieldName, type, isOptional) => {
4937
+ const checkVal = validatorFns[type];
4938
+ if (typeof checkVal !== "function") throw new Error(`Invalid validator "${type}", expected function`);
4939
+ const val = object[fieldName];
4940
+ if (isOptional && val === void 0) return;
4941
+ if (!checkVal(val, object)) {
4942
+ throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
4943
+ }
4944
+ }, "checkField");
4945
+ for (const [fieldName, type] of Object.entries(validators2)) checkField(fieldName, type, false);
4946
+ for (const [fieldName, type] of Object.entries(optValidators)) checkField(fieldName, type, true);
4947
+ return object;
4948
+ }
4949
+ __name(validateObject, "validateObject");
4950
+ function memoized(fn) {
4951
+ const map = /* @__PURE__ */ new WeakMap();
4952
+ return (arg, ...args) => {
4953
+ const val = map.get(arg);
4954
+ if (val !== void 0) return val;
4955
+ const computed = fn(arg, ...args);
4956
+ map.set(arg, computed);
4957
+ return computed;
4958
+ };
4959
+ }
4960
+ __name(memoized, "memoized");
4961
+
4962
+ // ../../node_modules/.pnpm/@noble+curves@1.5.0/node_modules/@noble/curves/esm/abstract/modular.js
4963
+ var _0n2 = BigInt(0);
4964
+ var _1n2 = BigInt(1);
4965
+ var _2n2 = BigInt(2);
4966
+ var _3n = BigInt(3);
4967
+ var _4n = BigInt(4);
4968
+ var _5n = BigInt(5);
4969
+ var _8n = BigInt(8);
4970
+ BigInt(9);
4971
+ BigInt(16);
4972
+ function mod(a, b) {
4973
+ const result = a % b;
4974
+ return result >= _0n2 ? result : b + result;
4975
+ }
4976
+ __name(mod, "mod");
4977
+ function pow(num, power, modulo) {
4978
+ if (modulo <= _0n2 || power < _0n2) throw new Error("Expected power/modulo > 0");
4979
+ if (modulo === _1n2) return _0n2;
4980
+ let res = _1n2;
4981
+ while (power > _0n2) {
4982
+ if (power & _1n2) res = res * num % modulo;
4983
+ num = num * num % modulo;
4984
+ power >>= _1n2;
4985
+ }
4986
+ return res;
4987
+ }
4988
+ __name(pow, "pow");
4989
+ function pow2(x, power, modulo) {
4990
+ let res = x;
4991
+ while (power-- > _0n2) {
4992
+ res *= res;
4993
+ res %= modulo;
4994
+ }
4995
+ return res;
4996
+ }
4997
+ __name(pow2, "pow2");
4998
+ function invert(number2, modulo) {
4999
+ if (number2 === _0n2 || modulo <= _0n2) {
5000
+ throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
5001
+ }
5002
+ let a = mod(number2, modulo);
5003
+ let b = modulo;
5004
+ let x = _0n2, u = _1n2;
5005
+ while (a !== _0n2) {
5006
+ const q = b / a;
5007
+ const r = b % a;
5008
+ const m = x - u * q;
5009
+ b = a, a = r, x = u, u = m;
5010
+ }
5011
+ const gcd = b;
5012
+ if (gcd !== _1n2) throw new Error("invert: does not exist");
5013
+ return mod(x, modulo);
5014
+ }
5015
+ __name(invert, "invert");
5016
+ function tonelliShanks(P) {
5017
+ const legendreC = (P - _1n2) / _2n2;
5018
+ let Q, S, Z;
5019
+ for (Q = P - _1n2, S = 0; Q % _2n2 === _0n2; Q /= _2n2, S++) ;
5020
+ for (Z = _2n2; Z < P && pow(Z, legendreC, P) !== P - _1n2; Z++) ;
5021
+ if (S === 1) {
5022
+ const p1div4 = (P + _1n2) / _4n;
5023
+ return /* @__PURE__ */ __name(function tonelliFast(Fp2, n) {
5024
+ const root = Fp2.pow(n, p1div4);
5025
+ if (!Fp2.eql(Fp2.sqr(root), n)) throw new Error("Cannot find square root");
5026
+ return root;
5027
+ }, "tonelliFast");
5028
+ }
5029
+ const Q1div2 = (Q + _1n2) / _2n2;
5030
+ return /* @__PURE__ */ __name(function tonelliSlow(Fp2, n) {
5031
+ if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE)) throw new Error("Cannot find square root");
5032
+ let r = S;
5033
+ let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
5034
+ let x = Fp2.pow(n, Q1div2);
5035
+ let b = Fp2.pow(n, Q);
5036
+ while (!Fp2.eql(b, Fp2.ONE)) {
5037
+ if (Fp2.eql(b, Fp2.ZERO)) return Fp2.ZERO;
5038
+ let m = 1;
5039
+ for (let t2 = Fp2.sqr(b); m < r; m++) {
5040
+ if (Fp2.eql(t2, Fp2.ONE)) break;
5041
+ t2 = Fp2.sqr(t2);
4137
5042
  }
4138
- WASM_VECTOR_LEN = offset;
4139
- return ptr;
4140
- }
4141
- __name(passStringToWasm0, "passStringToWasm0");
4142
- var cachedInt32Memory0 = null;
4143
- function getInt32Memory0() {
4144
- if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
4145
- cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
5043
+ const ge = Fp2.pow(g, _1n2 << BigInt(r - m - 1));
5044
+ g = Fp2.sqr(ge);
5045
+ x = Fp2.mul(x, ge);
5046
+ b = Fp2.mul(b, g);
5047
+ r = m;
5048
+ }
5049
+ return x;
5050
+ }, "tonelliSlow");
5051
+ }
5052
+ __name(tonelliShanks, "tonelliShanks");
5053
+ function FpSqrt(P) {
5054
+ if (P % _4n === _3n) {
5055
+ const p1div4 = (P + _1n2) / _4n;
5056
+ return /* @__PURE__ */ __name(function sqrt3mod4(Fp2, n) {
5057
+ const root = Fp2.pow(n, p1div4);
5058
+ if (!Fp2.eql(Fp2.sqr(root), n)) throw new Error("Cannot find square root");
5059
+ return root;
5060
+ }, "sqrt3mod4");
5061
+ }
5062
+ if (P % _8n === _5n) {
5063
+ const c1 = (P - _5n) / _8n;
5064
+ return /* @__PURE__ */ __name(function sqrt5mod8(Fp2, n) {
5065
+ const n2 = Fp2.mul(n, _2n2);
5066
+ const v = Fp2.pow(n2, c1);
5067
+ const nv = Fp2.mul(n, v);
5068
+ const i = Fp2.mul(Fp2.mul(nv, _2n2), v);
5069
+ const root = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
5070
+ if (!Fp2.eql(Fp2.sqr(root), n)) throw new Error("Cannot find square root");
5071
+ return root;
5072
+ }, "sqrt5mod8");
5073
+ }
5074
+ return tonelliShanks(P);
5075
+ }
5076
+ __name(FpSqrt, "FpSqrt");
5077
+ var isNegativeLE = /* @__PURE__ */ __name((num, modulo) => (mod(num, modulo) & _1n2) === _1n2, "isNegativeLE");
5078
+ var FIELD_FIELDS = [
5079
+ "create",
5080
+ "isValid",
5081
+ "is0",
5082
+ "neg",
5083
+ "inv",
5084
+ "sqrt",
5085
+ "sqr",
5086
+ "eql",
5087
+ "add",
5088
+ "sub",
5089
+ "mul",
5090
+ "pow",
5091
+ "div",
5092
+ "addN",
5093
+ "subN",
5094
+ "mulN",
5095
+ "sqrN"
5096
+ ];
5097
+ function validateField(field) {
5098
+ const initial = {
5099
+ ORDER: "bigint",
5100
+ MASK: "bigint",
5101
+ BYTES: "isSafeInteger",
5102
+ BITS: "isSafeInteger"
5103
+ };
5104
+ const opts = FIELD_FIELDS.reduce((map, val) => {
5105
+ map[val] = "function";
5106
+ return map;
5107
+ }, initial);
5108
+ return validateObject(field, opts);
5109
+ }
5110
+ __name(validateField, "validateField");
5111
+ function FpPow(f, num, power) {
5112
+ if (power < _0n2) throw new Error("Expected power > 0");
5113
+ if (power === _0n2) return f.ONE;
5114
+ if (power === _1n2) return num;
5115
+ let p = f.ONE;
5116
+ let d = num;
5117
+ while (power > _0n2) {
5118
+ if (power & _1n2) p = f.mul(p, d);
5119
+ d = f.sqr(d);
5120
+ power >>= _1n2;
5121
+ }
5122
+ return p;
5123
+ }
5124
+ __name(FpPow, "FpPow");
5125
+ function FpInvertBatch(f, nums) {
5126
+ const tmp = new Array(nums.length);
5127
+ const lastMultiplied = nums.reduce((acc, num, i) => {
5128
+ if (f.is0(num)) return acc;
5129
+ tmp[i] = acc;
5130
+ return f.mul(acc, num);
5131
+ }, f.ONE);
5132
+ const inverted = f.inv(lastMultiplied);
5133
+ nums.reduceRight((acc, num, i) => {
5134
+ if (f.is0(num)) return acc;
5135
+ tmp[i] = f.mul(acc, tmp[i]);
5136
+ return f.mul(acc, num);
5137
+ }, inverted);
5138
+ return tmp;
5139
+ }
5140
+ __name(FpInvertBatch, "FpInvertBatch");
5141
+ function nLength(n, nBitLength) {
5142
+ const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
5143
+ const nByteLength = Math.ceil(_nBitLength / 8);
5144
+ return {
5145
+ nBitLength: _nBitLength,
5146
+ nByteLength
5147
+ };
5148
+ }
5149
+ __name(nLength, "nLength");
5150
+ function Field(ORDER, bitLen, isLE2 = false, redef = {}) {
5151
+ if (ORDER <= _0n2) throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
5152
+ const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);
5153
+ if (BYTES > 2048) throw new Error("Field lengths over 2048 bytes are not supported");
5154
+ const sqrtP = FpSqrt(ORDER);
5155
+ const f = Object.freeze({
5156
+ ORDER,
5157
+ BITS,
5158
+ BYTES,
5159
+ MASK: bitMask(BITS),
5160
+ ZERO: _0n2,
5161
+ ONE: _1n2,
5162
+ create: /* @__PURE__ */ __name((num) => mod(num, ORDER), "create"),
5163
+ isValid: /* @__PURE__ */ __name((num) => {
5164
+ if (typeof num !== "bigint") throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);
5165
+ return _0n2 <= num && num < ORDER;
5166
+ }, "isValid"),
5167
+ is0: /* @__PURE__ */ __name((num) => num === _0n2, "is0"),
5168
+ isOdd: /* @__PURE__ */ __name((num) => (num & _1n2) === _1n2, "isOdd"),
5169
+ neg: /* @__PURE__ */ __name((num) => mod(-num, ORDER), "neg"),
5170
+ eql: /* @__PURE__ */ __name((lhs, rhs) => lhs === rhs, "eql"),
5171
+ sqr: /* @__PURE__ */ __name((num) => mod(num * num, ORDER), "sqr"),
5172
+ add: /* @__PURE__ */ __name((lhs, rhs) => mod(lhs + rhs, ORDER), "add"),
5173
+ sub: /* @__PURE__ */ __name((lhs, rhs) => mod(lhs - rhs, ORDER), "sub"),
5174
+ mul: /* @__PURE__ */ __name((lhs, rhs) => mod(lhs * rhs, ORDER), "mul"),
5175
+ pow: /* @__PURE__ */ __name((num, power) => FpPow(f, num, power), "pow"),
5176
+ div: /* @__PURE__ */ __name((lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER), "div"),
5177
+ // Same as above, but doesn't normalize
5178
+ sqrN: /* @__PURE__ */ __name((num) => num * num, "sqrN"),
5179
+ addN: /* @__PURE__ */ __name((lhs, rhs) => lhs + rhs, "addN"),
5180
+ subN: /* @__PURE__ */ __name((lhs, rhs) => lhs - rhs, "subN"),
5181
+ mulN: /* @__PURE__ */ __name((lhs, rhs) => lhs * rhs, "mulN"),
5182
+ inv: /* @__PURE__ */ __name((num) => invert(num, ORDER), "inv"),
5183
+ sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
5184
+ invertBatch: /* @__PURE__ */ __name((lst) => FpInvertBatch(f, lst), "invertBatch"),
5185
+ // TODO: do we really need constant cmov?
5186
+ // We don't have const-time bigints anyway, so probably will be not very useful
5187
+ cmov: /* @__PURE__ */ __name((a, b, c) => c ? b : a, "cmov"),
5188
+ toBytes: /* @__PURE__ */ __name((num) => isLE2 ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES), "toBytes"),
5189
+ fromBytes: /* @__PURE__ */ __name((bytes2) => {
5190
+ if (bytes2.length !== BYTES) throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
5191
+ return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
5192
+ }, "fromBytes")
5193
+ });
5194
+ return Object.freeze(f);
5195
+ }
5196
+ __name(Field, "Field");
5197
+
5198
+ // ../../node_modules/.pnpm/@noble+curves@1.5.0/node_modules/@noble/curves/esm/abstract/curve.js
5199
+ var _0n3 = BigInt(0);
5200
+ var _1n3 = BigInt(1);
5201
+ var pointPrecomputes = /* @__PURE__ */ new WeakMap();
5202
+ var pointWindowSizes = /* @__PURE__ */ new WeakMap();
5203
+ function wNAF(c, bits) {
5204
+ const constTimeNegate = /* @__PURE__ */ __name((condition, item) => {
5205
+ const neg = item.negate();
5206
+ return condition ? neg : item;
5207
+ }, "constTimeNegate");
5208
+ const validateW = /* @__PURE__ */ __name((W) => {
5209
+ if (!Number.isSafeInteger(W) || W <= 0 || W > bits) throw new Error(`Wrong window size=${W}, should be [1..${bits}]`);
5210
+ }, "validateW");
5211
+ const opts = /* @__PURE__ */ __name((W) => {
5212
+ validateW(W);
5213
+ const windows = Math.ceil(bits / W) + 1;
5214
+ const windowSize = 2 ** (W - 1);
5215
+ return {
5216
+ windows,
5217
+ windowSize
5218
+ };
5219
+ }, "opts");
5220
+ return {
5221
+ constTimeNegate,
5222
+ // non-const time multiplication ladder
5223
+ unsafeLadder(elm, n) {
5224
+ let p = c.ZERO;
5225
+ let d = elm;
5226
+ while (n > _0n3) {
5227
+ if (n & _1n3) p = p.add(d);
5228
+ d = d.double();
5229
+ n >>= _1n3;
4146
5230
  }
4147
- return cachedInt32Memory0;
4148
- }
4149
- __name(getInt32Memory0, "getInt32Memory0");
4150
- module.exports.decode = function(address, encoding, network) {
4151
- let deferred3_0;
4152
- let deferred3_1;
4153
- try {
4154
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
4155
- const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4156
- const len0 = WASM_VECTOR_LEN;
4157
- wasm.decode(retptr, ptr0, len0, encoding, network);
4158
- var r0 = getInt32Memory0()[retptr / 4 + 0];
4159
- var r1 = getInt32Memory0()[retptr / 4 + 1];
4160
- var r2 = getInt32Memory0()[retptr / 4 + 2];
4161
- var r3 = getInt32Memory0()[retptr / 4 + 3];
4162
- var ptr2 = r0;
4163
- var len2 = r1;
4164
- if (r3) {
4165
- ptr2 = 0;
4166
- len2 = 0;
4167
- throw takeObject(r2);
5231
+ return p;
5232
+ },
5233
+ /**
5234
+ * Creates a wNAF precomputation window. Used for caching.
5235
+ * Default window size is set by `utils.precompute()` and is equal to 8.
5236
+ * Number of precomputed points depends on the curve size:
5237
+ * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
5238
+ * - 𝑊 is the window size
5239
+ * - 𝑛 is the bitlength of the curve order.
5240
+ * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
5241
+ * @returns precomputed point tables flattened to a single array
5242
+ */
5243
+ precomputeWindow(elm, W) {
5244
+ const { windows, windowSize } = opts(W);
5245
+ const points = [];
5246
+ let p = elm;
5247
+ let base = p;
5248
+ for (let window = 0; window < windows; window++) {
5249
+ base = p;
5250
+ points.push(base);
5251
+ for (let i = 1; i < windowSize; i++) {
5252
+ base = base.add(p);
5253
+ points.push(base);
4168
5254
  }
4169
- deferred3_0 = ptr2;
4170
- deferred3_1 = len2;
4171
- return getStringFromWasm0(ptr2, len2);
4172
- } finally {
4173
- wasm.__wbindgen_add_to_stack_pointer(16);
4174
- wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
5255
+ p = base.double();
4175
5256
  }
5257
+ return points;
5258
+ },
5259
+ /**
5260
+ * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
5261
+ * @param W window size
5262
+ * @param precomputes precomputed tables
5263
+ * @param n scalar (we don't check here, but should be less than curve order)
5264
+ * @returns real and fake (for const-time) points
5265
+ */
5266
+ wNAF(W, precomputes, n) {
5267
+ const { windows, windowSize } = opts(W);
5268
+ let p = c.ZERO;
5269
+ let f = c.BASE;
5270
+ const mask = BigInt(2 ** W - 1);
5271
+ const maxNumber = 2 ** W;
5272
+ const shiftBy = BigInt(W);
5273
+ for (let window = 0; window < windows; window++) {
5274
+ const offset = window * windowSize;
5275
+ let wbits = Number(n & mask);
5276
+ n >>= shiftBy;
5277
+ if (wbits > windowSize) {
5278
+ wbits -= maxNumber;
5279
+ n += _1n3;
5280
+ }
5281
+ const offset1 = offset;
5282
+ const offset2 = offset + Math.abs(wbits) - 1;
5283
+ const cond1 = window % 2 !== 0;
5284
+ const cond2 = wbits < 0;
5285
+ if (wbits === 0) {
5286
+ f = f.add(constTimeNegate(cond1, precomputes[offset1]));
5287
+ } else {
5288
+ p = p.add(constTimeNegate(cond2, precomputes[offset2]));
5289
+ }
5290
+ }
5291
+ return {
5292
+ p,
5293
+ f
5294
+ };
5295
+ },
5296
+ wNAFCached(P, n, transform) {
5297
+ const W = pointWindowSizes.get(P) || 1;
5298
+ let comp = pointPrecomputes.get(P);
5299
+ if (!comp) {
5300
+ comp = this.precomputeWindow(P, W);
5301
+ if (W !== 1) pointPrecomputes.set(P, transform(comp));
5302
+ }
5303
+ return this.wNAF(W, comp, n);
5304
+ },
5305
+ // We calculate precomputes for elliptic curve point multiplication
5306
+ // using windowed method. This specifies window size and
5307
+ // stores precomputed values. Usually only base point would be precomputed.
5308
+ setWindowSize(P, W) {
5309
+ validateW(W);
5310
+ pointWindowSizes.set(P, W);
5311
+ pointPrecomputes.delete(P);
5312
+ }
5313
+ };
5314
+ }
5315
+ __name(wNAF, "wNAF");
5316
+ function validateBasic(curve) {
5317
+ validateField(curve.Fp);
5318
+ validateObject(curve, {
5319
+ n: "bigint",
5320
+ h: "bigint",
5321
+ Gx: "field",
5322
+ Gy: "field"
5323
+ }, {
5324
+ nBitLength: "isSafeInteger",
5325
+ nByteLength: "isSafeInteger"
5326
+ });
5327
+ return Object.freeze({
5328
+ ...nLength(curve.n, curve.nBitLength),
5329
+ ...curve,
5330
+ ...{
5331
+ p: curve.Fp.ORDER
5332
+ }
5333
+ });
5334
+ }
5335
+ __name(validateBasic, "validateBasic");
5336
+
5337
+ // ../../node_modules/.pnpm/@noble+curves@1.5.0/node_modules/@noble/curves/esm/abstract/edwards.js
5338
+ var _0n4 = BigInt(0);
5339
+ var _1n4 = BigInt(1);
5340
+ var _2n3 = BigInt(2);
5341
+ var _8n2 = BigInt(8);
5342
+ var VERIFY_DEFAULT = {
5343
+ zip215: true
5344
+ };
5345
+ function validateOpts(curve) {
5346
+ const opts = validateBasic(curve);
5347
+ validateObject(curve, {
5348
+ hash: "function",
5349
+ a: "bigint",
5350
+ d: "bigint",
5351
+ randomBytes: "function"
5352
+ }, {
5353
+ adjustScalarBytes: "function",
5354
+ domain: "function",
5355
+ uvRatio: "function",
5356
+ mapToCurve: "function"
5357
+ });
5358
+ return Object.freeze({
5359
+ ...opts
5360
+ });
5361
+ }
5362
+ __name(validateOpts, "validateOpts");
5363
+ function twistedEdwards(curveDef) {
5364
+ var _a2;
5365
+ const CURVE = validateOpts(curveDef);
5366
+ const { Fp: Fp2, n: CURVE_ORDER, prehash, hash: cHash, randomBytes: randomBytes2, nByteLength, h: cofactor } = CURVE;
5367
+ const MASK = _2n3 << BigInt(nByteLength * 8) - _1n4;
5368
+ const modP = Fp2.create;
5369
+ const uvRatio2 = CURVE.uvRatio || ((u, v) => {
5370
+ try {
5371
+ return {
5372
+ isValid: true,
5373
+ value: Fp2.sqrt(u * Fp2.inv(v))
5374
+ };
5375
+ } catch (e) {
5376
+ return {
5377
+ isValid: false,
5378
+ value: _0n4
5379
+ };
5380
+ }
5381
+ });
5382
+ const adjustScalarBytes2 = CURVE.adjustScalarBytes || ((bytes2) => bytes2);
5383
+ const domain = CURVE.domain || ((data, ctx, phflag) => {
5384
+ abool("phflag", phflag);
5385
+ if (ctx.length || phflag) throw new Error("Contexts/pre-hash are not supported");
5386
+ return data;
5387
+ });
5388
+ function aCoordinate(title, n) {
5389
+ aInRange("coordinate " + title, n, _0n4, MASK);
5390
+ }
5391
+ __name(aCoordinate, "aCoordinate");
5392
+ function assertPoint(other) {
5393
+ if (!(other instanceof Point)) throw new Error("ExtendedPoint expected");
5394
+ }
5395
+ __name(assertPoint, "assertPoint");
5396
+ const toAffineMemo = memoized((p, iz) => {
5397
+ const { ex: x, ey: y, ez: z2 } = p;
5398
+ const is0 = p.is0();
5399
+ if (iz == null) iz = is0 ? _8n2 : Fp2.inv(z2);
5400
+ const ax = modP(x * iz);
5401
+ const ay = modP(y * iz);
5402
+ const zz = modP(z2 * iz);
5403
+ if (is0) return {
5404
+ x: _0n4,
5405
+ y: _1n4
4176
5406
  };
4177
- module.exports.isValidAddressForNetwork = function(address, network) {
4178
- const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4179
- const len0 = WASM_VECTOR_LEN;
4180
- const ret = wasm.isValidAddressForNetwork(ptr0, len0, network);
4181
- return ret !== 0;
4182
- };
4183
- module.exports.BitcoinNetwork = Object.freeze({ Mainnet: 0, "0": "Mainnet", Testnet: 1, "1": "Testnet", Regtest: 2, "2": "Regtest" });
4184
- module.exports.AddressEncoding = Object.freeze({ P2WPKH: 0, "0": "P2WPKH", P2SH: 1, "1": "P2SH", P2PKH: 2, "2": "P2PKH", P2WSH: 3, "3": "P2WSH", Taproot: 4, "4": "Taproot" });
4185
- module.exports.__wbindgen_error_new = function(arg0, arg1) {
4186
- const ret = new Error(getStringFromWasm0(arg0, arg1));
4187
- return addHeapObject(ret);
4188
- };
4189
- module.exports.__wbindgen_object_drop_ref = function(arg0) {
4190
- takeObject(arg0);
4191
- };
4192
- module.exports.__wbindgen_throw = function(arg0, arg1) {
4193
- throw new Error(getStringFromWasm0(arg0, arg1));
5407
+ if (zz !== _1n4) throw new Error("invZ was invalid");
5408
+ return {
5409
+ x: ax,
5410
+ y: ay
4194
5411
  };
4195
- var bytes = (() => {
4196
- const base64 = "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";
4197
- const binary = atob(base64);
4198
- const array = new Uint8Array(binary.length);
4199
- for (let i = 0; i < binary.length; i++) {
4200
- array[i] = binary.charCodeAt(i);
5412
+ });
5413
+ const assertValidMemo = memoized((p) => {
5414
+ const { a, d } = CURVE;
5415
+ if (p.is0()) throw new Error("bad point: ZERO");
5416
+ const { ex: X, ey: Y, ez: Z, et: T } = p;
5417
+ const X2 = modP(X * X);
5418
+ const Y2 = modP(Y * Y);
5419
+ const Z2 = modP(Z * Z);
5420
+ const Z4 = modP(Z2 * Z2);
5421
+ const aX2 = modP(X2 * a);
5422
+ const left = modP(Z2 * modP(aX2 + Y2));
5423
+ const right = modP(Z4 + modP(d * modP(X2 * Y2)));
5424
+ if (left !== right) throw new Error("bad point: equation left != right (1)");
5425
+ const XY = modP(X * Y);
5426
+ const ZT = modP(Z * T);
5427
+ if (XY !== ZT) throw new Error("bad point: equation left != right (2)");
5428
+ return true;
5429
+ });
5430
+ let Point = (_a2 = class {
5431
+ constructor(ex, ey, ez, et) {
5432
+ this.ex = ex;
5433
+ this.ey = ey;
5434
+ this.ez = ez;
5435
+ this.et = et;
5436
+ aCoordinate("x", ex);
5437
+ aCoordinate("y", ey);
5438
+ aCoordinate("z", ez);
5439
+ aCoordinate("t", et);
5440
+ Object.freeze(this);
5441
+ }
5442
+ get x() {
5443
+ return this.toAffine().x;
5444
+ }
5445
+ get y() {
5446
+ return this.toAffine().y;
5447
+ }
5448
+ static fromAffine(p) {
5449
+ if (p instanceof _a2) throw new Error("extended point not allowed");
5450
+ const { x, y } = p || {};
5451
+ aCoordinate("x", x);
5452
+ aCoordinate("y", y);
5453
+ return new _a2(x, y, _1n4, modP(x * y));
5454
+ }
5455
+ static normalizeZ(points) {
5456
+ const toInv = Fp2.invertBatch(points.map((p) => p.ez));
5457
+ return points.map((p, i) => p.toAffine(toInv[i])).map(_a2.fromAffine);
5458
+ }
5459
+ // "Private method", don't use it directly
5460
+ _setWindowSize(windowSize) {
5461
+ wnaf.setWindowSize(this, windowSize);
5462
+ }
5463
+ // Not required for fromHex(), which always creates valid points.
5464
+ // Could be useful for fromAffine().
5465
+ assertValidity() {
5466
+ assertValidMemo(this);
5467
+ }
5468
+ // Compare one point to another.
5469
+ equals(other) {
5470
+ assertPoint(other);
5471
+ const { ex: X1, ey: Y1, ez: Z1 } = this;
5472
+ const { ex: X2, ey: Y2, ez: Z2 } = other;
5473
+ const X1Z2 = modP(X1 * Z2);
5474
+ const X2Z1 = modP(X2 * Z1);
5475
+ const Y1Z2 = modP(Y1 * Z2);
5476
+ const Y2Z1 = modP(Y2 * Z1);
5477
+ return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
5478
+ }
5479
+ is0() {
5480
+ return this.equals(_a2.ZERO);
5481
+ }
5482
+ negate() {
5483
+ return new _a2(modP(-this.ex), this.ey, this.ez, modP(-this.et));
5484
+ }
5485
+ // Fast algo for doubling Extended Point.
5486
+ // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#doubling-dbl-2008-hwcd
5487
+ // Cost: 4M + 4S + 1*a + 6add + 1*2.
5488
+ double() {
5489
+ const { a } = CURVE;
5490
+ const { ex: X1, ey: Y1, ez: Z1 } = this;
5491
+ const A = modP(X1 * X1);
5492
+ const B = modP(Y1 * Y1);
5493
+ const C = modP(_2n3 * modP(Z1 * Z1));
5494
+ const D = modP(a * A);
5495
+ const x1y1 = X1 + Y1;
5496
+ const E = modP(modP(x1y1 * x1y1) - A - B);
5497
+ const G2 = D + B;
5498
+ const F = G2 - C;
5499
+ const H = D - B;
5500
+ const X3 = modP(E * F);
5501
+ const Y3 = modP(G2 * H);
5502
+ const T3 = modP(E * H);
5503
+ const Z3 = modP(F * G2);
5504
+ return new _a2(X3, Y3, Z3, T3);
5505
+ }
5506
+ // Fast algo for adding 2 Extended Points.
5507
+ // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#addition-add-2008-hwcd
5508
+ // Cost: 9M + 1*a + 1*d + 7add.
5509
+ add(other) {
5510
+ assertPoint(other);
5511
+ const { a, d } = CURVE;
5512
+ const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
5513
+ const { ex: X2, ey: Y2, ez: Z2, et: T2 } = other;
5514
+ if (a === BigInt(-1)) {
5515
+ const A2 = modP((Y1 - X1) * (Y2 + X2));
5516
+ const B2 = modP((Y1 + X1) * (Y2 - X2));
5517
+ const F2 = modP(B2 - A2);
5518
+ if (F2 === _0n4) return this.double();
5519
+ const C2 = modP(Z1 * _2n3 * T2);
5520
+ const D2 = modP(T1 * _2n3 * Z2);
5521
+ const E2 = D2 + C2;
5522
+ const G3 = B2 + A2;
5523
+ const H2 = D2 - C2;
5524
+ const X32 = modP(E2 * F2);
5525
+ const Y32 = modP(G3 * H2);
5526
+ const T32 = modP(E2 * H2);
5527
+ const Z32 = modP(F2 * G3);
5528
+ return new _a2(X32, Y32, Z32, T32);
4201
5529
  }
4202
- return array.buffer;
4203
- })();
4204
- var wasmModule = new WebAssembly.Module(bytes);
4205
- var wasmInstance = new WebAssembly.Instance(wasmModule, imports);
4206
- wasm = wasmInstance.exports;
4207
- module.exports.__wasm = wasm;
5530
+ const A = modP(X1 * X2);
5531
+ const B = modP(Y1 * Y2);
5532
+ const C = modP(T1 * d * T2);
5533
+ const D = modP(Z1 * Z2);
5534
+ const E = modP((X1 + Y1) * (X2 + Y2) - A - B);
5535
+ const F = D - C;
5536
+ const G2 = D + C;
5537
+ const H = modP(B - a * A);
5538
+ const X3 = modP(E * F);
5539
+ const Y3 = modP(G2 * H);
5540
+ const T3 = modP(E * H);
5541
+ const Z3 = modP(F * G2);
5542
+ return new _a2(X3, Y3, Z3, T3);
5543
+ }
5544
+ subtract(other) {
5545
+ return this.add(other.negate());
5546
+ }
5547
+ wNAF(n) {
5548
+ return wnaf.wNAFCached(this, n, _a2.normalizeZ);
5549
+ }
5550
+ // Constant-time multiplication.
5551
+ multiply(scalar) {
5552
+ const n = scalar;
5553
+ aInRange("scalar", n, _1n4, CURVE_ORDER);
5554
+ const { p, f } = this.wNAF(n);
5555
+ return _a2.normalizeZ([
5556
+ p,
5557
+ f
5558
+ ])[0];
5559
+ }
5560
+ // Non-constant-time multiplication. Uses double-and-add algorithm.
5561
+ // It's faster, but should only be used when you don't care about
5562
+ // an exposed private key e.g. sig verification.
5563
+ // Does NOT allow scalars higher than CURVE.n.
5564
+ multiplyUnsafe(scalar) {
5565
+ const n = scalar;
5566
+ aInRange("scalar", n, _0n4, CURVE_ORDER);
5567
+ if (n === _0n4) return I;
5568
+ if (this.equals(I) || n === _1n4) return this;
5569
+ if (this.equals(G)) return this.wNAF(n).p;
5570
+ return wnaf.unsafeLadder(this, n);
5571
+ }
5572
+ // Checks if point is of small order.
5573
+ // If you add something to small order point, you will have "dirty"
5574
+ // point with torsion component.
5575
+ // Multiplies point by cofactor and checks if the result is 0.
5576
+ isSmallOrder() {
5577
+ return this.multiplyUnsafe(cofactor).is0();
5578
+ }
5579
+ // Multiplies point by curve order and checks if the result is 0.
5580
+ // Returns `false` is the point is dirty.
5581
+ isTorsionFree() {
5582
+ return wnaf.unsafeLadder(this, CURVE_ORDER).is0();
5583
+ }
5584
+ // Converts Extended point to default (x, y) coordinates.
5585
+ // Can accept precomputed Z^-1 - for example, from invertBatch.
5586
+ toAffine(iz) {
5587
+ return toAffineMemo(this, iz);
5588
+ }
5589
+ clearCofactor() {
5590
+ const { h: cofactor2 } = CURVE;
5591
+ if (cofactor2 === _1n4) return this;
5592
+ return this.multiplyUnsafe(cofactor2);
5593
+ }
5594
+ // Converts hash string or Uint8Array to Point.
5595
+ // Uses algo from RFC8032 5.1.3.
5596
+ static fromHex(hex, zip215 = false) {
5597
+ const { d, a } = CURVE;
5598
+ const len = Fp2.BYTES;
5599
+ hex = ensureBytes("pointHex", hex, len);
5600
+ abool("zip215", zip215);
5601
+ const normed = hex.slice();
5602
+ const lastByte = hex[len - 1];
5603
+ normed[len - 1] = lastByte & ~128;
5604
+ const y = bytesToNumberLE(normed);
5605
+ const max = zip215 ? MASK : Fp2.ORDER;
5606
+ aInRange("pointHex.y", y, _0n4, max);
5607
+ const y2 = modP(y * y);
5608
+ const u = modP(y2 - _1n4);
5609
+ const v = modP(d * y2 - a);
5610
+ let { isValid: isValid2, value: x } = uvRatio2(u, v);
5611
+ if (!isValid2) throw new Error("Point.fromHex: invalid y coordinate");
5612
+ const isXOdd = (x & _1n4) === _1n4;
5613
+ const isLastByteOdd = (lastByte & 128) !== 0;
5614
+ if (!zip215 && x === _0n4 && isLastByteOdd)
5615
+ throw new Error("Point.fromHex: x=0 and x_0=1");
5616
+ if (isLastByteOdd !== isXOdd) x = modP(-x);
5617
+ return _a2.fromAffine({
5618
+ x,
5619
+ y
5620
+ });
5621
+ }
5622
+ static fromPrivateKey(privKey) {
5623
+ return getExtendedPublicKey(privKey).point;
5624
+ }
5625
+ toRawBytes() {
5626
+ const { x, y } = this.toAffine();
5627
+ const bytes2 = numberToBytesLE(y, Fp2.BYTES);
5628
+ bytes2[bytes2.length - 1] |= x & _1n4 ? 128 : 0;
5629
+ return bytes2;
5630
+ }
5631
+ toHex() {
5632
+ return bytesToHex(this.toRawBytes());
5633
+ }
5634
+ }, __name(_a2, "Point"), _a2);
5635
+ Point.BASE = new Point(CURVE.Gx, CURVE.Gy, _1n4, modP(CURVE.Gx * CURVE.Gy));
5636
+ Point.ZERO = new Point(_0n4, _1n4, _1n4, _0n4);
5637
+ const { BASE: G, ZERO: I } = Point;
5638
+ const wnaf = wNAF(Point, nByteLength * 8);
5639
+ function modN(a) {
5640
+ return mod(a, CURVE_ORDER);
5641
+ }
5642
+ __name(modN, "modN");
5643
+ function modN_LE(hash) {
5644
+ return modN(bytesToNumberLE(hash));
5645
+ }
5646
+ __name(modN_LE, "modN_LE");
5647
+ function getExtendedPublicKey(key) {
5648
+ const len = nByteLength;
5649
+ key = ensureBytes("private key", key, len);
5650
+ const hashed = ensureBytes("hashed private key", cHash(key), 2 * len);
5651
+ const head = adjustScalarBytes2(hashed.slice(0, len));
5652
+ const prefix = hashed.slice(len, 2 * len);
5653
+ const scalar = modN_LE(head);
5654
+ const point = G.multiply(scalar);
5655
+ const pointBytes = point.toRawBytes();
5656
+ return {
5657
+ head,
5658
+ prefix,
5659
+ scalar,
5660
+ point,
5661
+ pointBytes
5662
+ };
4208
5663
  }
4209
- });
4210
- var Bitcoin = __toESM(require_bitcoin(), 1);
4211
- var networkToBitcoinNetwork = /* @__PURE__ */ __name((network) => {
4212
- switch (network) {
4213
- case "mainnet":
4214
- return Bitcoin.BitcoinNetwork.Mainnet;
4215
- case "perseverance":
4216
- case "sisyphos":
4217
- case "testnet":
4218
- return Bitcoin.BitcoinNetwork.Testnet;
4219
- case "backspin":
4220
- case "regtest":
4221
- return Bitcoin.BitcoinNetwork.Regtest;
4222
- default:
4223
- throw new Error(`Invalid network: ${network}`);
4224
- }
4225
- }, "networkToBitcoinNetwork");
4226
- var isValidAddressForNetwork2 = /* @__PURE__ */ __name((address, network) => Bitcoin.isValidAddressForNetwork(address, networkToBitcoinNetwork(network)), "isValidAddressForNetwork2");
4227
- var bitcoinNetworkHrp = {
4228
- mainnet: "bc",
4229
- testnet: "tb",
4230
- regtest: "bcrt"
4231
- };
4232
- var isValidSegwitAddressForNetwork = /* @__PURE__ */ __name((address, bitcoinNetwork) => {
4233
- if (!/^(bc|tb|bcrt)1/.test(address)) return false;
4234
- return BitcoinAddress.decode(address).prefix === bitcoinNetworkHrp[bitcoinNetwork];
4235
- }, "isValidSegwitAddressForNetwork");
5664
+ __name(getExtendedPublicKey, "getExtendedPublicKey");
5665
+ function getPublicKey(privKey) {
5666
+ return getExtendedPublicKey(privKey).pointBytes;
5667
+ }
5668
+ __name(getPublicKey, "getPublicKey");
5669
+ function hashDomainToScalar(context = new Uint8Array(), ...msgs) {
5670
+ const msg = concatBytes(...msgs);
5671
+ return modN_LE(cHash(domain(msg, ensureBytes("context", context), !!prehash)));
5672
+ }
5673
+ __name(hashDomainToScalar, "hashDomainToScalar");
5674
+ function sign(msg, privKey, options = {}) {
5675
+ msg = ensureBytes("message", msg);
5676
+ if (prehash) msg = prehash(msg);
5677
+ const { prefix, scalar, pointBytes } = getExtendedPublicKey(privKey);
5678
+ const r = hashDomainToScalar(options.context, prefix, msg);
5679
+ const R = G.multiply(r).toRawBytes();
5680
+ const k = hashDomainToScalar(options.context, R, pointBytes, msg);
5681
+ const s = modN(r + k * scalar);
5682
+ aInRange("signature.s", s, _0n4, CURVE_ORDER);
5683
+ const res = concatBytes(R, numberToBytesLE(s, Fp2.BYTES));
5684
+ return ensureBytes("result", res, nByteLength * 2);
5685
+ }
5686
+ __name(sign, "sign");
5687
+ const verifyOpts = VERIFY_DEFAULT;
5688
+ function verify(sig, msg, publicKey, options = verifyOpts) {
5689
+ const { context, zip215 } = options;
5690
+ const len = Fp2.BYTES;
5691
+ sig = ensureBytes("signature", sig, 2 * len);
5692
+ msg = ensureBytes("message", msg);
5693
+ if (zip215 !== void 0) abool("zip215", zip215);
5694
+ if (prehash) msg = prehash(msg);
5695
+ const s = bytesToNumberLE(sig.slice(len, 2 * len));
5696
+ let A, R, SB;
5697
+ try {
5698
+ A = Point.fromHex(publicKey, zip215);
5699
+ R = Point.fromHex(sig.slice(0, len), zip215);
5700
+ SB = G.multiplyUnsafe(s);
5701
+ } catch (error) {
5702
+ return false;
5703
+ }
5704
+ if (!zip215 && A.isSmallOrder()) return false;
5705
+ const k = hashDomainToScalar(context, R.toRawBytes(), A.toRawBytes(), msg);
5706
+ const RkA = R.add(A.multiplyUnsafe(k));
5707
+ return RkA.subtract(SB).clearCofactor().equals(Point.ZERO);
5708
+ }
5709
+ __name(verify, "verify");
5710
+ G._setWindowSize(8);
5711
+ const utils = {
5712
+ getExtendedPublicKey,
5713
+ // ed25519 private keys are uniform 32b. No need to check for modulo bias, like in secp256k1.
5714
+ randomPrivateKey: /* @__PURE__ */ __name(() => randomBytes2(Fp2.BYTES), "randomPrivateKey"),
5715
+ /**
5716
+ * We're doing scalar multiplication (used in getPublicKey etc) with precomputed BASE_POINT
5717
+ * values. This slows down first getPublicKey() by milliseconds (see Speed section),
5718
+ * but allows to speed-up subsequent getPublicKey() calls up to 20x.
5719
+ * @param windowSize 2, 4, 8, 16
5720
+ */
5721
+ precompute(windowSize = 8, point = Point.BASE) {
5722
+ point._setWindowSize(windowSize);
5723
+ point.multiply(BigInt(3));
5724
+ return point;
5725
+ }
5726
+ };
5727
+ return {
5728
+ CURVE,
5729
+ getPublicKey,
5730
+ sign,
5731
+ verify,
5732
+ ExtendedPoint: Point,
5733
+ utils
5734
+ };
5735
+ }
5736
+ __name(twistedEdwards, "twistedEdwards");
5737
+
5738
+ // ../../node_modules/.pnpm/@noble+curves@1.5.0/node_modules/@noble/curves/esm/ed25519.js
5739
+ var ED25519_P = BigInt("57896044618658097711785492504343953926634992332820282019728792003956564819949");
5740
+ var ED25519_SQRT_M1 = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
5741
+ BigInt(0);
5742
+ var _1n5 = BigInt(1);
5743
+ var _2n4 = BigInt(2);
5744
+ BigInt(3);
5745
+ var _5n2 = BigInt(5);
5746
+ var _8n3 = BigInt(8);
5747
+ function ed25519_pow_2_252_3(x) {
5748
+ const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
5749
+ const P = ED25519_P;
5750
+ const x2 = x * x % P;
5751
+ const b2 = x2 * x % P;
5752
+ const b4 = pow2(b2, _2n4, P) * b2 % P;
5753
+ const b5 = pow2(b4, _1n5, P) * x % P;
5754
+ const b10 = pow2(b5, _5n2, P) * b5 % P;
5755
+ const b20 = pow2(b10, _10n, P) * b10 % P;
5756
+ const b40 = pow2(b20, _20n, P) * b20 % P;
5757
+ const b80 = pow2(b40, _40n, P) * b40 % P;
5758
+ const b160 = pow2(b80, _80n, P) * b80 % P;
5759
+ const b240 = pow2(b160, _80n, P) * b80 % P;
5760
+ const b250 = pow2(b240, _10n, P) * b10 % P;
5761
+ const pow_p_5_8 = pow2(b250, _2n4, P) * x % P;
5762
+ return {
5763
+ pow_p_5_8,
5764
+ b2
5765
+ };
5766
+ }
5767
+ __name(ed25519_pow_2_252_3, "ed25519_pow_2_252_3");
5768
+ function adjustScalarBytes(bytes2) {
5769
+ bytes2[0] &= 248;
5770
+ bytes2[31] &= 127;
5771
+ bytes2[31] |= 64;
5772
+ return bytes2;
5773
+ }
5774
+ __name(adjustScalarBytes, "adjustScalarBytes");
5775
+ function uvRatio(u, v) {
5776
+ const P = ED25519_P;
5777
+ const v3 = mod(v * v * v, P);
5778
+ const v7 = mod(v3 * v3 * v, P);
5779
+ const pow3 = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
5780
+ let x = mod(u * v3 * pow3, P);
5781
+ const vx2 = mod(v * x * x, P);
5782
+ const root1 = x;
5783
+ const root2 = mod(x * ED25519_SQRT_M1, P);
5784
+ const useRoot1 = vx2 === u;
5785
+ const useRoot2 = vx2 === mod(-u, P);
5786
+ const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P);
5787
+ if (useRoot1) x = root1;
5788
+ if (useRoot2 || noRoot) x = root2;
5789
+ if (isNegativeLE(x, P)) x = mod(-x, P);
5790
+ return {
5791
+ isValid: useRoot1 || useRoot2,
5792
+ value: x
5793
+ };
5794
+ }
5795
+ __name(uvRatio, "uvRatio");
5796
+ var Fp = /* @__PURE__ */ (() => Field(ED25519_P, void 0, true))();
5797
+ var ed25519Defaults = /* @__PURE__ */ (() => ({
5798
+ // Param: a
5799
+ a: BigInt(-1),
5800
+ // d is equal to -121665/121666 over finite field.
5801
+ // Negative number is P - number, and division is invert(number, P)
5802
+ d: BigInt("37095705934669439343138083508754565189542113879843219016388785533085940283555"),
5803
+ // Finite field 𝔽p over which we'll do calculations; 2n**255n - 19n
5804
+ Fp,
5805
+ // Subgroup order: how many points curve has
5806
+ // 2n**252n + 27742317777372353535851937790883648493n;
5807
+ n: BigInt("7237005577332262213973186563042994240857116359379907606001950938285454250989"),
5808
+ // Cofactor
5809
+ h: _8n3,
5810
+ // Base point (x, y) aka generator point
5811
+ Gx: BigInt("15112221349535400772501151409588531511454012693041857206046113283949847762202"),
5812
+ Gy: BigInt("46316835694926478169428394003475163141307993866256225615783033603165251855960"),
5813
+ hash: sha512,
5814
+ randomBytes,
5815
+ adjustScalarBytes,
5816
+ // dom2
5817
+ // Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.
5818
+ // Constant-time, u/√v
5819
+ uvRatio
5820
+ }))();
5821
+ var ed25519 = /* @__PURE__ */ (() => twistedEdwards(ed25519Defaults))();
5822
+ var isValidSolanaAddress = /* @__PURE__ */ __name((address) => {
5823
+ try {
5824
+ const rawBytes = base58.decode(address);
5825
+ ed25519.ExtendedPoint.fromHex(rawBytes);
5826
+ return true;
5827
+ } catch (e) {
5828
+ return false;
5829
+ }
5830
+ }, "isValidSolanaAddress");
4236
5831
  var validatePolkadotAddress = /* @__PURE__ */ __name((address) => {
4237
5832
  try {
4238
5833
  ss582.decode(address);
@@ -4242,49 +5837,48 @@ var validatePolkadotAddress = /* @__PURE__ */ __name((address) => {
4242
5837
  }
4243
5838
  }, "validatePolkadotAddress");
4244
5839
  var validateEvmAddress = /* @__PURE__ */ __name((address) => ethers.isAddress(address), "validateEvmAddress");
4245
- var validateBitcoinAddressForNetwork = /* @__PURE__ */ __name((network) => (address) => {
4246
- try {
4247
- return isValidAddressForNetwork2(address, network);
4248
- } catch {
4249
- return isValidSegwitAddressForNetwork(address, network);
4250
- }
4251
- }, "validateBitcoinAddressForNetwork");
4252
- var validateBitcoinMainnetAddress = validateBitcoinAddressForNetwork("mainnet");
4253
- var validateBitcoinTestnetAddress = validateBitcoinAddressForNetwork("testnet");
4254
- var validateBitcoinRegtestAddress = validateBitcoinAddressForNetwork("regtest");
5840
+ var validateBitcoinMainnetAddress = /* @__PURE__ */ __name((address) => isValidAddressForNetwork(address, "mainnet"), "validateBitcoinMainnetAddress");
5841
+ var validateBitcoinTestnetAddress = /* @__PURE__ */ __name((address) => isValidAddressForNetwork(address, "testnet"), "validateBitcoinTestnetAddress");
5842
+ var validateBitcoinRegtestAddress = /* @__PURE__ */ __name((address) => isValidAddressForNetwork(address, "regtest"), "validateBitcoinRegtestAddress");
5843
+ var validateSolanaAddress = isValidSolanaAddress;
4255
5844
  var validators = {
4256
5845
  mainnet: {
4257
5846
  Bitcoin: validateBitcoinMainnetAddress,
4258
5847
  Ethereum: validateEvmAddress,
4259
5848
  Polkadot: validatePolkadotAddress,
4260
- Arbitrum: validateEvmAddress
5849
+ Arbitrum: validateEvmAddress,
5850
+ Solana: validateSolanaAddress
4261
5851
  },
4262
5852
  perseverance: {
4263
5853
  Bitcoin: validateBitcoinTestnetAddress,
4264
5854
  Ethereum: validateEvmAddress,
4265
5855
  Polkadot: validatePolkadotAddress,
4266
- Arbitrum: validateEvmAddress
5856
+ Arbitrum: validateEvmAddress,
5857
+ Solana: validateSolanaAddress
4267
5858
  },
4268
5859
  sisyphos: {
4269
5860
  Bitcoin: validateBitcoinTestnetAddress,
4270
5861
  Ethereum: validateEvmAddress,
4271
5862
  Polkadot: validatePolkadotAddress,
4272
- Arbitrum: validateEvmAddress
5863
+ Arbitrum: validateEvmAddress,
5864
+ Solana: validateSolanaAddress
4273
5865
  },
4274
5866
  backspin: {
4275
5867
  Bitcoin: validateBitcoinRegtestAddress,
4276
5868
  Ethereum: validateEvmAddress,
4277
5869
  Polkadot: validatePolkadotAddress,
4278
- Arbitrum: validateEvmAddress
5870
+ Arbitrum: validateEvmAddress,
5871
+ Solana: validateSolanaAddress
4279
5872
  },
4280
5873
  localnet: {
4281
5874
  Bitcoin: validateBitcoinRegtestAddress,
4282
5875
  Ethereum: validateEvmAddress,
4283
5876
  Polkadot: validatePolkadotAddress,
4284
- Arbitrum: validateEvmAddress
5877
+ Arbitrum: validateEvmAddress,
5878
+ Solana: validateSolanaAddress
4285
5879
  }
4286
5880
  };
4287
- var assertValidAddress = /* @__PURE__ */ __name((chain2, address, network) => assert(validators[network][chain2](address), `Address "${address}" is not a valid "${chain2}" address for "${network}"`), "assertValidAddress");
5881
+ var assertValidAddress = /* @__PURE__ */ __name((chain2, address, network) => assert$1(validators[network][chain2](address), `Address "${address}" is not a valid "${chain2}" address for "${network}"`), "assertValidAddress");
4288
5882
 
4289
5883
  // ../shared/src/parsers.ts
4290
5884
  var enumValues = Object.values;
@@ -4342,10 +5936,13 @@ var dotAddress = z.union([
4342
5936
  message: `address is not a valid polkadot address`
4343
5937
  });
4344
5938
  var ethereumAddress = hexString.refine((address) => ethers.isAddress(address), (address) => ({
4345
- message: `${address} is not a valid ethereum address`
5939
+ message: `${address} is not a valid Ethereum address`
4346
5940
  }));
4347
5941
  var chainflipAddress = string.refine((address) => address.startsWith("cF") && ss582.decode(address), (address) => ({
4348
- message: `${address} is not a valid chainflip address`
5942
+ message: `${address} is not a valid Chainflip address`
5943
+ }));
5944
+ var solanaAddress = string.refine(isValidSolanaAddress, (address) => ({
5945
+ message: `${address} is not a valid Solana address`
4349
5946
  }));
4350
5947
  numericString.transform((arg) => BigInt(arg));
4351
5948
  var u128 = z.union([
@@ -4421,8 +6018,7 @@ z.union([
4421
6018
  prewitnessedDepositId: u128
4422
6019
  })
4423
6020
  ]);
4424
-
4425
- // ../shared/src/schemas.ts
6021
+ hexString.transform((value) => base58.encode(hexToBytes(value)));
4426
6022
  z.object({
4427
6023
  srcChain: chain,
4428
6024
  srcAsset: asset,
@@ -4460,8 +6056,13 @@ z.object({
4460
6056
  };
4461
6057
  });
4462
6058
  var ccmParamsSchema = z.object({
4463
- gasBudget: numericString,
4464
- message: hexStringWithMaxByteSize(1024 * 10)
6059
+ gasBudget: z.union([
6060
+ numericString,
6061
+ hexString
6062
+ ]).transform((n) => hexEncodeNumber(BigInt(n))),
6063
+ message: hexStringWithMaxByteSize(1024 * 10),
6064
+ // TODO(solana): update max size when it is known
6065
+ cfParameters: hexStringWithMaxByteSize(1024 * 10).optional()
4465
6066
  });
4466
6067
  var affiliateBroker = z.object({
4467
6068
  account: chainflipAddress,
@@ -4491,5 +6092,25 @@ z.object({
4491
6092
  ...rest,
4492
6093
  expectedDepositAmount: amount
4493
6094
  }));
6095
+ /*! Bundled license information:
6096
+
6097
+ @noble/hashes/esm/utils.js:
6098
+ (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
6099
+
6100
+ @noble/curves/esm/abstract/utils.js:
6101
+ (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
6102
+
6103
+ @noble/curves/esm/abstract/modular.js:
6104
+ (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
6105
+
6106
+ @noble/curves/esm/abstract/curve.js:
6107
+ (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
6108
+
6109
+ @noble/curves/esm/abstract/edwards.js:
6110
+ (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
6111
+
6112
+ @noble/curves/esm/ed25519.js:
6113
+ (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
6114
+ */
4494
6115
 
4495
- export { affiliateBroker, assertValidAddress, assetAndChain, btcAddress, ccmParamsSchema, dotAddress, ethereumAddress, fillOrKillParams, hexString, numericString, z };
6116
+ export { affiliateBroker, assertValidAddress, assetAndChain, btcAddress, ccmParamsSchema, dotAddress, ethereumAddress, fillOrKillParams, hexString, numericString, solanaAddress, z };