@settlemint/sdk-cli 2.1.4-pra7619575 → 2.1.4-prb6bb647e

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.
Files changed (3) hide show
  1. package/dist/cli.js +1294 -690
  2. package/dist/cli.js.map +69 -61
  3. package/package.json +3 -3
package/dist/cli.js CHANGED
@@ -837,7 +837,7 @@ var require_dist2 = __commonJS((exports) => {
837
837
  // ../../node_modules/@dotenvx/dotenvx/package.json
838
838
  var require_package = __commonJS((exports, module) => {
839
839
  module.exports = {
840
- version: "1.39.1",
840
+ version: "1.41.0",
841
841
  name: "@dotenvx/dotenvx",
842
842
  description: "a better dotenv–from the creator of `dotenv`",
843
843
  author: "@motdotla",
@@ -1086,7 +1086,7 @@ var require_logger = __commonJS((exports, module) => {
1086
1086
  // ../../node_modules/fdir/dist/utils.js
1087
1087
  var require_utils = __commonJS((exports) => {
1088
1088
  Object.defineProperty(exports, "__esModule", { value: true });
1089
- exports.normalizePath = exports.convertSlashes = exports.cleanPath = undefined;
1089
+ exports.normalizePath = exports.isRootDirectory = exports.convertSlashes = exports.cleanPath = undefined;
1090
1090
  var path_1 = __require("path");
1091
1091
  function cleanPath(path) {
1092
1092
  let normalized = (0, path_1.normalize)(path);
@@ -1100,6 +1100,10 @@ var require_utils = __commonJS((exports) => {
1100
1100
  return path.replace(SLASHES_REGEX, separator);
1101
1101
  }
1102
1102
  exports.convertSlashes = convertSlashes;
1103
+ function isRootDirectory(path) {
1104
+ return path === "/" || /^[a-z]:\\$/i.test(path);
1105
+ }
1106
+ exports.isRootDirectory = isRootDirectory;
1103
1107
  function normalizePath(path, options) {
1104
1108
  const { resolvePaths, normalizePath: normalizePath2, pathSeparator } = options;
1105
1109
  const pathNeedsCleaning = process.platform === "win32" && path.includes("/") || path.startsWith(".");
@@ -1523,7 +1527,7 @@ var require_walker = __commonJS((exports) => {
1523
1527
  this.callbackInvoker = invokeCallback.build(options, this.isSynchronous);
1524
1528
  this.root = (0, utils_1.normalizePath)(root, options);
1525
1529
  this.state = {
1526
- root: this.root.slice(0, -1),
1530
+ root: (0, utils_1.isRootDirectory)(this.root) ? this.root : this.root.slice(0, -1),
1527
1531
  paths: [""].slice(0, 0),
1528
1532
  groups: [],
1529
1533
  counts: new counter_1.Counter,
@@ -4232,7 +4236,7 @@ var require_utils4 = __commonJS((exports) => {
4232
4236
  exports.wrapXOFConstructorWithOpts = wrapXOFConstructorWithOpts;
4233
4237
  exports.randomBytes = randomBytes;
4234
4238
  var crypto_1 = require_cryptoNode2();
4235
- var _assert_js_1 = require__assert2();
4239
+ var _assert_ts_1 = require__assert2();
4236
4240
  function isBytes(a) {
4237
4241
  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
4238
4242
  }
@@ -4261,9 +4265,12 @@ var require_utils4 = __commonJS((exports) => {
4261
4265
  arr[i] = byteSwap(arr[i]);
4262
4266
  }
4263
4267
  }
4268
+ var hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
4264
4269
  var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
4265
4270
  function bytesToHex(bytes) {
4266
- (0, _assert_js_1.abytes)(bytes);
4271
+ (0, _assert_ts_1.abytes)(bytes);
4272
+ if (hasHexBuiltin)
4273
+ return bytes.toHex();
4267
4274
  let hex = "";
4268
4275
  for (let i = 0;i < bytes.length; i++) {
4269
4276
  hex += hexes[bytes[i]];
@@ -4283,6 +4290,8 @@ var require_utils4 = __commonJS((exports) => {
4283
4290
  function hexToBytes(hex) {
4284
4291
  if (typeof hex !== "string")
4285
4292
  throw new Error("hex string expected, got " + typeof hex);
4293
+ if (hasHexBuiltin)
4294
+ return Uint8Array.fromHex(hex);
4286
4295
  const hl = hex.length;
4287
4296
  const al = hl / 2;
4288
4297
  if (hl % 2)
@@ -4320,14 +4329,14 @@ var require_utils4 = __commonJS((exports) => {
4320
4329
  function toBytes(data) {
4321
4330
  if (typeof data === "string")
4322
4331
  data = utf8ToBytes(data);
4323
- (0, _assert_js_1.abytes)(data);
4332
+ (0, _assert_ts_1.abytes)(data);
4324
4333
  return data;
4325
4334
  }
4326
4335
  function concatBytes(...arrays) {
4327
4336
  let sum = 0;
4328
4337
  for (let i = 0;i < arrays.length; i++) {
4329
4338
  const a = arrays[i];
4330
- (0, _assert_js_1.abytes)(a);
4339
+ (0, _assert_ts_1.abytes)(a);
4331
4340
  sum += a.length;
4332
4341
  }
4333
4342
  const res = new Uint8Array(sum);
@@ -4380,7 +4389,7 @@ var require_utils4 = __commonJS((exports) => {
4380
4389
  return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
4381
4390
  }
4382
4391
  if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === "function") {
4383
- return crypto_1.crypto.randomBytes(bytesLength);
4392
+ return Uint8Array.from(crypto_1.crypto.randomBytes(bytesLength));
4384
4393
  }
4385
4394
  throw new Error("crypto.getRandomValues must be defined");
4386
4395
  }
@@ -4393,8 +4402,8 @@ var require__md = __commonJS((exports) => {
4393
4402
  exports.setBigUint64 = setBigUint64;
4394
4403
  exports.Chi = Chi;
4395
4404
  exports.Maj = Maj;
4396
- var _assert_js_1 = require__assert2();
4397
- var utils_js_1 = require_utils4();
4405
+ var _assert_ts_1 = require__assert2();
4406
+ var utils_ts_1 = require_utils4();
4398
4407
  function setBigUint64(view, byteOffset, value, isLE) {
4399
4408
  if (typeof view.setBigUint64 === "function")
4400
4409
  return view.setBigUint64(byteOffset, value, isLE);
@@ -4414,29 +4423,29 @@ var require__md = __commonJS((exports) => {
4414
4423
  return a & b ^ a & c ^ b & c;
4415
4424
  }
4416
4425
 
4417
- class HashMD extends utils_js_1.Hash {
4426
+ class HashMD extends utils_ts_1.Hash {
4418
4427
  constructor(blockLen, outputLen, padOffset, isLE) {
4419
4428
  super();
4420
- this.blockLen = blockLen;
4421
- this.outputLen = outputLen;
4422
- this.padOffset = padOffset;
4423
- this.isLE = isLE;
4424
4429
  this.finished = false;
4425
4430
  this.length = 0;
4426
4431
  this.pos = 0;
4427
4432
  this.destroyed = false;
4433
+ this.blockLen = blockLen;
4434
+ this.outputLen = outputLen;
4435
+ this.padOffset = padOffset;
4436
+ this.isLE = isLE;
4428
4437
  this.buffer = new Uint8Array(blockLen);
4429
- this.view = (0, utils_js_1.createView)(this.buffer);
4438
+ this.view = (0, utils_ts_1.createView)(this.buffer);
4430
4439
  }
4431
4440
  update(data) {
4432
- (0, _assert_js_1.aexists)(this);
4441
+ (0, _assert_ts_1.aexists)(this);
4433
4442
  const { view, buffer, blockLen } = this;
4434
- data = (0, utils_js_1.toBytes)(data);
4443
+ data = (0, utils_ts_1.toBytes)(data);
4435
4444
  const len = data.length;
4436
4445
  for (let pos = 0;pos < len; ) {
4437
4446
  const take = Math.min(blockLen - this.pos, len - pos);
4438
4447
  if (take === blockLen) {
4439
- const dataView = (0, utils_js_1.createView)(data);
4448
+ const dataView = (0, utils_ts_1.createView)(data);
4440
4449
  for (;blockLen <= len - pos; pos += blockLen)
4441
4450
  this.process(dataView, pos);
4442
4451
  continue;
@@ -4454,8 +4463,8 @@ var require__md = __commonJS((exports) => {
4454
4463
  return this;
4455
4464
  }
4456
4465
  digestInto(out) {
4457
- (0, _assert_js_1.aexists)(this);
4458
- (0, _assert_js_1.aoutput)(out, this);
4466
+ (0, _assert_ts_1.aexists)(this);
4467
+ (0, _assert_ts_1.aoutput)(out, this);
4459
4468
  this.finished = true;
4460
4469
  const { buffer, view, blockLen, isLE } = this;
4461
4470
  let { pos } = this;
@@ -4469,7 +4478,7 @@ var require__md = __commonJS((exports) => {
4469
4478
  buffer[i] = 0;
4470
4479
  setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
4471
4480
  this.process(view, 0);
4472
- const oview = (0, utils_js_1.createView)(out);
4481
+ const oview = (0, utils_ts_1.createView)(out);
4473
4482
  const len = this.outputLen;
4474
4483
  if (len % 4)
4475
4484
  throw new Error("_sha2: outputLen should be aligned to 32bit");
@@ -4503,6 +4512,178 @@ var require__md = __commonJS((exports) => {
4503
4512
  exports.HashMD = HashMD;
4504
4513
  });
4505
4514
 
4515
+ // ../../node_modules/@noble/hashes/sha256.js
4516
+ var require_sha256 = __commonJS((exports) => {
4517
+ Object.defineProperty(exports, "__esModule", { value: true });
4518
+ exports.sha224 = exports.sha256 = exports.SHA256 = undefined;
4519
+ var _md_ts_1 = require__md();
4520
+ var utils_ts_1 = require_utils4();
4521
+ var SHA256_K = /* @__PURE__ */ new Uint32Array([
4522
+ 1116352408,
4523
+ 1899447441,
4524
+ 3049323471,
4525
+ 3921009573,
4526
+ 961987163,
4527
+ 1508970993,
4528
+ 2453635748,
4529
+ 2870763221,
4530
+ 3624381080,
4531
+ 310598401,
4532
+ 607225278,
4533
+ 1426881987,
4534
+ 1925078388,
4535
+ 2162078206,
4536
+ 2614888103,
4537
+ 3248222580,
4538
+ 3835390401,
4539
+ 4022224774,
4540
+ 264347078,
4541
+ 604807628,
4542
+ 770255983,
4543
+ 1249150122,
4544
+ 1555081692,
4545
+ 1996064986,
4546
+ 2554220882,
4547
+ 2821834349,
4548
+ 2952996808,
4549
+ 3210313671,
4550
+ 3336571891,
4551
+ 3584528711,
4552
+ 113926993,
4553
+ 338241895,
4554
+ 666307205,
4555
+ 773529912,
4556
+ 1294757372,
4557
+ 1396182291,
4558
+ 1695183700,
4559
+ 1986661051,
4560
+ 2177026350,
4561
+ 2456956037,
4562
+ 2730485921,
4563
+ 2820302411,
4564
+ 3259730800,
4565
+ 3345764771,
4566
+ 3516065817,
4567
+ 3600352804,
4568
+ 4094571909,
4569
+ 275423344,
4570
+ 430227734,
4571
+ 506948616,
4572
+ 659060556,
4573
+ 883997877,
4574
+ 958139571,
4575
+ 1322822218,
4576
+ 1537002063,
4577
+ 1747873779,
4578
+ 1955562222,
4579
+ 2024104815,
4580
+ 2227730452,
4581
+ 2361852424,
4582
+ 2428436474,
4583
+ 2756734187,
4584
+ 3204031479,
4585
+ 3329325298
4586
+ ]);
4587
+ var SHA256_IV = /* @__PURE__ */ new Uint32Array([
4588
+ 1779033703,
4589
+ 3144134277,
4590
+ 1013904242,
4591
+ 2773480762,
4592
+ 1359893119,
4593
+ 2600822924,
4594
+ 528734635,
4595
+ 1541459225
4596
+ ]);
4597
+ var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
4598
+
4599
+ class SHA256 extends _md_ts_1.HashMD {
4600
+ constructor(outputLen = 32) {
4601
+ super(64, outputLen, 8, false);
4602
+ this.A = SHA256_IV[0] | 0;
4603
+ this.B = SHA256_IV[1] | 0;
4604
+ this.C = SHA256_IV[2] | 0;
4605
+ this.D = SHA256_IV[3] | 0;
4606
+ this.E = SHA256_IV[4] | 0;
4607
+ this.F = SHA256_IV[5] | 0;
4608
+ this.G = SHA256_IV[6] | 0;
4609
+ this.H = SHA256_IV[7] | 0;
4610
+ }
4611
+ get() {
4612
+ const { A, B, C, D, E, F, G, H } = this;
4613
+ return [A, B, C, D, E, F, G, H];
4614
+ }
4615
+ set(A, B, C, D, E, F, G, H) {
4616
+ this.A = A | 0;
4617
+ this.B = B | 0;
4618
+ this.C = C | 0;
4619
+ this.D = D | 0;
4620
+ this.E = E | 0;
4621
+ this.F = F | 0;
4622
+ this.G = G | 0;
4623
+ this.H = H | 0;
4624
+ }
4625
+ process(view, offset) {
4626
+ for (let i = 0;i < 16; i++, offset += 4)
4627
+ SHA256_W[i] = view.getUint32(offset, false);
4628
+ for (let i = 16;i < 64; i++) {
4629
+ const W15 = SHA256_W[i - 15];
4630
+ const W2 = SHA256_W[i - 2];
4631
+ const s0 = (0, utils_ts_1.rotr)(W15, 7) ^ (0, utils_ts_1.rotr)(W15, 18) ^ W15 >>> 3;
4632
+ const s1 = (0, utils_ts_1.rotr)(W2, 17) ^ (0, utils_ts_1.rotr)(W2, 19) ^ W2 >>> 10;
4633
+ SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
4634
+ }
4635
+ let { A, B, C, D, E, F, G, H } = this;
4636
+ for (let i = 0;i < 64; i++) {
4637
+ const sigma1 = (0, utils_ts_1.rotr)(E, 6) ^ (0, utils_ts_1.rotr)(E, 11) ^ (0, utils_ts_1.rotr)(E, 25);
4638
+ const T1 = H + sigma1 + (0, _md_ts_1.Chi)(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
4639
+ const sigma0 = (0, utils_ts_1.rotr)(A, 2) ^ (0, utils_ts_1.rotr)(A, 13) ^ (0, utils_ts_1.rotr)(A, 22);
4640
+ const T2 = sigma0 + (0, _md_ts_1.Maj)(A, B, C) | 0;
4641
+ H = G;
4642
+ G = F;
4643
+ F = E;
4644
+ E = D + T1 | 0;
4645
+ D = C;
4646
+ C = B;
4647
+ B = A;
4648
+ A = T1 + T2 | 0;
4649
+ }
4650
+ A = A + this.A | 0;
4651
+ B = B + this.B | 0;
4652
+ C = C + this.C | 0;
4653
+ D = D + this.D | 0;
4654
+ E = E + this.E | 0;
4655
+ F = F + this.F | 0;
4656
+ G = G + this.G | 0;
4657
+ H = H + this.H | 0;
4658
+ this.set(A, B, C, D, E, F, G, H);
4659
+ }
4660
+ roundClean() {
4661
+ SHA256_W.fill(0);
4662
+ }
4663
+ destroy() {
4664
+ this.set(0, 0, 0, 0, 0, 0, 0, 0);
4665
+ this.buffer.fill(0);
4666
+ }
4667
+ }
4668
+ exports.SHA256 = SHA256;
4669
+
4670
+ class SHA224 extends SHA256 {
4671
+ constructor() {
4672
+ super(28);
4673
+ this.A = 3238371032 | 0;
4674
+ this.B = 914150663 | 0;
4675
+ this.C = 812702999 | 0;
4676
+ this.D = 4144912697 | 0;
4677
+ this.E = 4290775857 | 0;
4678
+ this.F = 1750603025 | 0;
4679
+ this.G = 1694076839 | 0;
4680
+ this.H = 3204075428 | 0;
4681
+ }
4682
+ }
4683
+ exports.sha256 = (0, utils_ts_1.wrapConstructor)(() => new SHA256);
4684
+ exports.sha224 = (0, utils_ts_1.wrapConstructor)(() => new SHA224);
4685
+ });
4686
+
4506
4687
  // ../../node_modules/@noble/hashes/_u64.js
4507
4688
  var require__u64 = __commonJS((exports) => {
4508
4689
  Object.defineProperty(exports, "__esModule", { value: true });
@@ -4599,10 +4780,10 @@ var require__u64 = __commonJS((exports) => {
4599
4780
  var require_sha512 = __commonJS((exports) => {
4600
4781
  Object.defineProperty(exports, "__esModule", { value: true });
4601
4782
  exports.sha384 = exports.sha512_256 = exports.sha512_224 = exports.sha512 = exports.SHA384 = exports.SHA512_256 = exports.SHA512_224 = exports.SHA512 = undefined;
4602
- var _md_js_1 = require__md();
4603
- var _u64_js_1 = require__u64();
4604
- var utils_js_1 = require_utils4();
4605
- var [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => _u64_js_1.default.split([
4783
+ var _md_ts_1 = require__md();
4784
+ var _u64_ts_1 = require__u64();
4785
+ var utils_ts_1 = require_utils4();
4786
+ var [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => _u64_ts_1.default.split([
4606
4787
  "0x428a2f98d728ae22",
4607
4788
  "0x7137449123ef65cd",
4608
4789
  "0xb5c0fbcfec4d3b2f",
@@ -4687,9 +4868,9 @@ var require_sha512 = __commonJS((exports) => {
4687
4868
  var SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
4688
4869
  var SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
4689
4870
 
4690
- class SHA512 extends _md_js_1.HashMD {
4691
- constructor() {
4692
- super(128, 64, 16, false);
4871
+ class SHA512 extends _md_ts_1.HashMD {
4872
+ constructor(outputLen = 64) {
4873
+ super(128, outputLen, 16, false);
4693
4874
  this.Ah = 1779033703 | 0;
4694
4875
  this.Al = 4089235720 | 0;
4695
4876
  this.Bh = 3144134277 | 0;
@@ -4737,28 +4918,28 @@ var require_sha512 = __commonJS((exports) => {
4737
4918
  for (let i = 16;i < 80; i++) {
4738
4919
  const W15h = SHA512_W_H[i - 15] | 0;
4739
4920
  const W15l = SHA512_W_L[i - 15] | 0;
4740
- const s0h = _u64_js_1.default.rotrSH(W15h, W15l, 1) ^ _u64_js_1.default.rotrSH(W15h, W15l, 8) ^ _u64_js_1.default.shrSH(W15h, W15l, 7);
4741
- const s0l = _u64_js_1.default.rotrSL(W15h, W15l, 1) ^ _u64_js_1.default.rotrSL(W15h, W15l, 8) ^ _u64_js_1.default.shrSL(W15h, W15l, 7);
4921
+ const s0h = _u64_ts_1.default.rotrSH(W15h, W15l, 1) ^ _u64_ts_1.default.rotrSH(W15h, W15l, 8) ^ _u64_ts_1.default.shrSH(W15h, W15l, 7);
4922
+ const s0l = _u64_ts_1.default.rotrSL(W15h, W15l, 1) ^ _u64_ts_1.default.rotrSL(W15h, W15l, 8) ^ _u64_ts_1.default.shrSL(W15h, W15l, 7);
4742
4923
  const W2h = SHA512_W_H[i - 2] | 0;
4743
4924
  const W2l = SHA512_W_L[i - 2] | 0;
4744
- const s1h = _u64_js_1.default.rotrSH(W2h, W2l, 19) ^ _u64_js_1.default.rotrBH(W2h, W2l, 61) ^ _u64_js_1.default.shrSH(W2h, W2l, 6);
4745
- const s1l = _u64_js_1.default.rotrSL(W2h, W2l, 19) ^ _u64_js_1.default.rotrBL(W2h, W2l, 61) ^ _u64_js_1.default.shrSL(W2h, W2l, 6);
4746
- const SUMl = _u64_js_1.default.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
4747
- const SUMh = _u64_js_1.default.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
4925
+ const s1h = _u64_ts_1.default.rotrSH(W2h, W2l, 19) ^ _u64_ts_1.default.rotrBH(W2h, W2l, 61) ^ _u64_ts_1.default.shrSH(W2h, W2l, 6);
4926
+ const s1l = _u64_ts_1.default.rotrSL(W2h, W2l, 19) ^ _u64_ts_1.default.rotrBL(W2h, W2l, 61) ^ _u64_ts_1.default.shrSL(W2h, W2l, 6);
4927
+ const SUMl = _u64_ts_1.default.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
4928
+ const SUMh = _u64_ts_1.default.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
4748
4929
  SHA512_W_H[i] = SUMh | 0;
4749
4930
  SHA512_W_L[i] = SUMl | 0;
4750
4931
  }
4751
4932
  let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
4752
4933
  for (let i = 0;i < 80; i++) {
4753
- const sigma1h = _u64_js_1.default.rotrSH(Eh, El, 14) ^ _u64_js_1.default.rotrSH(Eh, El, 18) ^ _u64_js_1.default.rotrBH(Eh, El, 41);
4754
- const sigma1l = _u64_js_1.default.rotrSL(Eh, El, 14) ^ _u64_js_1.default.rotrSL(Eh, El, 18) ^ _u64_js_1.default.rotrBL(Eh, El, 41);
4934
+ const sigma1h = _u64_ts_1.default.rotrSH(Eh, El, 14) ^ _u64_ts_1.default.rotrSH(Eh, El, 18) ^ _u64_ts_1.default.rotrBH(Eh, El, 41);
4935
+ const sigma1l = _u64_ts_1.default.rotrSL(Eh, El, 14) ^ _u64_ts_1.default.rotrSL(Eh, El, 18) ^ _u64_ts_1.default.rotrBL(Eh, El, 41);
4755
4936
  const CHIh = Eh & Fh ^ ~Eh & Gh;
4756
4937
  const CHIl = El & Fl ^ ~El & Gl;
4757
- const T1ll = _u64_js_1.default.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
4758
- const T1h = _u64_js_1.default.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
4938
+ const T1ll = _u64_ts_1.default.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
4939
+ const T1h = _u64_ts_1.default.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
4759
4940
  const T1l = T1ll | 0;
4760
- const sigma0h = _u64_js_1.default.rotrSH(Ah, Al, 28) ^ _u64_js_1.default.rotrBH(Ah, Al, 34) ^ _u64_js_1.default.rotrBH(Ah, Al, 39);
4761
- const sigma0l = _u64_js_1.default.rotrSL(Ah, Al, 28) ^ _u64_js_1.default.rotrBL(Ah, Al, 34) ^ _u64_js_1.default.rotrBL(Ah, Al, 39);
4941
+ const sigma0h = _u64_ts_1.default.rotrSH(Ah, Al, 28) ^ _u64_ts_1.default.rotrBH(Ah, Al, 34) ^ _u64_ts_1.default.rotrBH(Ah, Al, 39);
4942
+ const sigma0l = _u64_ts_1.default.rotrSL(Ah, Al, 28) ^ _u64_ts_1.default.rotrBL(Ah, Al, 34) ^ _u64_ts_1.default.rotrBL(Ah, Al, 39);
4762
4943
  const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
4763
4944
  const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
4764
4945
  Hh = Gh | 0;
@@ -4767,25 +4948,25 @@ var require_sha512 = __commonJS((exports) => {
4767
4948
  Gl = Fl | 0;
4768
4949
  Fh = Eh | 0;
4769
4950
  Fl = El | 0;
4770
- ({ h: Eh, l: El } = _u64_js_1.default.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
4951
+ ({ h: Eh, l: El } = _u64_ts_1.default.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
4771
4952
  Dh = Ch | 0;
4772
4953
  Dl = Cl | 0;
4773
4954
  Ch = Bh | 0;
4774
4955
  Cl = Bl | 0;
4775
4956
  Bh = Ah | 0;
4776
4957
  Bl = Al | 0;
4777
- const All = _u64_js_1.default.add3L(T1l, sigma0l, MAJl);
4778
- Ah = _u64_js_1.default.add3H(All, T1h, sigma0h, MAJh);
4958
+ const All = _u64_ts_1.default.add3L(T1l, sigma0l, MAJl);
4959
+ Ah = _u64_ts_1.default.add3H(All, T1h, sigma0h, MAJh);
4779
4960
  Al = All | 0;
4780
4961
  }
4781
- ({ h: Ah, l: Al } = _u64_js_1.default.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
4782
- ({ h: Bh, l: Bl } = _u64_js_1.default.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
4783
- ({ h: Ch, l: Cl } = _u64_js_1.default.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
4784
- ({ h: Dh, l: Dl } = _u64_js_1.default.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
4785
- ({ h: Eh, l: El } = _u64_js_1.default.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
4786
- ({ h: Fh, l: Fl } = _u64_js_1.default.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
4787
- ({ h: Gh, l: Gl } = _u64_js_1.default.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
4788
- ({ h: Hh, l: Hl } = _u64_js_1.default.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
4962
+ ({ h: Ah, l: Al } = _u64_ts_1.default.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
4963
+ ({ h: Bh, l: Bl } = _u64_ts_1.default.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
4964
+ ({ h: Ch, l: Cl } = _u64_ts_1.default.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
4965
+ ({ h: Dh, l: Dl } = _u64_ts_1.default.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
4966
+ ({ h: Eh, l: El } = _u64_ts_1.default.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
4967
+ ({ h: Fh, l: Fl } = _u64_ts_1.default.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
4968
+ ({ h: Gh, l: Gl } = _u64_ts_1.default.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
4969
+ ({ h: Hh, l: Hl } = _u64_ts_1.default.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
4789
4970
  this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
4790
4971
  }
4791
4972
  roundClean() {
@@ -4801,7 +4982,7 @@ var require_sha512 = __commonJS((exports) => {
4801
4982
 
4802
4983
  class SHA512_224 extends SHA512 {
4803
4984
  constructor() {
4804
- super();
4985
+ super(28);
4805
4986
  this.Ah = 2352822216 | 0;
4806
4987
  this.Al = 424955298 | 0;
4807
4988
  this.Bh = 1944164710 | 0;
@@ -4818,14 +4999,13 @@ var require_sha512 = __commonJS((exports) => {
4818
4999
  this.Gl = 1780299464 | 0;
4819
5000
  this.Hh = 286451373 | 0;
4820
5001
  this.Hl = 2446758561 | 0;
4821
- this.outputLen = 28;
4822
5002
  }
4823
5003
  }
4824
5004
  exports.SHA512_224 = SHA512_224;
4825
5005
 
4826
5006
  class SHA512_256 extends SHA512 {
4827
5007
  constructor() {
4828
- super();
5008
+ super(32);
4829
5009
  this.Ah = 573645204 | 0;
4830
5010
  this.Al = 4230739756 | 0;
4831
5011
  this.Bh = 2673172387 | 0;
@@ -4842,14 +5022,13 @@ var require_sha512 = __commonJS((exports) => {
4842
5022
  this.Gl = 746961066 | 0;
4843
5023
  this.Hh = 246885852 | 0;
4844
5024
  this.Hl = 2177182882 | 0;
4845
- this.outputLen = 32;
4846
5025
  }
4847
5026
  }
4848
5027
  exports.SHA512_256 = SHA512_256;
4849
5028
 
4850
5029
  class SHA384 extends SHA512 {
4851
5030
  constructor() {
4852
- super();
5031
+ super(48);
4853
5032
  this.Ah = 3418070365 | 0;
4854
5033
  this.Al = 3238371032 | 0;
4855
5034
  this.Bh = 1654270250 | 0;
@@ -4866,14 +5045,39 @@ var require_sha512 = __commonJS((exports) => {
4866
5045
  this.Gl = 1694076839 | 0;
4867
5046
  this.Hh = 1203062813 | 0;
4868
5047
  this.Hl = 3204075428 | 0;
4869
- this.outputLen = 48;
4870
5048
  }
4871
5049
  }
4872
5050
  exports.SHA384 = SHA384;
4873
- exports.sha512 = (0, utils_js_1.wrapConstructor)(() => new SHA512);
4874
- exports.sha512_224 = (0, utils_js_1.wrapConstructor)(() => new SHA512_224);
4875
- exports.sha512_256 = (0, utils_js_1.wrapConstructor)(() => new SHA512_256);
4876
- exports.sha384 = (0, utils_js_1.wrapConstructor)(() => new SHA384);
5051
+ exports.sha512 = (0, utils_ts_1.wrapConstructor)(() => new SHA512);
5052
+ exports.sha512_224 = (0, utils_ts_1.wrapConstructor)(() => new SHA512_224);
5053
+ exports.sha512_256 = (0, utils_ts_1.wrapConstructor)(() => new SHA512_256);
5054
+ exports.sha384 = (0, utils_ts_1.wrapConstructor)(() => new SHA384);
5055
+ });
5056
+
5057
+ // ../../node_modules/@noble/hashes/sha2.js
5058
+ var require_sha2 = __commonJS((exports) => {
5059
+ Object.defineProperty(exports, "__esModule", { value: true });
5060
+ exports.sha512_256 = exports.sha512_224 = exports.sha512 = exports.sha384 = exports.sha256 = exports.sha224 = undefined;
5061
+ var sha256_ts_1 = require_sha256();
5062
+ Object.defineProperty(exports, "sha224", { enumerable: true, get: function() {
5063
+ return sha256_ts_1.sha224;
5064
+ } });
5065
+ Object.defineProperty(exports, "sha256", { enumerable: true, get: function() {
5066
+ return sha256_ts_1.sha256;
5067
+ } });
5068
+ var sha512_ts_1 = require_sha512();
5069
+ Object.defineProperty(exports, "sha384", { enumerable: true, get: function() {
5070
+ return sha512_ts_1.sha384;
5071
+ } });
5072
+ Object.defineProperty(exports, "sha512", { enumerable: true, get: function() {
5073
+ return sha512_ts_1.sha512;
5074
+ } });
5075
+ Object.defineProperty(exports, "sha512_224", { enumerable: true, get: function() {
5076
+ return sha512_ts_1.sha512_224;
5077
+ } });
5078
+ Object.defineProperty(exports, "sha512_256", { enumerable: true, get: function() {
5079
+ return sha512_ts_1.sha512_256;
5080
+ } });
4877
5081
  });
4878
5082
 
4879
5083
  // ../../node_modules/@noble/curves/abstract/utils.js
@@ -4884,9 +5088,9 @@ var require_utils5 = __commonJS((exports) => {
4884
5088
  exports.isBytes = isBytes;
4885
5089
  exports.abytes = abytes;
4886
5090
  exports.abool = abool;
4887
- exports.bytesToHex = bytesToHex;
4888
5091
  exports.numberToHexUnpadded = numberToHexUnpadded;
4889
5092
  exports.hexToNumber = hexToNumber;
5093
+ exports.bytesToHex = bytesToHex;
4890
5094
  exports.hexToBytes = hexToBytes;
4891
5095
  exports.bytesToNumberBE = bytesToNumberBE;
4892
5096
  exports.bytesToNumberLE = bytesToNumberLE;
@@ -4907,7 +5111,6 @@ var require_utils5 = __commonJS((exports) => {
4907
5111
  exports.memoized = memoized;
4908
5112
  var _0n = /* @__PURE__ */ BigInt(0);
4909
5113
  var _1n = /* @__PURE__ */ BigInt(1);
4910
- var _2n = /* @__PURE__ */ BigInt(2);
4911
5114
  function isBytes(a) {
4912
5115
  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
4913
5116
  }
@@ -4919,15 +5122,6 @@ var require_utils5 = __commonJS((exports) => {
4919
5122
  if (typeof value !== "boolean")
4920
5123
  throw new Error(title + " boolean expected, got " + value);
4921
5124
  }
4922
- var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
4923
- function bytesToHex(bytes) {
4924
- abytes(bytes);
4925
- let hex = "";
4926
- for (let i = 0;i < bytes.length; i++) {
4927
- hex += hexes[bytes[i]];
4928
- }
4929
- return hex;
4930
- }
4931
5125
  function numberToHexUnpadded(num) {
4932
5126
  const hex = num.toString(16);
4933
5127
  return hex.length & 1 ? "0" + hex : hex;
@@ -4937,6 +5131,18 @@ var require_utils5 = __commonJS((exports) => {
4937
5131
  throw new Error("hex string expected, got " + typeof hex);
4938
5132
  return hex === "" ? _0n : BigInt("0x" + hex);
4939
5133
  }
5134
+ var hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
5135
+ var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
5136
+ function bytesToHex(bytes) {
5137
+ abytes(bytes);
5138
+ if (hasHexBuiltin)
5139
+ return bytes.toHex();
5140
+ let hex = "";
5141
+ for (let i = 0;i < bytes.length; i++) {
5142
+ hex += hexes[bytes[i]];
5143
+ }
5144
+ return hex;
5145
+ }
4940
5146
  var asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
4941
5147
  function asciiToBase16(ch) {
4942
5148
  if (ch >= asciis._0 && ch <= asciis._9)
@@ -4950,6 +5156,8 @@ var require_utils5 = __commonJS((exports) => {
4950
5156
  function hexToBytes(hex) {
4951
5157
  if (typeof hex !== "string")
4952
5158
  throw new Error("hex string expected, got " + typeof hex);
5159
+ if (hasHexBuiltin)
5160
+ return Uint8Array.fromHex(hex);
4953
5161
  const hl = hex.length;
4954
5162
  const al = hl / 2;
4955
5163
  if (hl % 2)
@@ -5048,9 +5256,9 @@ var require_utils5 = __commonJS((exports) => {
5048
5256
  function bitSet(n, pos, value) {
5049
5257
  return n | (value ? _1n : _0n) << BigInt(pos);
5050
5258
  }
5051
- var bitMask = (n) => (_2n << BigInt(n - 1)) - _1n;
5259
+ var bitMask = (n) => (_1n << BigInt(n)) - _1n;
5052
5260
  exports.bitMask = bitMask;
5053
- var u8n = (data) => new Uint8Array(data);
5261
+ var u8n = (len) => new Uint8Array(len);
5054
5262
  var u8fr = (arr) => Uint8Array.from(arr);
5055
5263
  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
5056
5264
  if (typeof hashLen !== "number" || hashLen < 2)
@@ -5068,7 +5276,7 @@ var require_utils5 = __commonJS((exports) => {
5068
5276
  i = 0;
5069
5277
  };
5070
5278
  const h = (...b) => hmacFn(k, v, ...b);
5071
- const reseed = (seed = u8n()) => {
5279
+ const reseed = (seed = u8n(0)) => {
5072
5280
  k = h(u8fr([0]), seed);
5073
5281
  v = h();
5074
5282
  if (seed.length === 0)
@@ -5171,7 +5379,7 @@ var require_modular = __commonJS((exports) => {
5171
5379
  exports.getMinHashLength = getMinHashLength;
5172
5380
  exports.mapHashToField = mapHashToField;
5173
5381
  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
5174
- var utils_js_1 = require_utils5();
5382
+ var utils_ts_1 = require_utils5();
5175
5383
  var _0n = BigInt(0);
5176
5384
  var _1n = BigInt(1);
5177
5385
  var _2n = /* @__PURE__ */ BigInt(2);
@@ -5331,7 +5539,7 @@ var require_modular = __commonJS((exports) => {
5331
5539
  map[val] = "function";
5332
5540
  return map;
5333
5541
  }, initial);
5334
- return (0, utils_js_1.validateObject)(field, opts);
5542
+ return (0, utils_ts_1.validateObject)(field, opts);
5335
5543
  }
5336
5544
  function FpPow(f, num, power) {
5337
5545
  if (power < _0n)
@@ -5398,7 +5606,7 @@ var require_modular = __commonJS((exports) => {
5398
5606
  isLE,
5399
5607
  BITS,
5400
5608
  BYTES,
5401
- MASK: (0, utils_js_1.bitMask)(BITS),
5609
+ MASK: (0, utils_ts_1.bitMask)(BITS),
5402
5610
  ZERO: _0n,
5403
5611
  ONE: _1n,
5404
5612
  create: (num) => mod(num, ORDER),
@@ -5429,11 +5637,11 @@ var require_modular = __commonJS((exports) => {
5429
5637
  }),
5430
5638
  invertBatch: (lst) => FpInvertBatch(f, lst),
5431
5639
  cmov: (a, b, c) => c ? b : a,
5432
- toBytes: (num) => isLE ? (0, utils_js_1.numberToBytesLE)(num, BYTES) : (0, utils_js_1.numberToBytesBE)(num, BYTES),
5640
+ toBytes: (num) => isLE ? (0, utils_ts_1.numberToBytesLE)(num, BYTES) : (0, utils_ts_1.numberToBytesBE)(num, BYTES),
5433
5641
  fromBytes: (bytes) => {
5434
5642
  if (bytes.length !== BYTES)
5435
5643
  throw new Error("Field.fromBytes: expected " + BYTES + " bytes, got " + bytes.length);
5436
- return isLE ? (0, utils_js_1.bytesToNumberLE)(bytes) : (0, utils_js_1.bytesToNumberBE)(bytes);
5644
+ return isLE ? (0, utils_ts_1.bytesToNumberLE)(bytes) : (0, utils_ts_1.bytesToNumberBE)(bytes);
5437
5645
  }
5438
5646
  });
5439
5647
  return Object.freeze(f);
@@ -5451,12 +5659,12 @@ var require_modular = __commonJS((exports) => {
5451
5659
  return Fp.isOdd(root) ? Fp.neg(root) : root;
5452
5660
  }
5453
5661
  function hashToPrivateScalar(hash, groupOrder, isLE = false) {
5454
- hash = (0, utils_js_1.ensureBytes)("privateHash", hash);
5662
+ hash = (0, utils_ts_1.ensureBytes)("privateHash", hash);
5455
5663
  const hashLen = hash.length;
5456
5664
  const minLen = nLength(groupOrder).nByteLength + 8;
5457
5665
  if (minLen < 24 || hashLen < minLen || hashLen > 1024)
5458
5666
  throw new Error("hashToPrivateScalar: expected " + minLen + "-1024 bytes of input, got " + hashLen);
5459
- const num = isLE ? (0, utils_js_1.bytesToNumberLE)(hash) : (0, utils_js_1.bytesToNumberBE)(hash);
5667
+ const num = isLE ? (0, utils_ts_1.bytesToNumberLE)(hash) : (0, utils_ts_1.bytesToNumberBE)(hash);
5460
5668
  return mod(num, groupOrder - _1n) + _1n;
5461
5669
  }
5462
5670
  function getFieldBytesLength(fieldOrder) {
@@ -5475,9 +5683,9 @@ var require_modular = __commonJS((exports) => {
5475
5683
  const minLen = getMinHashLength(fieldOrder);
5476
5684
  if (len < 16 || len < minLen || len > 1024)
5477
5685
  throw new Error("expected " + minLen + "-1024 bytes of input, got " + len);
5478
- const num = isLE ? (0, utils_js_1.bytesToNumberLE)(key) : (0, utils_js_1.bytesToNumberBE)(key);
5686
+ const num = isLE ? (0, utils_ts_1.bytesToNumberLE)(key) : (0, utils_ts_1.bytesToNumberBE)(key);
5479
5687
  const reduced = mod(num, fieldOrder - _1n) + _1n;
5480
- return isLE ? (0, utils_js_1.numberToBytesLE)(reduced, fieldLen) : (0, utils_js_1.numberToBytesBE)(reduced, fieldLen);
5688
+ return isLE ? (0, utils_ts_1.numberToBytesLE)(reduced, fieldLen) : (0, utils_ts_1.numberToBytesBE)(reduced, fieldLen);
5481
5689
  }
5482
5690
  });
5483
5691
 
@@ -5489,8 +5697,8 @@ var require_curve = __commonJS((exports) => {
5489
5697
  exports.precomputeMSMUnsafe = precomputeMSMUnsafe;
5490
5698
  exports.validateBasic = validateBasic;
5491
5699
  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
5492
- var modular_js_1 = require_modular();
5493
- var utils_js_1 = require_utils5();
5700
+ var modular_ts_1 = require_modular();
5701
+ var utils_ts_1 = require_utils5();
5494
5702
  var _0n = BigInt(0);
5495
5703
  var _1n = BigInt(1);
5496
5704
  function constTimeNegate(condition, item) {
@@ -5501,11 +5709,30 @@ var require_curve = __commonJS((exports) => {
5501
5709
  if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
5502
5710
  throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W);
5503
5711
  }
5504
- function calcWOpts(W, bits) {
5505
- validateW(W, bits);
5506
- const windows = Math.ceil(bits / W) + 1;
5712
+ function calcWOpts(W, scalarBits) {
5713
+ validateW(W, scalarBits);
5714
+ const windows = Math.ceil(scalarBits / W) + 1;
5507
5715
  const windowSize = 2 ** (W - 1);
5508
- return { windows, windowSize };
5716
+ const maxNumber = 2 ** W;
5717
+ const mask = (0, utils_ts_1.bitMask)(W);
5718
+ const shiftBy = BigInt(W);
5719
+ return { windows, windowSize, mask, maxNumber, shiftBy };
5720
+ }
5721
+ function calcOffsets(n, window2, wOpts) {
5722
+ const { windowSize, mask, maxNumber, shiftBy } = wOpts;
5723
+ let wbits = Number(n & mask);
5724
+ let nextN = n >> shiftBy;
5725
+ if (wbits > windowSize) {
5726
+ wbits -= maxNumber;
5727
+ nextN += _1n;
5728
+ }
5729
+ const offsetStart = window2 * windowSize;
5730
+ const offset = offsetStart + Math.abs(wbits) - 1;
5731
+ const isZero = wbits === 0;
5732
+ const isNeg = wbits < 0;
5733
+ const isNegF = window2 % 2 !== 0;
5734
+ const offsetF = offsetStart;
5735
+ return { nextN, offset, isZero, isNeg, isNegF, offsetF };
5509
5736
  }
5510
5737
  function validateMSMPoints(points, c) {
5511
5738
  if (!Array.isArray(points))
@@ -5561,53 +5788,33 @@ var require_curve = __commonJS((exports) => {
5561
5788
  return points;
5562
5789
  },
5563
5790
  wNAF(W, precomputes, n) {
5564
- const { windows, windowSize } = calcWOpts(W, bits);
5565
5791
  let p = c.ZERO;
5566
5792
  let f = c.BASE;
5567
- const mask = BigInt(2 ** W - 1);
5568
- const maxNumber = 2 ** W;
5569
- const shiftBy = BigInt(W);
5570
- for (let window2 = 0;window2 < windows; window2++) {
5571
- const offset = window2 * windowSize;
5572
- let wbits = Number(n & mask);
5573
- n >>= shiftBy;
5574
- if (wbits > windowSize) {
5575
- wbits -= maxNumber;
5576
- n += _1n;
5577
- }
5578
- const offset1 = offset;
5579
- const offset2 = offset + Math.abs(wbits) - 1;
5580
- const cond1 = window2 % 2 !== 0;
5581
- const cond2 = wbits < 0;
5582
- if (wbits === 0) {
5583
- f = f.add(constTimeNegate(cond1, precomputes[offset1]));
5793
+ const wo = calcWOpts(W, bits);
5794
+ for (let window2 = 0;window2 < wo.windows; window2++) {
5795
+ const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window2, wo);
5796
+ n = nextN;
5797
+ if (isZero) {
5798
+ f = f.add(constTimeNegate(isNegF, precomputes[offsetF]));
5584
5799
  } else {
5585
- p = p.add(constTimeNegate(cond2, precomputes[offset2]));
5800
+ p = p.add(constTimeNegate(isNeg, precomputes[offset]));
5586
5801
  }
5587
5802
  }
5588
5803
  return { p, f };
5589
5804
  },
5590
5805
  wNAFUnsafe(W, precomputes, n, acc = c.ZERO) {
5591
- const { windows, windowSize } = calcWOpts(W, bits);
5592
- const mask = BigInt(2 ** W - 1);
5593
- const maxNumber = 2 ** W;
5594
- const shiftBy = BigInt(W);
5595
- for (let window2 = 0;window2 < windows; window2++) {
5596
- const offset = window2 * windowSize;
5806
+ const wo = calcWOpts(W, bits);
5807
+ for (let window2 = 0;window2 < wo.windows; window2++) {
5597
5808
  if (n === _0n)
5598
5809
  break;
5599
- let wbits = Number(n & mask);
5600
- n >>= shiftBy;
5601
- if (wbits > windowSize) {
5602
- wbits -= maxNumber;
5603
- n += _1n;
5604
- }
5605
- if (wbits === 0)
5810
+ const { nextN, offset, isZero, isNeg } = calcOffsets(n, window2, wo);
5811
+ n = nextN;
5812
+ if (isZero) {
5606
5813
  continue;
5607
- let curr = precomputes[offset + Math.abs(wbits) - 1];
5608
- if (wbits < 0)
5609
- curr = curr.negate();
5610
- acc = acc.add(curr);
5814
+ } else {
5815
+ const item = precomputes[offset];
5816
+ acc = acc.add(isNeg ? item.negate() : item);
5817
+ }
5611
5818
  }
5612
5819
  return acc;
5613
5820
  },
@@ -5643,17 +5850,17 @@ var require_curve = __commonJS((exports) => {
5643
5850
  if (points.length !== scalars.length)
5644
5851
  throw new Error("arrays of points and scalars must have equal length");
5645
5852
  const zero = c.ZERO;
5646
- const wbits = (0, utils_js_1.bitLen)(BigInt(points.length));
5853
+ const wbits = (0, utils_ts_1.bitLen)(BigInt(points.length));
5647
5854
  const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
5648
- const MASK = (1 << windowSize) - 1;
5649
- const buckets = new Array(MASK + 1).fill(zero);
5855
+ const MASK = (0, utils_ts_1.bitMask)(windowSize);
5856
+ const buckets = new Array(Number(MASK) + 1).fill(zero);
5650
5857
  const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;
5651
5858
  let sum = zero;
5652
5859
  for (let i = lastBits;i >= 0; i -= windowSize) {
5653
5860
  buckets.fill(zero);
5654
5861
  for (let j = 0;j < scalars.length; j++) {
5655
5862
  const scalar = scalars[j];
5656
- const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
5863
+ const wbits2 = Number(scalar >> BigInt(i) & MASK);
5657
5864
  buckets[wbits2] = buckets[wbits2].add(points[j]);
5658
5865
  }
5659
5866
  let resI = zero;
@@ -5674,7 +5881,7 @@ var require_curve = __commonJS((exports) => {
5674
5881
  const zero = c.ZERO;
5675
5882
  const tableSize = 2 ** windowSize - 1;
5676
5883
  const chunks = Math.ceil(fieldN.BITS / windowSize);
5677
- const MASK = BigInt((1 << windowSize) - 1);
5884
+ const MASK = (0, utils_ts_1.bitMask)(windowSize);
5678
5885
  const tables = points.map((p) => {
5679
5886
  const res = [];
5680
5887
  for (let i = 0, acc = p;i < tableSize; i++) {
@@ -5705,8 +5912,8 @@ var require_curve = __commonJS((exports) => {
5705
5912
  };
5706
5913
  }
5707
5914
  function validateBasic(curve) {
5708
- (0, modular_js_1.validateField)(curve.Fp);
5709
- (0, utils_js_1.validateObject)(curve, {
5915
+ (0, modular_ts_1.validateField)(curve.Fp);
5916
+ (0, utils_ts_1.validateObject)(curve, {
5710
5917
  n: "bigint",
5711
5918
  h: "bigint",
5712
5919
  Gx: "field",
@@ -5716,7 +5923,7 @@ var require_curve = __commonJS((exports) => {
5716
5923
  nByteLength: "isSafeInteger"
5717
5924
  });
5718
5925
  return Object.freeze({
5719
- ...(0, modular_js_1.nLength)(curve.n, curve.nBitLength),
5926
+ ...(0, modular_ts_1.nLength)(curve.n, curve.nBitLength),
5720
5927
  ...curve,
5721
5928
  ...{ p: curve.Fp.ORDER }
5722
5929
  });
@@ -5728,18 +5935,17 @@ var require_edwards = __commonJS((exports) => {
5728
5935
  Object.defineProperty(exports, "__esModule", { value: true });
5729
5936
  exports.twistedEdwards = twistedEdwards;
5730
5937
  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
5731
- var curve_js_1 = require_curve();
5732
- var modular_js_1 = require_modular();
5733
- var ut = require_utils5();
5734
- var utils_js_1 = require_utils5();
5938
+ var curve_ts_1 = require_curve();
5939
+ var modular_ts_1 = require_modular();
5940
+ var utils_ts_1 = require_utils5();
5735
5941
  var _0n = BigInt(0);
5736
5942
  var _1n = BigInt(1);
5737
5943
  var _2n = BigInt(2);
5738
5944
  var _8n = BigInt(8);
5739
5945
  var VERIFY_DEFAULT = { zip215: true };
5740
5946
  function validateOpts(curve) {
5741
- const opts = (0, curve_js_1.validateBasic)(curve);
5742
- ut.validateObject(curve, {
5947
+ const opts = (0, curve_ts_1.validateBasic)(curve);
5948
+ (0, utils_ts_1.validateObject)(curve, {
5743
5949
  hash: "function",
5744
5950
  a: "bigint",
5745
5951
  d: "bigint",
@@ -5757,7 +5963,7 @@ var require_edwards = __commonJS((exports) => {
5757
5963
  const { Fp, n: CURVE_ORDER, prehash, hash: cHash, randomBytes, nByteLength, h: cofactor } = CURVE;
5758
5964
  const MASK = _2n << BigInt(nByteLength * 8) - _1n;
5759
5965
  const modP = Fp.create;
5760
- const Fn = (0, modular_js_1.Field)(CURVE.n, CURVE.nBitLength);
5966
+ const Fn = (0, modular_ts_1.Field)(CURVE.n, CURVE.nBitLength);
5761
5967
  const uvRatio = CURVE.uvRatio || ((u, v) => {
5762
5968
  try {
5763
5969
  return { isValid: true, value: Fp.sqrt(u * Fp.inv(v)) };
@@ -5767,19 +5973,20 @@ var require_edwards = __commonJS((exports) => {
5767
5973
  });
5768
5974
  const adjustScalarBytes = CURVE.adjustScalarBytes || ((bytes) => bytes);
5769
5975
  const domain = CURVE.domain || ((data, ctx, phflag) => {
5770
- (0, utils_js_1.abool)("phflag", phflag);
5976
+ (0, utils_ts_1.abool)("phflag", phflag);
5771
5977
  if (ctx.length || phflag)
5772
5978
  throw new Error("Contexts/pre-hash are not supported");
5773
5979
  return data;
5774
5980
  });
5775
- function aCoordinate(title, n) {
5776
- ut.aInRange("coordinate " + title, n, _0n, MASK);
5981
+ function aCoordinate(title, n, banZero = false) {
5982
+ const min = banZero ? _1n : _0n;
5983
+ (0, utils_ts_1.aInRange)("coordinate " + title, n, min, MASK);
5777
5984
  }
5778
- function assertPoint(other) {
5985
+ function aextpoint(other) {
5779
5986
  if (!(other instanceof Point))
5780
5987
  throw new Error("ExtendedPoint expected");
5781
5988
  }
5782
- const toAffineMemo = (0, utils_js_1.memoized)((p, iz) => {
5989
+ const toAffineMemo = (0, utils_ts_1.memoized)((p, iz) => {
5783
5990
  const { ex: x, ey: y, ez: z2 } = p;
5784
5991
  const is0 = p.is0();
5785
5992
  if (iz == null)
@@ -5793,7 +6000,7 @@ var require_edwards = __commonJS((exports) => {
5793
6000
  throw new Error("invZ was invalid");
5794
6001
  return { x: ax, y: ay };
5795
6002
  });
5796
- const assertValidMemo = (0, utils_js_1.memoized)((p) => {
6003
+ const assertValidMemo = (0, utils_ts_1.memoized)((p) => {
5797
6004
  const { a, d } = CURVE;
5798
6005
  if (p.is0())
5799
6006
  throw new Error("bad point: ZERO");
@@ -5816,14 +6023,14 @@ var require_edwards = __commonJS((exports) => {
5816
6023
 
5817
6024
  class Point {
5818
6025
  constructor(ex, ey, ez, et) {
6026
+ aCoordinate("x", ex);
6027
+ aCoordinate("y", ey);
6028
+ aCoordinate("z", ez, true);
6029
+ aCoordinate("t", et);
5819
6030
  this.ex = ex;
5820
6031
  this.ey = ey;
5821
6032
  this.ez = ez;
5822
6033
  this.et = et;
5823
- aCoordinate("x", ex);
5824
- aCoordinate("y", ey);
5825
- aCoordinate("z", ez);
5826
- aCoordinate("t", et);
5827
6034
  Object.freeze(this);
5828
6035
  }
5829
6036
  get x() {
@@ -5845,7 +6052,7 @@ var require_edwards = __commonJS((exports) => {
5845
6052
  return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
5846
6053
  }
5847
6054
  static msm(points, scalars) {
5848
- return (0, curve_js_1.pippenger)(Point, Fn, points, scalars);
6055
+ return (0, curve_ts_1.pippenger)(Point, Fn, points, scalars);
5849
6056
  }
5850
6057
  _setWindowSize(windowSize) {
5851
6058
  wnaf.setWindowSize(this, windowSize);
@@ -5854,7 +6061,7 @@ var require_edwards = __commonJS((exports) => {
5854
6061
  assertValidMemo(this);
5855
6062
  }
5856
6063
  equals(other) {
5857
- assertPoint(other);
6064
+ aextpoint(other);
5858
6065
  const { ex: X1, ey: Y1, ez: Z1 } = this;
5859
6066
  const { ex: X2, ey: Y2, ez: Z2 } = other;
5860
6067
  const X1Z2 = modP(X1 * Z2);
@@ -5888,27 +6095,10 @@ var require_edwards = __commonJS((exports) => {
5888
6095
  return new Point(X3, Y3, Z3, T3);
5889
6096
  }
5890
6097
  add(other) {
5891
- assertPoint(other);
6098
+ aextpoint(other);
5892
6099
  const { a, d } = CURVE;
5893
6100
  const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
5894
6101
  const { ex: X2, ey: Y2, ez: Z2, et: T2 } = other;
5895
- if (a === BigInt(-1)) {
5896
- const A2 = modP((Y1 - X1) * (Y2 + X2));
5897
- const B2 = modP((Y1 + X1) * (Y2 - X2));
5898
- const F2 = modP(B2 - A2);
5899
- if (F2 === _0n)
5900
- return this.double();
5901
- const C2 = modP(Z1 * _2n * T2);
5902
- const D2 = modP(T1 * _2n * Z2);
5903
- const E2 = D2 + C2;
5904
- const G3 = B2 + A2;
5905
- const H2 = D2 - C2;
5906
- const X32 = modP(E2 * F2);
5907
- const Y32 = modP(G3 * H2);
5908
- const T32 = modP(E2 * H2);
5909
- const Z32 = modP(F2 * G3);
5910
- return new Point(X32, Y32, Z32, T32);
5911
- }
5912
6102
  const A = modP(X1 * X2);
5913
6103
  const B = modP(Y1 * Y2);
5914
6104
  const C = modP(T1 * d * T2);
@@ -5931,13 +6121,13 @@ var require_edwards = __commonJS((exports) => {
5931
6121
  }
5932
6122
  multiply(scalar) {
5933
6123
  const n = scalar;
5934
- ut.aInRange("scalar", n, _1n, CURVE_ORDER);
6124
+ (0, utils_ts_1.aInRange)("scalar", n, _1n, CURVE_ORDER);
5935
6125
  const { p, f } = this.wNAF(n);
5936
6126
  return Point.normalizeZ([p, f])[0];
5937
6127
  }
5938
6128
  multiplyUnsafe(scalar, acc = Point.ZERO) {
5939
6129
  const n = scalar;
5940
- ut.aInRange("scalar", n, _0n, CURVE_ORDER);
6130
+ (0, utils_ts_1.aInRange)("scalar", n, _0n, CURVE_ORDER);
5941
6131
  if (n === _0n)
5942
6132
  return I;
5943
6133
  if (this.is0() || n === _1n)
@@ -5962,14 +6152,14 @@ var require_edwards = __commonJS((exports) => {
5962
6152
  static fromHex(hex, zip215 = false) {
5963
6153
  const { d, a } = CURVE;
5964
6154
  const len = Fp.BYTES;
5965
- hex = (0, utils_js_1.ensureBytes)("pointHex", hex, len);
5966
- (0, utils_js_1.abool)("zip215", zip215);
6155
+ hex = (0, utils_ts_1.ensureBytes)("pointHex", hex, len);
6156
+ (0, utils_ts_1.abool)("zip215", zip215);
5967
6157
  const normed = hex.slice();
5968
6158
  const lastByte = hex[len - 1];
5969
6159
  normed[len - 1] = lastByte & ~128;
5970
- const y = ut.bytesToNumberLE(normed);
6160
+ const y = (0, utils_ts_1.bytesToNumberLE)(normed);
5971
6161
  const max = zip215 ? MASK : Fp.ORDER;
5972
- ut.aInRange("pointHex.y", y, _0n, max);
6162
+ (0, utils_ts_1.aInRange)("pointHex.y", y, _0n, max);
5973
6163
  const y2 = modP(y * y);
5974
6164
  const u = modP(y2 - _1n);
5975
6165
  const v = modP(d * y2 - a);
@@ -5985,35 +6175,40 @@ var require_edwards = __commonJS((exports) => {
5985
6175
  return Point.fromAffine({ x, y });
5986
6176
  }
5987
6177
  static fromPrivateKey(privKey) {
5988
- return getExtendedPublicKey(privKey).point;
6178
+ const { scalar } = getPrivateScalar(privKey);
6179
+ return G.multiply(scalar);
5989
6180
  }
5990
6181
  toRawBytes() {
5991
6182
  const { x, y } = this.toAffine();
5992
- const bytes = ut.numberToBytesLE(y, Fp.BYTES);
6183
+ const bytes = (0, utils_ts_1.numberToBytesLE)(y, Fp.BYTES);
5993
6184
  bytes[bytes.length - 1] |= x & _1n ? 128 : 0;
5994
6185
  return bytes;
5995
6186
  }
5996
6187
  toHex() {
5997
- return ut.bytesToHex(this.toRawBytes());
6188
+ return (0, utils_ts_1.bytesToHex)(this.toRawBytes());
5998
6189
  }
5999
6190
  }
6000
6191
  Point.BASE = new Point(CURVE.Gx, CURVE.Gy, _1n, modP(CURVE.Gx * CURVE.Gy));
6001
6192
  Point.ZERO = new Point(_0n, _1n, _1n, _0n);
6002
6193
  const { BASE: G, ZERO: I } = Point;
6003
- const wnaf = (0, curve_js_1.wNAF)(Point, nByteLength * 8);
6194
+ const wnaf = (0, curve_ts_1.wNAF)(Point, nByteLength * 8);
6004
6195
  function modN(a) {
6005
- return (0, modular_js_1.mod)(a, CURVE_ORDER);
6196
+ return (0, modular_ts_1.mod)(a, CURVE_ORDER);
6006
6197
  }
6007
6198
  function modN_LE(hash) {
6008
- return modN(ut.bytesToNumberLE(hash));
6199
+ return modN((0, utils_ts_1.bytesToNumberLE)(hash));
6009
6200
  }
6010
- function getExtendedPublicKey(key) {
6201
+ function getPrivateScalar(key) {
6011
6202
  const len = Fp.BYTES;
6012
- key = (0, utils_js_1.ensureBytes)("private key", key, len);
6013
- const hashed = (0, utils_js_1.ensureBytes)("hashed private key", cHash(key), 2 * len);
6203
+ key = (0, utils_ts_1.ensureBytes)("private key", key, len);
6204
+ const hashed = (0, utils_ts_1.ensureBytes)("hashed private key", cHash(key), 2 * len);
6014
6205
  const head = adjustScalarBytes(hashed.slice(0, len));
6015
6206
  const prefix = hashed.slice(len, 2 * len);
6016
6207
  const scalar = modN_LE(head);
6208
+ return { head, prefix, scalar };
6209
+ }
6210
+ function getExtendedPublicKey(key) {
6211
+ const { head, prefix, scalar } = getPrivateScalar(key);
6017
6212
  const point = G.multiply(scalar);
6018
6213
  const pointBytes = point.toRawBytes();
6019
6214
  return { head, prefix, scalar, point, pointBytes };
@@ -6022,11 +6217,11 @@ var require_edwards = __commonJS((exports) => {
6022
6217
  return getExtendedPublicKey(privKey).pointBytes;
6023
6218
  }
6024
6219
  function hashDomainToScalar(context = new Uint8Array, ...msgs) {
6025
- const msg = ut.concatBytes(...msgs);
6026
- return modN_LE(cHash(domain(msg, (0, utils_js_1.ensureBytes)("context", context), !!prehash)));
6220
+ const msg = (0, utils_ts_1.concatBytes)(...msgs);
6221
+ return modN_LE(cHash(domain(msg, (0, utils_ts_1.ensureBytes)("context", context), !!prehash)));
6027
6222
  }
6028
6223
  function sign(msg, privKey, options = {}) {
6029
- msg = (0, utils_js_1.ensureBytes)("message", msg);
6224
+ msg = (0, utils_ts_1.ensureBytes)("message", msg);
6030
6225
  if (prehash)
6031
6226
  msg = prehash(msg);
6032
6227
  const { prefix, scalar, pointBytes } = getExtendedPublicKey(privKey);
@@ -6034,22 +6229,22 @@ var require_edwards = __commonJS((exports) => {
6034
6229
  const R = G.multiply(r).toRawBytes();
6035
6230
  const k = hashDomainToScalar(options.context, R, pointBytes, msg);
6036
6231
  const s = modN(r + k * scalar);
6037
- ut.aInRange("signature.s", s, _0n, CURVE_ORDER);
6038
- const res = ut.concatBytes(R, ut.numberToBytesLE(s, Fp.BYTES));
6039
- return (0, utils_js_1.ensureBytes)("result", res, Fp.BYTES * 2);
6232
+ (0, utils_ts_1.aInRange)("signature.s", s, _0n, CURVE_ORDER);
6233
+ const res = (0, utils_ts_1.concatBytes)(R, (0, utils_ts_1.numberToBytesLE)(s, Fp.BYTES));
6234
+ return (0, utils_ts_1.ensureBytes)("result", res, Fp.BYTES * 2);
6040
6235
  }
6041
6236
  const verifyOpts = VERIFY_DEFAULT;
6042
6237
  function verify(sig, msg, publicKey, options = verifyOpts) {
6043
6238
  const { context, zip215 } = options;
6044
6239
  const len = Fp.BYTES;
6045
- sig = (0, utils_js_1.ensureBytes)("signature", sig, 2 * len);
6046
- msg = (0, utils_js_1.ensureBytes)("message", msg);
6047
- publicKey = (0, utils_js_1.ensureBytes)("publicKey", publicKey, len);
6240
+ sig = (0, utils_ts_1.ensureBytes)("signature", sig, 2 * len);
6241
+ msg = (0, utils_ts_1.ensureBytes)("message", msg);
6242
+ publicKey = (0, utils_ts_1.ensureBytes)("publicKey", publicKey, len);
6048
6243
  if (zip215 !== undefined)
6049
- (0, utils_js_1.abool)("zip215", zip215);
6244
+ (0, utils_ts_1.abool)("zip215", zip215);
6050
6245
  if (prehash)
6051
6246
  msg = prehash(msg);
6052
- const s = ut.bytesToNumberLE(sig.slice(len, 2 * len));
6247
+ const s = (0, utils_ts_1.bytesToNumberLE)(sig.slice(len, 2 * len));
6053
6248
  let A, R, SB;
6054
6249
  try {
6055
6250
  A = Point.fromHex(publicKey, zip215);
@@ -6093,9 +6288,9 @@ var require_hash_to_curve = __commonJS((exports) => {
6093
6288
  exports.hash_to_field = hash_to_field;
6094
6289
  exports.isogenyMap = isogenyMap;
6095
6290
  exports.createHasher = createHasher;
6096
- var modular_js_1 = require_modular();
6097
- var utils_js_1 = require_utils5();
6098
- var os2ip = utils_js_1.bytesToNumberBE;
6291
+ var modular_ts_1 = require_modular();
6292
+ var utils_ts_1 = require_utils5();
6293
+ var os2ip = utils_ts_1.bytesToNumberBE;
6099
6294
  function i2osp(value, length) {
6100
6295
  anum(value);
6101
6296
  anum(length);
@@ -6120,42 +6315,42 @@ var require_hash_to_curve = __commonJS((exports) => {
6120
6315
  throw new Error("number expected");
6121
6316
  }
6122
6317
  function expand_message_xmd(msg, DST, lenInBytes, H) {
6123
- (0, utils_js_1.abytes)(msg);
6124
- (0, utils_js_1.abytes)(DST);
6318
+ (0, utils_ts_1.abytes)(msg);
6319
+ (0, utils_ts_1.abytes)(DST);
6125
6320
  anum(lenInBytes);
6126
6321
  if (DST.length > 255)
6127
- DST = H((0, utils_js_1.concatBytes)((0, utils_js_1.utf8ToBytes)("H2C-OVERSIZE-DST-"), DST));
6322
+ DST = H((0, utils_ts_1.concatBytes)((0, utils_ts_1.utf8ToBytes)("H2C-OVERSIZE-DST-"), DST));
6128
6323
  const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
6129
6324
  const ell = Math.ceil(lenInBytes / b_in_bytes);
6130
6325
  if (lenInBytes > 65535 || ell > 255)
6131
6326
  throw new Error("expand_message_xmd: invalid lenInBytes");
6132
- const DST_prime = (0, utils_js_1.concatBytes)(DST, i2osp(DST.length, 1));
6327
+ const DST_prime = (0, utils_ts_1.concatBytes)(DST, i2osp(DST.length, 1));
6133
6328
  const Z_pad = i2osp(0, r_in_bytes);
6134
6329
  const l_i_b_str = i2osp(lenInBytes, 2);
6135
6330
  const b = new Array(ell);
6136
- const b_0 = H((0, utils_js_1.concatBytes)(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
6137
- b[0] = H((0, utils_js_1.concatBytes)(b_0, i2osp(1, 1), DST_prime));
6331
+ const b_0 = H((0, utils_ts_1.concatBytes)(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
6332
+ b[0] = H((0, utils_ts_1.concatBytes)(b_0, i2osp(1, 1), DST_prime));
6138
6333
  for (let i = 1;i <= ell; i++) {
6139
6334
  const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
6140
- b[i] = H((0, utils_js_1.concatBytes)(...args));
6335
+ b[i] = H((0, utils_ts_1.concatBytes)(...args));
6141
6336
  }
6142
- const pseudo_random_bytes = (0, utils_js_1.concatBytes)(...b);
6337
+ const pseudo_random_bytes = (0, utils_ts_1.concatBytes)(...b);
6143
6338
  return pseudo_random_bytes.slice(0, lenInBytes);
6144
6339
  }
6145
6340
  function expand_message_xof(msg, DST, lenInBytes, k, H) {
6146
- (0, utils_js_1.abytes)(msg);
6147
- (0, utils_js_1.abytes)(DST);
6341
+ (0, utils_ts_1.abytes)(msg);
6342
+ (0, utils_ts_1.abytes)(DST);
6148
6343
  anum(lenInBytes);
6149
6344
  if (DST.length > 255) {
6150
6345
  const dkLen = Math.ceil(2 * k / 8);
6151
- DST = H.create({ dkLen }).update((0, utils_js_1.utf8ToBytes)("H2C-OVERSIZE-DST-")).update(DST).digest();
6346
+ DST = H.create({ dkLen }).update((0, utils_ts_1.utf8ToBytes)("H2C-OVERSIZE-DST-")).update(DST).digest();
6152
6347
  }
6153
6348
  if (lenInBytes > 65535 || DST.length > 255)
6154
6349
  throw new Error("expand_message_xof: invalid lenInBytes");
6155
6350
  return H.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
6156
6351
  }
6157
6352
  function hash_to_field(msg, count, options) {
6158
- (0, utils_js_1.validateObject)(options, {
6353
+ (0, utils_ts_1.validateObject)(options, {
6159
6354
  DST: "stringOrUint8Array",
6160
6355
  p: "bigint",
6161
6356
  m: "isSafeInteger",
@@ -6163,9 +6358,9 @@ var require_hash_to_curve = __commonJS((exports) => {
6163
6358
  hash: "hash"
6164
6359
  });
6165
6360
  const { p, k, m, hash, expand, DST: _DST } = options;
6166
- (0, utils_js_1.abytes)(msg);
6361
+ (0, utils_ts_1.abytes)(msg);
6167
6362
  anum(count);
6168
- const DST = typeof _DST === "string" ? (0, utils_js_1.utf8ToBytes)(_DST) : _DST;
6363
+ const DST = typeof _DST === "string" ? (0, utils_ts_1.utf8ToBytes)(_DST) : _DST;
6169
6364
  const log2p = p.toString(2).length;
6170
6365
  const L = Math.ceil((log2p + k) / 8);
6171
6366
  const len_in_bytes = count * m * L;
@@ -6185,7 +6380,7 @@ var require_hash_to_curve = __commonJS((exports) => {
6185
6380
  for (let j = 0;j < m; j++) {
6186
6381
  const elm_offset = L * (j + i * m);
6187
6382
  const tv = prb.subarray(elm_offset, elm_offset + L);
6188
- e[j] = (0, modular_js_1.mod)(os2ip(tv), p);
6383
+ e[j] = (0, modular_ts_1.mod)(os2ip(tv), p);
6189
6384
  }
6190
6385
  u[i] = e;
6191
6386
  }
@@ -6195,6 +6390,8 @@ var require_hash_to_curve = __commonJS((exports) => {
6195
6390
  const COEFF = map.map((i) => Array.from(i).reverse());
6196
6391
  return (x, y) => {
6197
6392
  const [xNum, xDen, yNum, yDen] = COEFF.map((val) => val.reduce((acc, i) => field.add(field.mul(acc, x), i)));
6393
+ if (field.is0(xDen) || field.is0(yDen))
6394
+ throw new Error("bad point: ZERO");
6198
6395
  x = field.div(xNum, xDen);
6199
6396
  y = field.mul(y, field.div(yNum, yDen));
6200
6397
  return { x, y };
@@ -6237,12 +6434,12 @@ var require_montgomery = __commonJS((exports) => {
6237
6434
  Object.defineProperty(exports, "__esModule", { value: true });
6238
6435
  exports.montgomery = montgomery;
6239
6436
  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
6240
- var modular_js_1 = require_modular();
6241
- var utils_js_1 = require_utils5();
6437
+ var modular_ts_1 = require_modular();
6438
+ var utils_ts_1 = require_utils5();
6242
6439
  var _0n = BigInt(0);
6243
6440
  var _1n = BigInt(1);
6244
6441
  function validateOpts(curve) {
6245
- (0, utils_js_1.validateObject)(curve, {
6442
+ (0, utils_ts_1.validateObject)(curve, {
6246
6443
  a: "bigint"
6247
6444
  }, {
6248
6445
  montgomeryBits: "isSafeInteger",
@@ -6257,12 +6454,12 @@ var require_montgomery = __commonJS((exports) => {
6257
6454
  function montgomery(curveDef) {
6258
6455
  const CURVE = validateOpts(curveDef);
6259
6456
  const { P } = CURVE;
6260
- const modP = (n) => (0, modular_js_1.mod)(n, P);
6457
+ const modP = (n) => (0, modular_ts_1.mod)(n, P);
6261
6458
  const montgomeryBits = CURVE.montgomeryBits;
6262
6459
  const montgomeryBytes = Math.ceil(montgomeryBits / 8);
6263
6460
  const fieldLen = CURVE.nByteLength;
6264
6461
  const adjustScalarBytes = CURVE.adjustScalarBytes || ((bytes) => bytes);
6265
- const powPminus2 = CURVE.powPminus2 || ((x) => (0, modular_js_1.pow)(x, P - BigInt(2), P));
6462
+ const powPminus2 = CURVE.powPminus2 || ((x) => (0, modular_ts_1.pow)(x, P - BigInt(2), P));
6266
6463
  function cswap(swap, x_2, x_3) {
6267
6464
  const dummy = modP(swap * (x_2 - x_3));
6268
6465
  x_2 = modP(x_2 - dummy);
@@ -6271,8 +6468,8 @@ var require_montgomery = __commonJS((exports) => {
6271
6468
  }
6272
6469
  const a24 = (CURVE.a - BigInt(2)) / BigInt(4);
6273
6470
  function montgomeryLadder(u, scalar) {
6274
- (0, utils_js_1.aInRange)("u", u, _0n, P);
6275
- (0, utils_js_1.aInRange)("scalar", scalar, _0n, P);
6471
+ (0, utils_ts_1.aInRange)("u", u, _0n, P);
6472
+ (0, utils_ts_1.aInRange)("scalar", scalar, _0n, P);
6276
6473
  const k = scalar;
6277
6474
  const x_1 = u;
6278
6475
  let x_2 = _1n;
@@ -6317,22 +6514,22 @@ var require_montgomery = __commonJS((exports) => {
6317
6514
  return modP(x_2 * z2);
6318
6515
  }
6319
6516
  function encodeUCoordinate(u) {
6320
- return (0, utils_js_1.numberToBytesLE)(modP(u), montgomeryBytes);
6517
+ return (0, utils_ts_1.numberToBytesLE)(modP(u), montgomeryBytes);
6321
6518
  }
6322
6519
  function decodeUCoordinate(uEnc) {
6323
- const u = (0, utils_js_1.ensureBytes)("u coordinate", uEnc, montgomeryBytes);
6520
+ const u = (0, utils_ts_1.ensureBytes)("u coordinate", uEnc, montgomeryBytes);
6324
6521
  if (fieldLen === 32)
6325
6522
  u[31] &= 127;
6326
- return (0, utils_js_1.bytesToNumberLE)(u);
6523
+ return (0, utils_ts_1.bytesToNumberLE)(u);
6327
6524
  }
6328
6525
  function decodeScalar(n) {
6329
- const bytes = (0, utils_js_1.ensureBytes)("scalar", n);
6526
+ const bytes = (0, utils_ts_1.ensureBytes)("scalar", n);
6330
6527
  const len = bytes.length;
6331
6528
  if (len !== montgomeryBytes && len !== fieldLen) {
6332
6529
  let valid = "" + montgomeryBytes + " or " + fieldLen;
6333
6530
  throw new Error("invalid scalar, expected " + valid + " bytes, got " + len);
6334
6531
  }
6335
- return (0, utils_js_1.bytesToNumberLE)(adjustScalarBytes(bytes));
6532
+ return (0, utils_ts_1.bytesToNumberLE)(adjustScalarBytes(bytes));
6336
6533
  }
6337
6534
  function scalarMult(scalar, u) {
6338
6535
  const pointU = decodeUCoordinate(u);
@@ -6364,14 +6561,14 @@ var require_ed25519 = __commonJS((exports) => {
6364
6561
  exports.edwardsToMontgomeryPub = edwardsToMontgomeryPub;
6365
6562
  exports.edwardsToMontgomeryPriv = edwardsToMontgomeryPriv;
6366
6563
  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
6367
- var sha512_1 = require_sha512();
6564
+ var sha2_1 = require_sha2();
6368
6565
  var utils_1 = require_utils4();
6369
- var curve_js_1 = require_curve();
6370
- var edwards_js_1 = require_edwards();
6371
- var hash_to_curve_js_1 = require_hash_to_curve();
6372
- var modular_js_1 = require_modular();
6373
- var montgomery_js_1 = require_montgomery();
6374
- var utils_js_1 = require_utils5();
6566
+ var curve_ts_1 = require_curve();
6567
+ var edwards_ts_1 = require_edwards();
6568
+ var hash_to_curve_ts_1 = require_hash_to_curve();
6569
+ var modular_ts_1 = require_modular();
6570
+ var montgomery_ts_1 = require_montgomery();
6571
+ var utils_ts_1 = require_utils5();
6375
6572
  var ED25519_P = BigInt("57896044618658097711785492504343953926634992332820282019728792003956564819949");
6376
6573
  var ED25519_SQRT_M1 = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
6377
6574
  var _0n = BigInt(0);
@@ -6385,16 +6582,16 @@ var require_ed25519 = __commonJS((exports) => {
6385
6582
  const P = ED25519_P;
6386
6583
  const x2 = x * x % P;
6387
6584
  const b2 = x2 * x % P;
6388
- const b4 = (0, modular_js_1.pow2)(b2, _2n, P) * b2 % P;
6389
- const b5 = (0, modular_js_1.pow2)(b4, _1n, P) * x % P;
6390
- const b10 = (0, modular_js_1.pow2)(b5, _5n, P) * b5 % P;
6391
- const b20 = (0, modular_js_1.pow2)(b10, _10n, P) * b10 % P;
6392
- const b40 = (0, modular_js_1.pow2)(b20, _20n, P) * b20 % P;
6393
- const b80 = (0, modular_js_1.pow2)(b40, _40n, P) * b40 % P;
6394
- const b160 = (0, modular_js_1.pow2)(b80, _80n, P) * b80 % P;
6395
- const b240 = (0, modular_js_1.pow2)(b160, _80n, P) * b80 % P;
6396
- const b250 = (0, modular_js_1.pow2)(b240, _10n, P) * b10 % P;
6397
- const pow_p_5_8 = (0, modular_js_1.pow2)(b250, _2n, P) * x % P;
6585
+ const b4 = (0, modular_ts_1.pow2)(b2, _2n, P) * b2 % P;
6586
+ const b5 = (0, modular_ts_1.pow2)(b4, _1n, P) * x % P;
6587
+ const b10 = (0, modular_ts_1.pow2)(b5, _5n, P) * b5 % P;
6588
+ const b20 = (0, modular_ts_1.pow2)(b10, _10n, P) * b10 % P;
6589
+ const b40 = (0, modular_ts_1.pow2)(b20, _20n, P) * b20 % P;
6590
+ const b80 = (0, modular_ts_1.pow2)(b40, _40n, P) * b40 % P;
6591
+ const b160 = (0, modular_ts_1.pow2)(b80, _80n, P) * b80 % P;
6592
+ const b240 = (0, modular_ts_1.pow2)(b160, _80n, P) * b80 % P;
6593
+ const b250 = (0, modular_ts_1.pow2)(b240, _10n, P) * b10 % P;
6594
+ const pow_p_5_8 = (0, modular_ts_1.pow2)(b250, _2n, P) * x % P;
6398
6595
  return { pow_p_5_8, b2 };
6399
6596
  }
6400
6597
  function adjustScalarBytes(bytes) {
@@ -6405,22 +6602,22 @@ var require_ed25519 = __commonJS((exports) => {
6405
6602
  }
6406
6603
  function uvRatio(u, v) {
6407
6604
  const P = ED25519_P;
6408
- const v3 = (0, modular_js_1.mod)(v * v * v, P);
6409
- const v7 = (0, modular_js_1.mod)(v3 * v3 * v, P);
6605
+ const v3 = (0, modular_ts_1.mod)(v * v * v, P);
6606
+ const v7 = (0, modular_ts_1.mod)(v3 * v3 * v, P);
6410
6607
  const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
6411
- let x = (0, modular_js_1.mod)(u * v3 * pow, P);
6412
- const vx2 = (0, modular_js_1.mod)(v * x * x, P);
6608
+ let x = (0, modular_ts_1.mod)(u * v3 * pow, P);
6609
+ const vx2 = (0, modular_ts_1.mod)(v * x * x, P);
6413
6610
  const root1 = x;
6414
- const root2 = (0, modular_js_1.mod)(x * ED25519_SQRT_M1, P);
6611
+ const root2 = (0, modular_ts_1.mod)(x * ED25519_SQRT_M1, P);
6415
6612
  const useRoot1 = vx2 === u;
6416
- const useRoot2 = vx2 === (0, modular_js_1.mod)(-u, P);
6417
- const noRoot = vx2 === (0, modular_js_1.mod)(-u * ED25519_SQRT_M1, P);
6613
+ const useRoot2 = vx2 === (0, modular_ts_1.mod)(-u, P);
6614
+ const noRoot = vx2 === (0, modular_ts_1.mod)(-u * ED25519_SQRT_M1, P);
6418
6615
  if (useRoot1)
6419
6616
  x = root1;
6420
6617
  if (useRoot2 || noRoot)
6421
6618
  x = root2;
6422
- if ((0, modular_js_1.isNegativeLE)(x, P))
6423
- x = (0, modular_js_1.mod)(-x, P);
6619
+ if ((0, modular_ts_1.isNegativeLE)(x, P))
6620
+ x = (0, modular_ts_1.mod)(-x, P);
6424
6621
  return { isValid: useRoot1 || useRoot2, value: x };
6425
6622
  }
6426
6623
  exports.ED25519_TORSION_SUBGROUP = [
@@ -6433,35 +6630,35 @@ var require_ed25519 = __commonJS((exports) => {
6433
6630
  "0000000000000000000000000000000000000000000000000000000000000000",
6434
6631
  "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa"
6435
6632
  ];
6436
- var Fp = /* @__PURE__ */ (() => (0, modular_js_1.Field)(ED25519_P, undefined, true))();
6633
+ var Fp = /* @__PURE__ */ (() => (0, modular_ts_1.Field)(ED25519_P, undefined, true))();
6437
6634
  var ed25519Defaults = /* @__PURE__ */ (() => ({
6438
- a: BigInt(-1),
6635
+ a: Fp.create(BigInt(-1)),
6439
6636
  d: BigInt("37095705934669439343138083508754565189542113879843219016388785533085940283555"),
6440
6637
  Fp,
6441
6638
  n: BigInt("7237005577332262213973186563042994240857116359379907606001950938285454250989"),
6442
6639
  h: _8n,
6443
6640
  Gx: BigInt("15112221349535400772501151409588531511454012693041857206046113283949847762202"),
6444
6641
  Gy: BigInt("46316835694926478169428394003475163141307993866256225615783033603165251855960"),
6445
- hash: sha512_1.sha512,
6642
+ hash: sha2_1.sha512,
6446
6643
  randomBytes: utils_1.randomBytes,
6447
6644
  adjustScalarBytes,
6448
6645
  uvRatio
6449
6646
  }))();
6450
- exports.ed25519 = (() => (0, edwards_js_1.twistedEdwards)(ed25519Defaults))();
6647
+ exports.ed25519 = (() => (0, edwards_ts_1.twistedEdwards)(ed25519Defaults))();
6451
6648
  function ed25519_domain(data, ctx, phflag) {
6452
6649
  if (ctx.length > 255)
6453
6650
  throw new Error("Context is too big");
6454
6651
  return (0, utils_1.concatBytes)((0, utils_1.utf8ToBytes)("SigEd25519 no Ed25519 collisions"), new Uint8Array([phflag ? 1 : 0, ctx.length]), ctx, data);
6455
6652
  }
6456
- exports.ed25519ctx = (() => (0, edwards_js_1.twistedEdwards)({
6653
+ exports.ed25519ctx = (() => (0, edwards_ts_1.twistedEdwards)({
6457
6654
  ...ed25519Defaults,
6458
6655
  domain: ed25519_domain
6459
6656
  }))();
6460
- exports.ed25519ph = (() => (0, edwards_js_1.twistedEdwards)(Object.assign({}, ed25519Defaults, {
6657
+ exports.ed25519ph = (() => (0, edwards_ts_1.twistedEdwards)(Object.assign({}, ed25519Defaults, {
6461
6658
  domain: ed25519_domain,
6462
- prehash: sha512_1.sha512
6659
+ prehash: sha2_1.sha512
6463
6660
  })))();
6464
- exports.x25519 = (() => (0, montgomery_js_1.montgomery)({
6661
+ exports.x25519 = (() => (0, montgomery_ts_1.montgomery)({
6465
6662
  P: ED25519_P,
6466
6663
  a: BigInt(486662),
6467
6664
  montgomeryBits: 255,
@@ -6470,7 +6667,7 @@ var require_ed25519 = __commonJS((exports) => {
6470
6667
  powPminus2: (x) => {
6471
6668
  const P = ED25519_P;
6472
6669
  const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x);
6473
- return (0, modular_js_1.mod)((0, modular_js_1.pow2)(pow_p_5_8, _3n, P) * b2, P);
6670
+ return (0, modular_ts_1.mod)((0, modular_ts_1.pow2)(pow_p_5_8, _3n, P) * b2, P);
6474
6671
  },
6475
6672
  adjustScalarBytes,
6476
6673
  randomBytes: utils_1.randomBytes
@@ -6531,7 +6728,7 @@ var require_ed25519 = __commonJS((exports) => {
6531
6728
  y = Fp.cmov(y, Fp.neg(y), e3 !== e4);
6532
6729
  return { xMn: xn, xMd: xd, yMn: y, yMd: _1n };
6533
6730
  }
6534
- var ELL2_C1_EDWARDS = /* @__PURE__ */ (() => (0, modular_js_1.FpSqrtEven)(Fp, Fp.neg(BigInt(486664))))();
6731
+ var ELL2_C1_EDWARDS = /* @__PURE__ */ (() => (0, modular_ts_1.FpSqrtEven)(Fp, Fp.neg(BigInt(486664))))();
6535
6732
  function map_to_curve_elligator2_edwards25519(u) {
6536
6733
  const { xMn, xMd, yMn, yMd } = map_to_curve_elligator2_curve25519(u);
6537
6734
  let xn = Fp.mul(xMn, yMd);
@@ -6548,18 +6745,18 @@ var require_ed25519 = __commonJS((exports) => {
6548
6745
  const inv = Fp.invertBatch([xd, yd]);
6549
6746
  return { x: Fp.mul(xn, inv[0]), y: Fp.mul(yn, inv[1]) };
6550
6747
  }
6551
- var htf = /* @__PURE__ */ (() => (0, hash_to_curve_js_1.createHasher)(exports.ed25519.ExtendedPoint, (scalars) => map_to_curve_elligator2_edwards25519(scalars[0]), {
6748
+ var htf = /* @__PURE__ */ (() => (0, hash_to_curve_ts_1.createHasher)(exports.ed25519.ExtendedPoint, (scalars) => map_to_curve_elligator2_edwards25519(scalars[0]), {
6552
6749
  DST: "edwards25519_XMD:SHA-512_ELL2_RO_",
6553
6750
  encodeDST: "edwards25519_XMD:SHA-512_ELL2_NU_",
6554
6751
  p: Fp.ORDER,
6555
6752
  m: 1,
6556
6753
  k: 128,
6557
6754
  expand: "xmd",
6558
- hash: sha512_1.sha512
6755
+ hash: sha2_1.sha512
6559
6756
  }))();
6560
6757
  exports.hashToCurve = (() => htf.hashToCurve)();
6561
6758
  exports.encodeToCurve = (() => htf.encodeToCurve)();
6562
- function assertRstPoint(other) {
6759
+ function aristp(other) {
6563
6760
  if (!(other instanceof RistPoint))
6564
6761
  throw new Error("RistrettoPoint expected");
6565
6762
  }
@@ -6570,7 +6767,7 @@ var require_ed25519 = __commonJS((exports) => {
6570
6767
  var D_MINUS_ONE_SQ = /* @__PURE__ */ BigInt("40440834346308536858101042469323190826248399146238708352240133220865137265952");
6571
6768
  var invertSqrt = (number) => uvRatio(_1n, number);
6572
6769
  var MAX_255B = /* @__PURE__ */ BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
6573
- var bytes255ToNumberLE = (bytes) => exports.ed25519.CURVE.Fp.create((0, utils_js_1.bytesToNumberLE)(bytes) & MAX_255B);
6770
+ var bytes255ToNumberLE = (bytes) => exports.ed25519.CURVE.Fp.create((0, utils_ts_1.bytesToNumberLE)(bytes) & MAX_255B);
6574
6771
  function calcElligatorRistrettoMap(r0) {
6575
6772
  const { d } = exports.ed25519.CURVE;
6576
6773
  const P = exports.ed25519.CURVE.Fp.ORDER;
@@ -6581,7 +6778,7 @@ var require_ed25519 = __commonJS((exports) => {
6581
6778
  const D = mod((c - d * r) * mod(r + d));
6582
6779
  let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D);
6583
6780
  let s_ = mod(s * r0);
6584
- if (!(0, modular_js_1.isNegativeLE)(s_, P))
6781
+ if (!(0, modular_ts_1.isNegativeLE)(s_, P))
6585
6782
  s_ = mod(-s_);
6586
6783
  if (!Ns_D_is_sq)
6587
6784
  s = s_;
@@ -6604,7 +6801,7 @@ var require_ed25519 = __commonJS((exports) => {
6604
6801
  return new RistPoint(exports.ed25519.ExtendedPoint.fromAffine(ap));
6605
6802
  }
6606
6803
  static hashToCurve(hex) {
6607
- hex = (0, utils_js_1.ensureBytes)("ristrettoHash", hex, 64);
6804
+ hex = (0, utils_ts_1.ensureBytes)("ristrettoHash", hex, 64);
6608
6805
  const r1 = bytes255ToNumberLE(hex.slice(0, 32));
6609
6806
  const R1 = calcElligatorRistrettoMap(r1);
6610
6807
  const r2 = bytes255ToNumberLE(hex.slice(32, 64));
@@ -6612,13 +6809,13 @@ var require_ed25519 = __commonJS((exports) => {
6612
6809
  return new RistPoint(R1.add(R2));
6613
6810
  }
6614
6811
  static fromHex(hex) {
6615
- hex = (0, utils_js_1.ensureBytes)("ristrettoHex", hex, 32);
6812
+ hex = (0, utils_ts_1.ensureBytes)("ristrettoHex", hex, 32);
6616
6813
  const { a, d } = exports.ed25519.CURVE;
6617
6814
  const P = exports.ed25519.CURVE.Fp.ORDER;
6618
6815
  const mod = exports.ed25519.CURVE.Fp.create;
6619
6816
  const emsg = "RistrettoPoint.fromHex: the hex is not valid encoding of RistrettoPoint";
6620
6817
  const s = bytes255ToNumberLE(hex);
6621
- if (!(0, utils_js_1.equalBytes)((0, utils_js_1.numberToBytesLE)(s, 32), hex) || (0, modular_js_1.isNegativeLE)(s, P))
6818
+ if (!(0, utils_ts_1.equalBytes)((0, utils_ts_1.numberToBytesLE)(s, 32), hex) || (0, modular_ts_1.isNegativeLE)(s, P))
6622
6819
  throw new Error(emsg);
6623
6820
  const s2 = mod(s * s);
6624
6821
  const u1 = mod(_1n + a * s2);
@@ -6630,17 +6827,17 @@ var require_ed25519 = __commonJS((exports) => {
6630
6827
  const Dx = mod(I * u2);
6631
6828
  const Dy = mod(I * Dx * v);
6632
6829
  let x = mod((s + s) * Dx);
6633
- if ((0, modular_js_1.isNegativeLE)(x, P))
6830
+ if ((0, modular_ts_1.isNegativeLE)(x, P))
6634
6831
  x = mod(-x);
6635
6832
  const y = mod(u1 * Dy);
6636
6833
  const t = mod(x * y);
6637
- if (!isValid2 || (0, modular_js_1.isNegativeLE)(t, P) || y === _0n)
6834
+ if (!isValid2 || (0, modular_ts_1.isNegativeLE)(t, P) || y === _0n)
6638
6835
  throw new Error(emsg);
6639
6836
  return new RistPoint(new exports.ed25519.ExtendedPoint(x, y, _1n, t));
6640
6837
  }
6641
6838
  static msm(points, scalars) {
6642
- const Fn = (0, modular_js_1.Field)(exports.ed25519.CURVE.n, exports.ed25519.CURVE.nBitLength);
6643
- return (0, curve_js_1.pippenger)(RistPoint, Fn, points, scalars);
6839
+ const Fn = (0, modular_ts_1.Field)(exports.ed25519.CURVE.n, exports.ed25519.CURVE.nBitLength);
6840
+ return (0, curve_ts_1.pippenger)(RistPoint, Fn, points, scalars);
6644
6841
  }
6645
6842
  toRawBytes() {
6646
6843
  let { ex: x, ey: y, ez: z2, et: t } = this.ep;
@@ -6654,7 +6851,7 @@ var require_ed25519 = __commonJS((exports) => {
6654
6851
  const D2 = mod(invsqrt * u2);
6655
6852
  const zInv = mod(D1 * D2 * t);
6656
6853
  let D;
6657
- if ((0, modular_js_1.isNegativeLE)(t * zInv, P)) {
6854
+ if ((0, modular_ts_1.isNegativeLE)(t * zInv, P)) {
6658
6855
  let _x = mod(y * SQRT_M1);
6659
6856
  let _y = mod(x * SQRT_M1);
6660
6857
  x = _x;
@@ -6663,21 +6860,21 @@ var require_ed25519 = __commonJS((exports) => {
6663
6860
  } else {
6664
6861
  D = D2;
6665
6862
  }
6666
- if ((0, modular_js_1.isNegativeLE)(x * zInv, P))
6863
+ if ((0, modular_ts_1.isNegativeLE)(x * zInv, P))
6667
6864
  y = mod(-y);
6668
6865
  let s = mod((z2 - y) * D);
6669
- if ((0, modular_js_1.isNegativeLE)(s, P))
6866
+ if ((0, modular_ts_1.isNegativeLE)(s, P))
6670
6867
  s = mod(-s);
6671
- return (0, utils_js_1.numberToBytesLE)(s, 32);
6868
+ return (0, utils_ts_1.numberToBytesLE)(s, 32);
6672
6869
  }
6673
6870
  toHex() {
6674
- return (0, utils_js_1.bytesToHex)(this.toRawBytes());
6871
+ return (0, utils_ts_1.bytesToHex)(this.toRawBytes());
6675
6872
  }
6676
6873
  toString() {
6677
6874
  return this.toHex();
6678
6875
  }
6679
6876
  equals(other) {
6680
- assertRstPoint(other);
6877
+ aristp(other);
6681
6878
  const { ex: X1, ey: Y1 } = this.ep;
6682
6879
  const { ex: X2, ey: Y2 } = other.ep;
6683
6880
  const mod = exports.ed25519.CURVE.Fp.create;
@@ -6686,11 +6883,11 @@ var require_ed25519 = __commonJS((exports) => {
6686
6883
  return one || two;
6687
6884
  }
6688
6885
  add(other) {
6689
- assertRstPoint(other);
6886
+ aristp(other);
6690
6887
  return new RistPoint(this.ep.add(other.ep));
6691
6888
  }
6692
6889
  subtract(other) {
6693
- assertRstPoint(other);
6890
+ aristp(other);
6694
6891
  return new RistPoint(this.ep.subtract(other.ep));
6695
6892
  }
6696
6893
  multiply(scalar) {
@@ -6716,7 +6913,7 @@ var require_ed25519 = __commonJS((exports) => {
6716
6913
  var hashToRistretto255 = (msg, options) => {
6717
6914
  const d = options.DST;
6718
6915
  const DST = typeof d === "string" ? (0, utils_1.utf8ToBytes)(d) : d;
6719
- const uniform_bytes = (0, hash_to_curve_js_1.expand_message_xmd)(msg, DST, 64, sha512_1.sha512);
6916
+ const uniform_bytes = (0, hash_to_curve_ts_1.expand_message_xmd)(msg, DST, 64, sha2_1.sha512);
6720
6917
  const P = RistPoint.hashToCurve(uniform_bytes);
6721
6918
  return P;
6722
6919
  };
@@ -6724,193 +6921,20 @@ var require_ed25519 = __commonJS((exports) => {
6724
6921
  exports.hash_to_ristretto255 = exports.hashToRistretto255;
6725
6922
  });
6726
6923
 
6727
- // ../../node_modules/@noble/hashes/sha256.js
6728
- var require_sha256 = __commonJS((exports) => {
6729
- Object.defineProperty(exports, "__esModule", { value: true });
6730
- exports.sha224 = exports.sha256 = exports.SHA256 = undefined;
6731
- var _md_js_1 = require__md();
6732
- var utils_js_1 = require_utils4();
6733
- var SHA256_K = /* @__PURE__ */ new Uint32Array([
6734
- 1116352408,
6735
- 1899447441,
6736
- 3049323471,
6737
- 3921009573,
6738
- 961987163,
6739
- 1508970993,
6740
- 2453635748,
6741
- 2870763221,
6742
- 3624381080,
6743
- 310598401,
6744
- 607225278,
6745
- 1426881987,
6746
- 1925078388,
6747
- 2162078206,
6748
- 2614888103,
6749
- 3248222580,
6750
- 3835390401,
6751
- 4022224774,
6752
- 264347078,
6753
- 604807628,
6754
- 770255983,
6755
- 1249150122,
6756
- 1555081692,
6757
- 1996064986,
6758
- 2554220882,
6759
- 2821834349,
6760
- 2952996808,
6761
- 3210313671,
6762
- 3336571891,
6763
- 3584528711,
6764
- 113926993,
6765
- 338241895,
6766
- 666307205,
6767
- 773529912,
6768
- 1294757372,
6769
- 1396182291,
6770
- 1695183700,
6771
- 1986661051,
6772
- 2177026350,
6773
- 2456956037,
6774
- 2730485921,
6775
- 2820302411,
6776
- 3259730800,
6777
- 3345764771,
6778
- 3516065817,
6779
- 3600352804,
6780
- 4094571909,
6781
- 275423344,
6782
- 430227734,
6783
- 506948616,
6784
- 659060556,
6785
- 883997877,
6786
- 958139571,
6787
- 1322822218,
6788
- 1537002063,
6789
- 1747873779,
6790
- 1955562222,
6791
- 2024104815,
6792
- 2227730452,
6793
- 2361852424,
6794
- 2428436474,
6795
- 2756734187,
6796
- 3204031479,
6797
- 3329325298
6798
- ]);
6799
- var SHA256_IV = /* @__PURE__ */ new Uint32Array([
6800
- 1779033703,
6801
- 3144134277,
6802
- 1013904242,
6803
- 2773480762,
6804
- 1359893119,
6805
- 2600822924,
6806
- 528734635,
6807
- 1541459225
6808
- ]);
6809
- var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
6810
-
6811
- class SHA256 extends _md_js_1.HashMD {
6812
- constructor() {
6813
- super(64, 32, 8, false);
6814
- this.A = SHA256_IV[0] | 0;
6815
- this.B = SHA256_IV[1] | 0;
6816
- this.C = SHA256_IV[2] | 0;
6817
- this.D = SHA256_IV[3] | 0;
6818
- this.E = SHA256_IV[4] | 0;
6819
- this.F = SHA256_IV[5] | 0;
6820
- this.G = SHA256_IV[6] | 0;
6821
- this.H = SHA256_IV[7] | 0;
6822
- }
6823
- get() {
6824
- const { A, B, C, D, E, F, G, H } = this;
6825
- return [A, B, C, D, E, F, G, H];
6826
- }
6827
- set(A, B, C, D, E, F, G, H) {
6828
- this.A = A | 0;
6829
- this.B = B | 0;
6830
- this.C = C | 0;
6831
- this.D = D | 0;
6832
- this.E = E | 0;
6833
- this.F = F | 0;
6834
- this.G = G | 0;
6835
- this.H = H | 0;
6836
- }
6837
- process(view, offset) {
6838
- for (let i = 0;i < 16; i++, offset += 4)
6839
- SHA256_W[i] = view.getUint32(offset, false);
6840
- for (let i = 16;i < 64; i++) {
6841
- const W15 = SHA256_W[i - 15];
6842
- const W2 = SHA256_W[i - 2];
6843
- const s0 = (0, utils_js_1.rotr)(W15, 7) ^ (0, utils_js_1.rotr)(W15, 18) ^ W15 >>> 3;
6844
- const s1 = (0, utils_js_1.rotr)(W2, 17) ^ (0, utils_js_1.rotr)(W2, 19) ^ W2 >>> 10;
6845
- SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
6846
- }
6847
- let { A, B, C, D, E, F, G, H } = this;
6848
- for (let i = 0;i < 64; i++) {
6849
- const sigma1 = (0, utils_js_1.rotr)(E, 6) ^ (0, utils_js_1.rotr)(E, 11) ^ (0, utils_js_1.rotr)(E, 25);
6850
- const T1 = H + sigma1 + (0, _md_js_1.Chi)(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
6851
- const sigma0 = (0, utils_js_1.rotr)(A, 2) ^ (0, utils_js_1.rotr)(A, 13) ^ (0, utils_js_1.rotr)(A, 22);
6852
- const T2 = sigma0 + (0, _md_js_1.Maj)(A, B, C) | 0;
6853
- H = G;
6854
- G = F;
6855
- F = E;
6856
- E = D + T1 | 0;
6857
- D = C;
6858
- C = B;
6859
- B = A;
6860
- A = T1 + T2 | 0;
6861
- }
6862
- A = A + this.A | 0;
6863
- B = B + this.B | 0;
6864
- C = C + this.C | 0;
6865
- D = D + this.D | 0;
6866
- E = E + this.E | 0;
6867
- F = F + this.F | 0;
6868
- G = G + this.G | 0;
6869
- H = H + this.H | 0;
6870
- this.set(A, B, C, D, E, F, G, H);
6871
- }
6872
- roundClean() {
6873
- SHA256_W.fill(0);
6874
- }
6875
- destroy() {
6876
- this.set(0, 0, 0, 0, 0, 0, 0, 0);
6877
- this.buffer.fill(0);
6878
- }
6879
- }
6880
- exports.SHA256 = SHA256;
6881
-
6882
- class SHA224 extends SHA256 {
6883
- constructor() {
6884
- super();
6885
- this.A = 3238371032 | 0;
6886
- this.B = 914150663 | 0;
6887
- this.C = 812702999 | 0;
6888
- this.D = 4144912697 | 0;
6889
- this.E = 4290775857 | 0;
6890
- this.F = 1750603025 | 0;
6891
- this.G = 1694076839 | 0;
6892
- this.H = 3204075428 | 0;
6893
- this.outputLen = 28;
6894
- }
6895
- }
6896
- exports.sha256 = (0, utils_js_1.wrapConstructor)(() => new SHA256);
6897
- exports.sha224 = (0, utils_js_1.wrapConstructor)(() => new SHA224);
6898
- });
6899
-
6900
6924
  // ../../node_modules/@noble/hashes/hmac.js
6901
6925
  var require_hmac = __commonJS((exports) => {
6902
6926
  Object.defineProperty(exports, "__esModule", { value: true });
6903
6927
  exports.hmac = exports.HMAC = undefined;
6904
- var _assert_js_1 = require__assert2();
6905
- var utils_js_1 = require_utils4();
6928
+ var _assert_ts_1 = require__assert2();
6929
+ var utils_ts_1 = require_utils4();
6906
6930
 
6907
- class HMAC extends utils_js_1.Hash {
6931
+ class HMAC extends utils_ts_1.Hash {
6908
6932
  constructor(hash, _key) {
6909
6933
  super();
6910
6934
  this.finished = false;
6911
6935
  this.destroyed = false;
6912
- (0, _assert_js_1.ahash)(hash);
6913
- const key = (0, utils_js_1.toBytes)(_key);
6936
+ (0, _assert_ts_1.ahash)(hash);
6937
+ const key = (0, utils_ts_1.toBytes)(_key);
6914
6938
  this.iHash = hash.create();
6915
6939
  if (typeof this.iHash.update !== "function")
6916
6940
  throw new Error("Expected instance of class which extends utils.Hash");
@@ -6929,13 +6953,13 @@ var require_hmac = __commonJS((exports) => {
6929
6953
  pad.fill(0);
6930
6954
  }
6931
6955
  update(buf) {
6932
- (0, _assert_js_1.aexists)(this);
6956
+ (0, _assert_ts_1.aexists)(this);
6933
6957
  this.iHash.update(buf);
6934
6958
  return this;
6935
6959
  }
6936
6960
  digestInto(out) {
6937
- (0, _assert_js_1.aexists)(this);
6938
- (0, _assert_js_1.abytes)(out, this.outputLen);
6961
+ (0, _assert_ts_1.aexists)(this);
6962
+ (0, _assert_ts_1.abytes)(out, this.outputLen);
6939
6963
  this.finished = true;
6940
6964
  this.iHash.digestInto(out);
6941
6965
  this.oHash.update(out);
@@ -6980,19 +7004,18 @@ var require_weierstrass = __commonJS((exports) => {
6980
7004
  exports.SWUFpSqrtRatio = SWUFpSqrtRatio;
6981
7005
  exports.mapToCurveSimpleSWU = mapToCurveSimpleSWU;
6982
7006
  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
6983
- var curve_js_1 = require_curve();
6984
- var modular_js_1 = require_modular();
6985
- var ut = require_utils5();
6986
- var utils_js_1 = require_utils5();
7007
+ var curve_ts_1 = require_curve();
7008
+ var modular_ts_1 = require_modular();
7009
+ var utils_ts_1 = require_utils5();
6987
7010
  function validateSigVerOpts(opts) {
6988
7011
  if (opts.lowS !== undefined)
6989
- (0, utils_js_1.abool)("lowS", opts.lowS);
7012
+ (0, utils_ts_1.abool)("lowS", opts.lowS);
6990
7013
  if (opts.prehash !== undefined)
6991
- (0, utils_js_1.abool)("prehash", opts.prehash);
7014
+ (0, utils_ts_1.abool)("prehash", opts.prehash);
6992
7015
  }
6993
7016
  function validatePointOpts(curve) {
6994
- const opts = (0, curve_js_1.validateBasic)(curve);
6995
- ut.validateObject(opts, {
7017
+ const opts = (0, curve_ts_1.validateBasic)(curve);
7018
+ (0, utils_ts_1.validateObject)(opts, {
6996
7019
  a: "field",
6997
7020
  b: "field"
6998
7021
  }, {
@@ -7015,7 +7038,6 @@ var require_weierstrass = __commonJS((exports) => {
7015
7038
  }
7016
7039
  return Object.freeze({ ...opts });
7017
7040
  }
7018
- var { bytesToNumberBE: b2n, hexToBytes: h2b } = ut;
7019
7041
 
7020
7042
  class DERErr extends Error {
7021
7043
  constructor(m = "") {
@@ -7033,11 +7055,11 @@ var require_weierstrass = __commonJS((exports) => {
7033
7055
  if (data.length & 1)
7034
7056
  throw new E("tlv.encode: unpadded data");
7035
7057
  const dataLen = data.length / 2;
7036
- const len = ut.numberToHexUnpadded(dataLen);
7058
+ const len = (0, utils_ts_1.numberToHexUnpadded)(dataLen);
7037
7059
  if (len.length / 2 & 128)
7038
7060
  throw new E("tlv.encode: long form length too big");
7039
- const lenLen = dataLen > 127 ? ut.numberToHexUnpadded(len.length / 2 | 128) : "";
7040
- const t = ut.numberToHexUnpadded(tag);
7061
+ const lenLen = dataLen > 127 ? (0, utils_ts_1.numberToHexUnpadded)(len.length / 2 | 128) : "";
7062
+ const t = (0, utils_ts_1.numberToHexUnpadded)(tag);
7041
7063
  return t + lenLen + len + data;
7042
7064
  },
7043
7065
  decode(tag, data) {
@@ -7080,7 +7102,7 @@ var require_weierstrass = __commonJS((exports) => {
7080
7102
  const { Err: E } = exports.DER;
7081
7103
  if (num < _0n)
7082
7104
  throw new E("integer: negative integers are not allowed");
7083
- let hex = ut.numberToHexUnpadded(num);
7105
+ let hex = (0, utils_ts_1.numberToHexUnpadded)(num);
7084
7106
  if (Number.parseInt(hex[0], 16) & 8)
7085
7107
  hex = "00" + hex;
7086
7108
  if (hex.length & 1)
@@ -7093,13 +7115,12 @@ var require_weierstrass = __commonJS((exports) => {
7093
7115
  throw new E("invalid signature integer: negative");
7094
7116
  if (data[0] === 0 && !(data[1] & 128))
7095
7117
  throw new E("invalid signature integer: unnecessary leading zero");
7096
- return b2n(data);
7118
+ return (0, utils_ts_1.bytesToNumberBE)(data);
7097
7119
  }
7098
7120
  },
7099
7121
  toSig(hex) {
7100
7122
  const { Err: E, _int: int, _tlv: tlv } = exports.DER;
7101
- const data = typeof hex === "string" ? h2b(hex) : hex;
7102
- ut.abytes(data);
7123
+ const data = (0, utils_ts_1.ensureBytes)("signature", hex);
7103
7124
  const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
7104
7125
  if (seqLeftBytes.length)
7105
7126
  throw new E("invalid signature: left bytes after parsing");
@@ -7125,10 +7146,10 @@ var require_weierstrass = __commonJS((exports) => {
7125
7146
  function weierstrassPoints(opts) {
7126
7147
  const CURVE = validatePointOpts(opts);
7127
7148
  const { Fp } = CURVE;
7128
- const Fn = (0, modular_js_1.Field)(CURVE.n, CURVE.nBitLength);
7149
+ const Fn = (0, modular_ts_1.Field)(CURVE.n, CURVE.nBitLength);
7129
7150
  const toBytes = CURVE.toBytes || ((_c, point, _isCompressed) => {
7130
7151
  const a = point.toAffine();
7131
- return ut.concatBytes(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
7152
+ return (0, utils_ts_1.concatBytes)(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
7132
7153
  });
7133
7154
  const fromBytes = CURVE.fromBytes || ((bytes) => {
7134
7155
  const tail = bytes.subarray(1);
@@ -7145,33 +7166,33 @@ var require_weierstrass = __commonJS((exports) => {
7145
7166
  if (!Fp.eql(Fp.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
7146
7167
  throw new Error("bad generator point: equation left != right");
7147
7168
  function isWithinCurveOrder(num) {
7148
- return ut.inRange(num, _1n, CURVE.n);
7169
+ return (0, utils_ts_1.inRange)(num, _1n, CURVE.n);
7149
7170
  }
7150
7171
  function normPrivateKeyToScalar(key) {
7151
7172
  const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
7152
7173
  if (lengths && typeof key !== "bigint") {
7153
- if (ut.isBytes(key))
7154
- key = ut.bytesToHex(key);
7174
+ if ((0, utils_ts_1.isBytes)(key))
7175
+ key = (0, utils_ts_1.bytesToHex)(key);
7155
7176
  if (typeof key !== "string" || !lengths.includes(key.length))
7156
7177
  throw new Error("invalid private key");
7157
7178
  key = key.padStart(nByteLength * 2, "0");
7158
7179
  }
7159
7180
  let num;
7160
7181
  try {
7161
- num = typeof key === "bigint" ? key : ut.bytesToNumberBE((0, utils_js_1.ensureBytes)("private key", key, nByteLength));
7182
+ num = typeof key === "bigint" ? key : (0, utils_ts_1.bytesToNumberBE)((0, utils_ts_1.ensureBytes)("private key", key, nByteLength));
7162
7183
  } catch (error) {
7163
7184
  throw new Error("invalid private key, expected hex or " + nByteLength + " bytes, got " + typeof key);
7164
7185
  }
7165
7186
  if (wrapPrivateKey)
7166
- num = (0, modular_js_1.mod)(num, N);
7167
- ut.aInRange("private key", num, _1n, N);
7187
+ num = (0, modular_ts_1.mod)(num, N);
7188
+ (0, utils_ts_1.aInRange)("private key", num, _1n, N);
7168
7189
  return num;
7169
7190
  }
7170
- function assertPrjPoint(other) {
7191
+ function aprjpoint(other) {
7171
7192
  if (!(other instanceof Point))
7172
7193
  throw new Error("ProjectivePoint expected");
7173
7194
  }
7174
- const toAffineMemo = (0, utils_js_1.memoized)((p, iz) => {
7195
+ const toAffineMemo = (0, utils_ts_1.memoized)((p, iz) => {
7175
7196
  const { px: x, py: y, pz: z2 } = p;
7176
7197
  if (Fp.eql(z2, Fp.ONE))
7177
7198
  return { x, y };
@@ -7187,7 +7208,7 @@ var require_weierstrass = __commonJS((exports) => {
7187
7208
  throw new Error("invZ was invalid");
7188
7209
  return { x: ax, y: ay };
7189
7210
  });
7190
- const assertValidMemo = (0, utils_js_1.memoized)((p) => {
7211
+ const assertValidMemo = (0, utils_ts_1.memoized)((p) => {
7191
7212
  if (p.is0()) {
7192
7213
  if (CURVE.allowInfinityPoint && !Fp.is0(p.py))
7193
7214
  return;
@@ -7207,15 +7228,15 @@ var require_weierstrass = __commonJS((exports) => {
7207
7228
 
7208
7229
  class Point {
7209
7230
  constructor(px, py, pz) {
7210
- this.px = px;
7211
- this.py = py;
7212
- this.pz = pz;
7213
7231
  if (px == null || !Fp.isValid(px))
7214
7232
  throw new Error("x required");
7215
7233
  if (py == null || !Fp.isValid(py))
7216
7234
  throw new Error("y required");
7217
7235
  if (pz == null || !Fp.isValid(pz))
7218
7236
  throw new Error("z required");
7237
+ this.px = px;
7238
+ this.py = py;
7239
+ this.pz = pz;
7219
7240
  Object.freeze(this);
7220
7241
  }
7221
7242
  static fromAffine(p) {
@@ -7240,7 +7261,7 @@ var require_weierstrass = __commonJS((exports) => {
7240
7261
  return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
7241
7262
  }
7242
7263
  static fromHex(hex) {
7243
- const P = Point.fromAffine(fromBytes((0, utils_js_1.ensureBytes)("pointHex", hex)));
7264
+ const P = Point.fromAffine(fromBytes((0, utils_ts_1.ensureBytes)("pointHex", hex)));
7244
7265
  P.assertValidity();
7245
7266
  return P;
7246
7267
  }
@@ -7248,7 +7269,7 @@ var require_weierstrass = __commonJS((exports) => {
7248
7269
  return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
7249
7270
  }
7250
7271
  static msm(points, scalars) {
7251
- return (0, curve_js_1.pippenger)(Point, Fn, points, scalars);
7272
+ return (0, curve_ts_1.pippenger)(Point, Fn, points, scalars);
7252
7273
  }
7253
7274
  _setWindowSize(windowSize) {
7254
7275
  wnaf.setWindowSize(this, windowSize);
@@ -7263,7 +7284,7 @@ var require_weierstrass = __commonJS((exports) => {
7263
7284
  throw new Error("Field doesn't support isOdd");
7264
7285
  }
7265
7286
  equals(other) {
7266
- assertPrjPoint(other);
7287
+ aprjpoint(other);
7267
7288
  const { px: X1, py: Y1, pz: Z1 } = this;
7268
7289
  const { px: X2, py: Y2, pz: Z2 } = other;
7269
7290
  const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
@@ -7312,7 +7333,7 @@ var require_weierstrass = __commonJS((exports) => {
7312
7333
  return new Point(X3, Y3, Z3);
7313
7334
  }
7314
7335
  add(other) {
7315
- assertPrjPoint(other);
7336
+ aprjpoint(other);
7316
7337
  const { px: X1, py: Y1, pz: Z1 } = this;
7317
7338
  const { px: X2, py: Y2, pz: Z2 } = other;
7318
7339
  let { ZERO: X3, ZERO: Y3, ZERO: Z3 } = Fp;
@@ -7371,7 +7392,7 @@ var require_weierstrass = __commonJS((exports) => {
7371
7392
  }
7372
7393
  multiplyUnsafe(sc) {
7373
7394
  const { endo, n: N } = CURVE;
7374
- ut.aInRange("scalar", sc, _0n, N);
7395
+ (0, utils_ts_1.aInRange)("scalar", sc, _0n, N);
7375
7396
  const I = Point.ZERO;
7376
7397
  if (sc === _0n)
7377
7398
  return I;
@@ -7401,7 +7422,7 @@ var require_weierstrass = __commonJS((exports) => {
7401
7422
  }
7402
7423
  multiply(scalar) {
7403
7424
  const { endo, n: N } = CURVE;
7404
- ut.aInRange("scalar", scalar, _1n, N);
7425
+ (0, utils_ts_1.aInRange)("scalar", scalar, _1n, N);
7405
7426
  let point, fake;
7406
7427
  if (endo) {
7407
7428
  const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
@@ -7445,19 +7466,19 @@ var require_weierstrass = __commonJS((exports) => {
7445
7466
  return this.multiplyUnsafe(CURVE.h);
7446
7467
  }
7447
7468
  toRawBytes(isCompressed = true) {
7448
- (0, utils_js_1.abool)("isCompressed", isCompressed);
7469
+ (0, utils_ts_1.abool)("isCompressed", isCompressed);
7449
7470
  this.assertValidity();
7450
7471
  return toBytes(Point, this, isCompressed);
7451
7472
  }
7452
7473
  toHex(isCompressed = true) {
7453
- (0, utils_js_1.abool)("isCompressed", isCompressed);
7454
- return ut.bytesToHex(this.toRawBytes(isCompressed));
7474
+ (0, utils_ts_1.abool)("isCompressed", isCompressed);
7475
+ return (0, utils_ts_1.bytesToHex)(this.toRawBytes(isCompressed));
7455
7476
  }
7456
7477
  }
7457
7478
  Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
7458
7479
  Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
7459
7480
  const _bits = CURVE.nBitLength;
7460
- const wnaf = (0, curve_js_1.wNAF)(Point, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
7481
+ const wnaf = (0, curve_ts_1.wNAF)(Point, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
7461
7482
  return {
7462
7483
  CURVE,
7463
7484
  ProjectivePoint: Point,
@@ -7467,8 +7488,8 @@ var require_weierstrass = __commonJS((exports) => {
7467
7488
  };
7468
7489
  }
7469
7490
  function validateOpts(curve) {
7470
- const opts = (0, curve_js_1.validateBasic)(curve);
7471
- ut.validateObject(opts, {
7491
+ const opts = (0, curve_ts_1.validateBasic)(curve);
7492
+ (0, utils_ts_1.validateObject)(opts, {
7472
7493
  hash: "hash",
7473
7494
  hmac: "function",
7474
7495
  randomBytes: "function"
@@ -7485,18 +7506,18 @@ var require_weierstrass = __commonJS((exports) => {
7485
7506
  const compressedLen = Fp.BYTES + 1;
7486
7507
  const uncompressedLen = 2 * Fp.BYTES + 1;
7487
7508
  function modN(a) {
7488
- return (0, modular_js_1.mod)(a, CURVE_ORDER);
7509
+ return (0, modular_ts_1.mod)(a, CURVE_ORDER);
7489
7510
  }
7490
7511
  function invN(a) {
7491
- return (0, modular_js_1.invert)(a, CURVE_ORDER);
7512
+ return (0, modular_ts_1.invert)(a, CURVE_ORDER);
7492
7513
  }
7493
7514
  const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
7494
7515
  ...CURVE,
7495
7516
  toBytes(_c, point, isCompressed) {
7496
7517
  const a = point.toAffine();
7497
7518
  const x = Fp.toBytes(a.x);
7498
- const cat = ut.concatBytes;
7499
- (0, utils_js_1.abool)("isCompressed", isCompressed);
7519
+ const cat = utils_ts_1.concatBytes;
7520
+ (0, utils_ts_1.abool)("isCompressed", isCompressed);
7500
7521
  if (isCompressed) {
7501
7522
  return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
7502
7523
  } else {
@@ -7508,8 +7529,8 @@ var require_weierstrass = __commonJS((exports) => {
7508
7529
  const head = bytes[0];
7509
7530
  const tail = bytes.subarray(1);
7510
7531
  if (len === compressedLen && (head === 2 || head === 3)) {
7511
- const x = ut.bytesToNumberBE(tail);
7512
- if (!ut.inRange(x, _1n, Fp.ORDER))
7532
+ const x = (0, utils_ts_1.bytesToNumberBE)(tail);
7533
+ if (!(0, utils_ts_1.inRange)(x, _1n, Fp.ORDER))
7513
7534
  throw new Error("Point is not on curve");
7514
7535
  const y2 = weierstrassEquation(x);
7515
7536
  let y;
@@ -7535,7 +7556,7 @@ var require_weierstrass = __commonJS((exports) => {
7535
7556
  }
7536
7557
  }
7537
7558
  });
7538
- const numToNByteStr = (num) => ut.bytesToHex(ut.numberToBytesBE(num, CURVE.nByteLength));
7559
+ const numToNByteHex = (num) => (0, utils_ts_1.bytesToHex)((0, utils_ts_1.numberToBytesBE)(num, CURVE.nByteLength));
7539
7560
  function isBiggerThanHalfOrder(number) {
7540
7561
  const HALF = CURVE_ORDER >> _1n;
7541
7562
  return number > HALF;
@@ -7543,41 +7564,41 @@ var require_weierstrass = __commonJS((exports) => {
7543
7564
  function normalizeS(s) {
7544
7565
  return isBiggerThanHalfOrder(s) ? modN(-s) : s;
7545
7566
  }
7546
- const slcNum = (b, from, to) => ut.bytesToNumberBE(b.slice(from, to));
7567
+ const slcNum = (b, from, to) => (0, utils_ts_1.bytesToNumberBE)(b.slice(from, to));
7547
7568
 
7548
7569
  class Signature {
7549
7570
  constructor(r, s, recovery) {
7571
+ (0, utils_ts_1.aInRange)("r", r, _1n, CURVE_ORDER);
7572
+ (0, utils_ts_1.aInRange)("s", s, _1n, CURVE_ORDER);
7550
7573
  this.r = r;
7551
7574
  this.s = s;
7552
- this.recovery = recovery;
7553
- this.assertValidity();
7575
+ if (recovery != null)
7576
+ this.recovery = recovery;
7577
+ Object.freeze(this);
7554
7578
  }
7555
7579
  static fromCompact(hex) {
7556
7580
  const l = CURVE.nByteLength;
7557
- hex = (0, utils_js_1.ensureBytes)("compactSignature", hex, l * 2);
7581
+ hex = (0, utils_ts_1.ensureBytes)("compactSignature", hex, l * 2);
7558
7582
  return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
7559
7583
  }
7560
7584
  static fromDER(hex) {
7561
- const { r, s } = exports.DER.toSig((0, utils_js_1.ensureBytes)("DER", hex));
7585
+ const { r, s } = exports.DER.toSig((0, utils_ts_1.ensureBytes)("DER", hex));
7562
7586
  return new Signature(r, s);
7563
7587
  }
7564
- assertValidity() {
7565
- ut.aInRange("r", this.r, _1n, CURVE_ORDER);
7566
- ut.aInRange("s", this.s, _1n, CURVE_ORDER);
7567
- }
7588
+ assertValidity() {}
7568
7589
  addRecoveryBit(recovery) {
7569
7590
  return new Signature(this.r, this.s, recovery);
7570
7591
  }
7571
7592
  recoverPublicKey(msgHash) {
7572
7593
  const { r, s, recovery: rec } = this;
7573
- const h = bits2int_modN((0, utils_js_1.ensureBytes)("msgHash", msgHash));
7594
+ const h = bits2int_modN((0, utils_ts_1.ensureBytes)("msgHash", msgHash));
7574
7595
  if (rec == null || ![0, 1, 2, 3].includes(rec))
7575
7596
  throw new Error("recovery id invalid");
7576
7597
  const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
7577
7598
  if (radj >= Fp.ORDER)
7578
7599
  throw new Error("recovery id 2 or 3 invalid");
7579
7600
  const prefix = (rec & 1) === 0 ? "02" : "03";
7580
- const R = Point.fromHex(prefix + numToNByteStr(radj));
7601
+ const R = Point.fromHex(prefix + numToNByteHex(radj));
7581
7602
  const ir = invN(radj);
7582
7603
  const u1 = modN(-h * ir);
7583
7604
  const u2 = modN(s * ir);
@@ -7594,16 +7615,16 @@ var require_weierstrass = __commonJS((exports) => {
7594
7615
  return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;
7595
7616
  }
7596
7617
  toDERRawBytes() {
7597
- return ut.hexToBytes(this.toDERHex());
7618
+ return (0, utils_ts_1.hexToBytes)(this.toDERHex());
7598
7619
  }
7599
7620
  toDERHex() {
7600
7621
  return exports.DER.hexFromSig({ r: this.r, s: this.s });
7601
7622
  }
7602
7623
  toCompactRawBytes() {
7603
- return ut.hexToBytes(this.toCompactHex());
7624
+ return (0, utils_ts_1.hexToBytes)(this.toCompactHex());
7604
7625
  }
7605
7626
  toCompactHex() {
7606
- return numToNByteStr(this.r) + numToNByteStr(this.s);
7627
+ return numToNByteHex(this.r) + numToNByteHex(this.s);
7607
7628
  }
7608
7629
  }
7609
7630
  const utils = {
@@ -7617,8 +7638,8 @@ var require_weierstrass = __commonJS((exports) => {
7617
7638
  },
7618
7639
  normPrivateKeyToScalar,
7619
7640
  randomPrivateKey: () => {
7620
- const length = (0, modular_js_1.getMinHashLength)(CURVE.n);
7621
- return (0, modular_js_1.mapHashToField)(CURVE.randomBytes(length), CURVE.n);
7641
+ const length = (0, modular_ts_1.getMinHashLength)(CURVE.n);
7642
+ return (0, modular_ts_1.mapHashToField)(CURVE.randomBytes(length), CURVE.n);
7622
7643
  },
7623
7644
  precompute(windowSize = 8, point = Point.BASE) {
7624
7645
  point._setWindowSize(windowSize);
@@ -7630,7 +7651,7 @@ var require_weierstrass = __commonJS((exports) => {
7630
7651
  return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
7631
7652
  }
7632
7653
  function isProbPub(item) {
7633
- const arr = ut.isBytes(item);
7654
+ const arr = (0, utils_ts_1.isBytes)(item);
7634
7655
  const str = typeof item === "string";
7635
7656
  const len = (arr || str) && item.length;
7636
7657
  if (arr)
@@ -7652,17 +7673,17 @@ var require_weierstrass = __commonJS((exports) => {
7652
7673
  const bits2int = CURVE.bits2int || function(bytes) {
7653
7674
  if (bytes.length > 8192)
7654
7675
  throw new Error("input is too large");
7655
- const num = ut.bytesToNumberBE(bytes);
7676
+ const num = (0, utils_ts_1.bytesToNumberBE)(bytes);
7656
7677
  const delta = bytes.length * 8 - CURVE.nBitLength;
7657
7678
  return delta > 0 ? num >> BigInt(delta) : num;
7658
7679
  };
7659
7680
  const bits2int_modN = CURVE.bits2int_modN || function(bytes) {
7660
7681
  return modN(bits2int(bytes));
7661
7682
  };
7662
- const ORDER_MASK = ut.bitMask(CURVE.nBitLength);
7683
+ const ORDER_MASK = (0, utils_ts_1.bitMask)(CURVE.nBitLength);
7663
7684
  function int2octets(num) {
7664
- ut.aInRange("num < 2^" + CURVE.nBitLength, num, _0n, ORDER_MASK);
7665
- return ut.numberToBytesBE(num, CURVE.nByteLength);
7685
+ (0, utils_ts_1.aInRange)("num < 2^" + CURVE.nBitLength, num, _0n, ORDER_MASK);
7686
+ return (0, utils_ts_1.numberToBytesBE)(num, CURVE.nByteLength);
7666
7687
  }
7667
7688
  function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
7668
7689
  if (["recovered", "canonical"].some((k) => (k in opts)))
@@ -7671,18 +7692,18 @@ var require_weierstrass = __commonJS((exports) => {
7671
7692
  let { lowS, prehash, extraEntropy: ent } = opts;
7672
7693
  if (lowS == null)
7673
7694
  lowS = true;
7674
- msgHash = (0, utils_js_1.ensureBytes)("msgHash", msgHash);
7695
+ msgHash = (0, utils_ts_1.ensureBytes)("msgHash", msgHash);
7675
7696
  validateSigVerOpts(opts);
7676
7697
  if (prehash)
7677
- msgHash = (0, utils_js_1.ensureBytes)("prehashed msgHash", hash(msgHash));
7698
+ msgHash = (0, utils_ts_1.ensureBytes)("prehashed msgHash", hash(msgHash));
7678
7699
  const h1int = bits2int_modN(msgHash);
7679
7700
  const d = normPrivateKeyToScalar(privateKey);
7680
7701
  const seedArgs = [int2octets(d), int2octets(h1int)];
7681
7702
  if (ent != null && ent !== false) {
7682
7703
  const e = ent === true ? randomBytes(Fp.BYTES) : ent;
7683
- seedArgs.push((0, utils_js_1.ensureBytes)("extraEntropy", e));
7704
+ seedArgs.push((0, utils_ts_1.ensureBytes)("extraEntropy", e));
7684
7705
  }
7685
- const seed = ut.concatBytes(...seedArgs);
7706
+ const seed = (0, utils_ts_1.concatBytes)(...seedArgs);
7686
7707
  const m = h1int;
7687
7708
  function k2sig(kBytes) {
7688
7709
  const k = bits2int(kBytes);
@@ -7711,21 +7732,21 @@ var require_weierstrass = __commonJS((exports) => {
7711
7732
  function sign(msgHash, privKey, opts = defaultSigOpts) {
7712
7733
  const { seed, k2sig } = prepSig(msgHash, privKey, opts);
7713
7734
  const C = CURVE;
7714
- const drbg = ut.createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
7735
+ const drbg = (0, utils_ts_1.createHmacDrbg)(C.hash.outputLen, C.nByteLength, C.hmac);
7715
7736
  return drbg(seed, k2sig);
7716
7737
  }
7717
7738
  Point.BASE._setWindowSize(8);
7718
7739
  function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
7719
7740
  const sg = signature;
7720
- msgHash = (0, utils_js_1.ensureBytes)("msgHash", msgHash);
7721
- publicKey = (0, utils_js_1.ensureBytes)("publicKey", publicKey);
7741
+ msgHash = (0, utils_ts_1.ensureBytes)("msgHash", msgHash);
7742
+ publicKey = (0, utils_ts_1.ensureBytes)("publicKey", publicKey);
7722
7743
  const { lowS, prehash, format: format2 } = opts;
7723
7744
  validateSigVerOpts(opts);
7724
7745
  if ("strict" in opts)
7725
7746
  throw new Error("options.strict was renamed to lowS");
7726
7747
  if (format2 !== undefined && format2 !== "compact" && format2 !== "der")
7727
7748
  throw new Error("format must be compact or der");
7728
- const isHex = typeof sg === "string" || ut.isBytes(sg);
7749
+ const isHex = typeof sg === "string" || (0, utils_ts_1.isBytes)(sg);
7729
7750
  const isObj = !isHex && !format2 && typeof sg === "object" && sg !== null && typeof sg.r === "bigint" && typeof sg.s === "bigint";
7730
7751
  if (!isHex && !isObj)
7731
7752
  throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
@@ -7840,7 +7861,7 @@ var require_weierstrass = __commonJS((exports) => {
7840
7861
  return sqrtRatio;
7841
7862
  }
7842
7863
  function mapToCurveSimpleSWU(Fp, opts) {
7843
- (0, modular_js_1.validateField)(Fp);
7864
+ (0, modular_ts_1.validateField)(Fp);
7844
7865
  if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))
7845
7866
  throw new Error("mapToCurveSimpleSWU: invalid opts");
7846
7867
  const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);
@@ -7886,7 +7907,7 @@ var require__shortw_utils = __commonJS((exports) => {
7886
7907
  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
7887
7908
  var hmac_1 = require_hmac();
7888
7909
  var utils_1 = require_utils4();
7889
- var weierstrass_js_1 = require_weierstrass();
7910
+ var weierstrass_ts_1 = require_weierstrass();
7890
7911
  function getHash(hash) {
7891
7912
  return {
7892
7913
  hash,
@@ -7895,7 +7916,7 @@ var require__shortw_utils = __commonJS((exports) => {
7895
7916
  };
7896
7917
  }
7897
7918
  function createCurve(curveDef, defHash) {
7898
- const create = (hash) => (0, weierstrass_js_1.weierstrass)({ ...curveDef, ...getHash(hash) });
7919
+ const create = (hash) => (0, weierstrass_ts_1.weierstrass)({ ...curveDef, ...getHash(hash) });
7899
7920
  return { ...create(defHash), create };
7900
7921
  }
7901
7922
  });
@@ -7905,13 +7926,13 @@ var require_secp256k1 = __commonJS((exports) => {
7905
7926
  Object.defineProperty(exports, "__esModule", { value: true });
7906
7927
  exports.encodeToCurve = exports.hashToCurve = exports.schnorr = exports.secp256k1 = undefined;
7907
7928
  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
7908
- var sha256_1 = require_sha256();
7929
+ var sha2_1 = require_sha2();
7909
7930
  var utils_1 = require_utils4();
7910
- var _shortw_utils_js_1 = require__shortw_utils();
7911
- var hash_to_curve_js_1 = require_hash_to_curve();
7912
- var modular_js_1 = require_modular();
7913
- var utils_js_1 = require_utils5();
7914
- var weierstrass_js_1 = require_weierstrass();
7931
+ var _shortw_utils_ts_1 = require__shortw_utils();
7932
+ var hash_to_curve_ts_1 = require_hash_to_curve();
7933
+ var modular_ts_1 = require_modular();
7934
+ var utils_ts_1 = require_utils5();
7935
+ var weierstrass_ts_1 = require_weierstrass();
7915
7936
  var secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
7916
7937
  var secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
7917
7938
  var _1n = BigInt(1);
@@ -7923,24 +7944,24 @@ var require_secp256k1 = __commonJS((exports) => {
7923
7944
  const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
7924
7945
  const b2 = y * y * y % P;
7925
7946
  const b3 = b2 * b2 * y % P;
7926
- const b6 = (0, modular_js_1.pow2)(b3, _3n, P) * b3 % P;
7927
- const b9 = (0, modular_js_1.pow2)(b6, _3n, P) * b3 % P;
7928
- const b11 = (0, modular_js_1.pow2)(b9, _2n, P) * b2 % P;
7929
- const b22 = (0, modular_js_1.pow2)(b11, _11n, P) * b11 % P;
7930
- const b44 = (0, modular_js_1.pow2)(b22, _22n, P) * b22 % P;
7931
- const b88 = (0, modular_js_1.pow2)(b44, _44n, P) * b44 % P;
7932
- const b176 = (0, modular_js_1.pow2)(b88, _88n, P) * b88 % P;
7933
- const b220 = (0, modular_js_1.pow2)(b176, _44n, P) * b44 % P;
7934
- const b223 = (0, modular_js_1.pow2)(b220, _3n, P) * b3 % P;
7935
- const t1 = (0, modular_js_1.pow2)(b223, _23n, P) * b22 % P;
7936
- const t2 = (0, modular_js_1.pow2)(t1, _6n, P) * b2 % P;
7937
- const root = (0, modular_js_1.pow2)(t2, _2n, P);
7947
+ const b6 = (0, modular_ts_1.pow2)(b3, _3n, P) * b3 % P;
7948
+ const b9 = (0, modular_ts_1.pow2)(b6, _3n, P) * b3 % P;
7949
+ const b11 = (0, modular_ts_1.pow2)(b9, _2n, P) * b2 % P;
7950
+ const b22 = (0, modular_ts_1.pow2)(b11, _11n, P) * b11 % P;
7951
+ const b44 = (0, modular_ts_1.pow2)(b22, _22n, P) * b22 % P;
7952
+ const b88 = (0, modular_ts_1.pow2)(b44, _44n, P) * b44 % P;
7953
+ const b176 = (0, modular_ts_1.pow2)(b88, _88n, P) * b88 % P;
7954
+ const b220 = (0, modular_ts_1.pow2)(b176, _44n, P) * b44 % P;
7955
+ const b223 = (0, modular_ts_1.pow2)(b220, _3n, P) * b3 % P;
7956
+ const t1 = (0, modular_ts_1.pow2)(b223, _23n, P) * b22 % P;
7957
+ const t2 = (0, modular_ts_1.pow2)(t1, _6n, P) * b2 % P;
7958
+ const root = (0, modular_ts_1.pow2)(t2, _2n, P);
7938
7959
  if (!Fpk1.eql(Fpk1.sqr(root), y))
7939
7960
  throw new Error("Cannot find square root");
7940
7961
  return root;
7941
7962
  }
7942
- var Fpk1 = (0, modular_js_1.Field)(secp256k1P, undefined, undefined, { sqrt: sqrtMod });
7943
- exports.secp256k1 = (0, _shortw_utils_js_1.createCurve)({
7963
+ var Fpk1 = (0, modular_ts_1.Field)(secp256k1P, undefined, undefined, { sqrt: sqrtMod });
7964
+ exports.secp256k1 = (0, _shortw_utils_ts_1.createCurve)({
7944
7965
  a: BigInt(0),
7945
7966
  b: BigInt(7),
7946
7967
  Fp: Fpk1,
@@ -7960,8 +7981,8 @@ var require_secp256k1 = __commonJS((exports) => {
7960
7981
  const POW_2_128 = BigInt("0x100000000000000000000000000000000");
7961
7982
  const c1 = divNearest(b2 * k, n);
7962
7983
  const c2 = divNearest(-b1 * k, n);
7963
- let k1 = (0, modular_js_1.mod)(k - c1 * a1 - c2 * a2, n);
7964
- let k2 = (0, modular_js_1.mod)(-c1 * b1 - c2 * b2, n);
7984
+ let k1 = (0, modular_ts_1.mod)(k - c1 * a1 - c2 * a2, n);
7985
+ let k2 = (0, modular_ts_1.mod)(-c1 * b1 - c2 * b2, n);
7965
7986
  const k1neg = k1 > POW_2_128;
7966
7987
  const k2neg = k2 > POW_2_128;
7967
7988
  if (k1neg)
@@ -7974,22 +7995,22 @@ var require_secp256k1 = __commonJS((exports) => {
7974
7995
  return { k1neg, k1, k2neg, k2 };
7975
7996
  }
7976
7997
  }
7977
- }, sha256_1.sha256);
7998
+ }, sha2_1.sha256);
7978
7999
  var _0n = BigInt(0);
7979
8000
  var TAGGED_HASH_PREFIXES = {};
7980
8001
  function taggedHash(tag, ...messages) {
7981
8002
  let tagP = TAGGED_HASH_PREFIXES[tag];
7982
8003
  if (tagP === undefined) {
7983
- const tagH = (0, sha256_1.sha256)(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
7984
- tagP = (0, utils_js_1.concatBytes)(tagH, tagH);
8004
+ const tagH = (0, sha2_1.sha256)(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
8005
+ tagP = (0, utils_ts_1.concatBytes)(tagH, tagH);
7985
8006
  TAGGED_HASH_PREFIXES[tag] = tagP;
7986
8007
  }
7987
- return (0, sha256_1.sha256)((0, utils_js_1.concatBytes)(tagP, ...messages));
8008
+ return (0, sha2_1.sha256)((0, utils_ts_1.concatBytes)(tagP, ...messages));
7988
8009
  }
7989
8010
  var pointToBytes = (point) => point.toRawBytes(true).slice(1);
7990
- var numTo32b = (n) => (0, utils_js_1.numberToBytesBE)(n, 32);
7991
- var modP = (x) => (0, modular_js_1.mod)(x, secp256k1P);
7992
- var modN = (x) => (0, modular_js_1.mod)(x, secp256k1N);
8011
+ var numTo32b = (n) => (0, utils_ts_1.numberToBytesBE)(n, 32);
8012
+ var modP = (x) => (0, modular_ts_1.mod)(x, secp256k1P);
8013
+ var modN = (x) => (0, modular_ts_1.mod)(x, secp256k1N);
7993
8014
  var Point = exports.secp256k1.ProjectivePoint;
7994
8015
  var GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
7995
8016
  function schnorrGetExtPubKey(priv) {
@@ -7999,7 +8020,7 @@ var require_secp256k1 = __commonJS((exports) => {
7999
8020
  return { scalar, bytes: pointToBytes(p) };
8000
8021
  }
8001
8022
  function lift_x(x) {
8002
- (0, utils_js_1.aInRange)("x", x, _1n, secp256k1P);
8023
+ (0, utils_ts_1.aInRange)("x", x, _1n, secp256k1P);
8003
8024
  const xx = modP(x * x);
8004
8025
  const c = modP(xx * x + BigInt(7));
8005
8026
  let y = sqrtMod(c);
@@ -8009,7 +8030,7 @@ var require_secp256k1 = __commonJS((exports) => {
8009
8030
  p.assertValidity();
8010
8031
  return p;
8011
8032
  }
8012
- var num = utils_js_1.bytesToNumberBE;
8033
+ var num = utils_ts_1.bytesToNumberBE;
8013
8034
  function challenge(...args) {
8014
8035
  return modN(num(taggedHash("BIP0340/challenge", ...args)));
8015
8036
  }
@@ -8017,9 +8038,9 @@ var require_secp256k1 = __commonJS((exports) => {
8017
8038
  return schnorrGetExtPubKey(privateKey).bytes;
8018
8039
  }
8019
8040
  function schnorrSign(message, privateKey, auxRand = (0, utils_1.randomBytes)(32)) {
8020
- const m = (0, utils_js_1.ensureBytes)("message", message);
8041
+ const m = (0, utils_ts_1.ensureBytes)("message", message);
8021
8042
  const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey);
8022
- const a = (0, utils_js_1.ensureBytes)("auxRand", auxRand, 32);
8043
+ const a = (0, utils_ts_1.ensureBytes)("auxRand", auxRand, 32);
8023
8044
  const t = numTo32b(d ^ num(taggedHash("BIP0340/aux", a)));
8024
8045
  const rand = taggedHash("BIP0340/nonce", t, px, m);
8025
8046
  const k_ = modN(num(rand));
@@ -8035,16 +8056,16 @@ var require_secp256k1 = __commonJS((exports) => {
8035
8056
  return sig;
8036
8057
  }
8037
8058
  function schnorrVerify(signature, message, publicKey) {
8038
- const sig = (0, utils_js_1.ensureBytes)("signature", signature, 64);
8039
- const m = (0, utils_js_1.ensureBytes)("message", message);
8040
- const pub = (0, utils_js_1.ensureBytes)("publicKey", publicKey, 32);
8059
+ const sig = (0, utils_ts_1.ensureBytes)("signature", signature, 64);
8060
+ const m = (0, utils_ts_1.ensureBytes)("message", message);
8061
+ const pub = (0, utils_ts_1.ensureBytes)("publicKey", publicKey, 32);
8041
8062
  try {
8042
8063
  const P = lift_x(num(pub));
8043
8064
  const r = num(sig.subarray(0, 32));
8044
- if (!(0, utils_js_1.inRange)(r, _1n, secp256k1P))
8065
+ if (!(0, utils_ts_1.inRange)(r, _1n, secp256k1P))
8045
8066
  return false;
8046
8067
  const s = num(sig.subarray(32, 64));
8047
- if (!(0, utils_js_1.inRange)(s, _1n, secp256k1N))
8068
+ if (!(0, utils_ts_1.inRange)(s, _1n, secp256k1N))
8048
8069
  return false;
8049
8070
  const e = challenge(numTo32b(r), pointToBytes(P), m);
8050
8071
  const R = GmulAdd(P, s, modN(-e));
@@ -8063,13 +8084,13 @@ var require_secp256k1 = __commonJS((exports) => {
8063
8084
  randomPrivateKey: exports.secp256k1.utils.randomPrivateKey,
8064
8085
  lift_x,
8065
8086
  pointToBytes,
8066
- numberToBytesBE: utils_js_1.numberToBytesBE,
8067
- bytesToNumberBE: utils_js_1.bytesToNumberBE,
8087
+ numberToBytesBE: utils_ts_1.numberToBytesBE,
8088
+ bytesToNumberBE: utils_ts_1.bytesToNumberBE,
8068
8089
  taggedHash,
8069
- mod: modular_js_1.mod
8090
+ mod: modular_ts_1.mod
8070
8091
  }
8071
8092
  }))();
8072
- var isoMap = /* @__PURE__ */ (() => (0, hash_to_curve_js_1.isogenyMap)(Fpk1, [
8093
+ var isoMap = /* @__PURE__ */ (() => (0, hash_to_curve_ts_1.isogenyMap)(Fpk1, [
8073
8094
  [
8074
8095
  "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
8075
8096
  "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
@@ -8094,12 +8115,12 @@ var require_secp256k1 = __commonJS((exports) => {
8094
8115
  "0x0000000000000000000000000000000000000000000000000000000000000001"
8095
8116
  ]
8096
8117
  ].map((i) => i.map((j) => BigInt(j)))))();
8097
- var mapSWU = /* @__PURE__ */ (() => (0, weierstrass_js_1.mapToCurveSimpleSWU)(Fpk1, {
8118
+ var mapSWU = /* @__PURE__ */ (() => (0, weierstrass_ts_1.mapToCurveSimpleSWU)(Fpk1, {
8098
8119
  A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
8099
8120
  B: BigInt("1771"),
8100
8121
  Z: Fpk1.create(BigInt("-11"))
8101
8122
  }))();
8102
- var htf = /* @__PURE__ */ (() => (0, hash_to_curve_js_1.createHasher)(exports.secp256k1.ProjectivePoint, (scalars) => {
8123
+ var htf = /* @__PURE__ */ (() => (0, hash_to_curve_ts_1.createHasher)(exports.secp256k1.ProjectivePoint, (scalars) => {
8103
8124
  const { x, y } = mapSWU(Fpk1.create(scalars[0]));
8104
8125
  return isoMap(x, y);
8105
8126
  }, {
@@ -8109,7 +8130,7 @@ var require_secp256k1 = __commonJS((exports) => {
8109
8130
  m: 1,
8110
8131
  k: 128,
8111
8132
  expand: "xmd",
8112
- hash: sha256_1.sha256
8133
+ hash: sha2_1.sha256
8113
8134
  }))();
8114
8135
  exports.hashToCurve = (() => htf.hashToCurve)();
8115
8136
  exports.encodeToCurve = (() => htf.encodeToCurve)();
@@ -8232,27 +8253,27 @@ var require_hkdf = __commonJS((exports) => {
8232
8253
  exports.hkdf = undefined;
8233
8254
  exports.extract = extract;
8234
8255
  exports.expand = expand;
8235
- var _assert_js_1 = require__assert2();
8236
- var hmac_js_1 = require_hmac();
8237
- var utils_js_1 = require_utils4();
8256
+ var _assert_ts_1 = require__assert2();
8257
+ var hmac_ts_1 = require_hmac();
8258
+ var utils_ts_1 = require_utils4();
8238
8259
  function extract(hash, ikm, salt) {
8239
- (0, _assert_js_1.ahash)(hash);
8260
+ (0, _assert_ts_1.ahash)(hash);
8240
8261
  if (salt === undefined)
8241
8262
  salt = new Uint8Array(hash.outputLen);
8242
- return (0, hmac_js_1.hmac)(hash, (0, utils_js_1.toBytes)(salt), (0, utils_js_1.toBytes)(ikm));
8263
+ return (0, hmac_ts_1.hmac)(hash, (0, utils_ts_1.toBytes)(salt), (0, utils_ts_1.toBytes)(ikm));
8243
8264
  }
8244
8265
  var HKDF_COUNTER = /* @__PURE__ */ new Uint8Array([0]);
8245
8266
  var EMPTY_BUFFER = /* @__PURE__ */ new Uint8Array;
8246
8267
  function expand(hash, prk, info, length = 32) {
8247
- (0, _assert_js_1.ahash)(hash);
8248
- (0, _assert_js_1.anumber)(length);
8268
+ (0, _assert_ts_1.ahash)(hash);
8269
+ (0, _assert_ts_1.anumber)(length);
8249
8270
  if (length > 255 * hash.outputLen)
8250
8271
  throw new Error("Length should be <= 255*HashLen");
8251
8272
  const blocks = Math.ceil(length / hash.outputLen);
8252
8273
  if (info === undefined)
8253
8274
  info = EMPTY_BUFFER;
8254
8275
  const okm = new Uint8Array(blocks * hash.outputLen);
8255
- const HMAC = hmac_js_1.hmac.create(hash, prk);
8276
+ const HMAC = hmac_ts_1.hmac.create(hash, prk);
8256
8277
  const HMACTmp = HMAC._cloneInto();
8257
8278
  const T = new Uint8Array(HMAC.outputLen);
8258
8279
  for (let counter = 0;counter < blocks; counter++) {
@@ -9088,7 +9109,7 @@ var require_parse2 = __commonJS((exports, module) => {
9088
9109
  // ../../node_modules/@dotenvx/dotenvx/src/lib/helpers/dotenvParse.js
9089
9110
  var require_dotenvParse = __commonJS((exports, module) => {
9090
9111
  var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
9091
- function dotenvParse(src, skipExpandForDoubleQuotes = false, skipConvertingWindowsNewlines = false) {
9112
+ function dotenvParse(src, skipExpandForDoubleQuotes = false, skipConvertingWindowsNewlines = false, collectAllValues = false) {
9092
9113
  const obj = {};
9093
9114
  let lines = src.toString();
9094
9115
  if (!skipConvertingWindowsNewlines) {
@@ -9108,7 +9129,12 @@ var require_dotenvParse = __commonJS((exports, module) => {
9108
9129
  value = value.replace(/\\r/g, "\r");
9109
9130
  value = value.replace(/\\t/g, "\t");
9110
9131
  }
9111
- obj[key] = value;
9132
+ if (collectAllValues) {
9133
+ obj[key] = obj[key] || [];
9134
+ obj[key].push(value);
9135
+ } else {
9136
+ obj[key] = value;
9137
+ }
9112
9138
  }
9113
9139
  return obj;
9114
9140
  }
@@ -31162,6 +31188,23 @@ var require_lib4 = __commonJS((exports, module) => {
31162
31188
  var fromUrl = require_from_url();
31163
31189
  var parseUrl = require_parse_url();
31164
31190
  var cache = new LRUCache2({ max: 1000 });
31191
+ function unknownHostedUrl(url) {
31192
+ try {
31193
+ const {
31194
+ protocol,
31195
+ hostname,
31196
+ pathname
31197
+ } = new URL(url);
31198
+ if (!hostname) {
31199
+ return null;
31200
+ }
31201
+ const proto = /(?:git\+)http:$/.test(protocol) ? "http:" : "https:";
31202
+ const path6 = pathname.replace(/\.git$/, "");
31203
+ return `${proto}//${hostname}${path6}`;
31204
+ } catch {
31205
+ return null;
31206
+ }
31207
+ }
31165
31208
 
31166
31209
  class GitHost {
31167
31210
  constructor(type2, user, auth, project, committish, defaultRepresentation, opts = {}) {
@@ -31205,6 +31248,22 @@ var require_lib4 = __commonJS((exports, module) => {
31205
31248
  }
31206
31249
  return cache.get(key2);
31207
31250
  }
31251
+ static fromManifest(manifest, opts = {}) {
31252
+ if (!manifest || typeof manifest !== "object") {
31253
+ return;
31254
+ }
31255
+ const r2 = manifest.repository;
31256
+ const rurl = r2 && (typeof r2 === "string" ? r2 : typeof r2 === "object" && typeof r2.url === "string" ? r2.url : null);
31257
+ if (!rurl) {
31258
+ throw new Error("no repository");
31259
+ }
31260
+ const info = rurl && GitHost.fromUrl(rurl.replace(/^git\+/, ""), opts) || null;
31261
+ if (info) {
31262
+ return info;
31263
+ }
31264
+ const unk = unknownHostedUrl(rurl);
31265
+ return GitHost.fromUrl(unk, opts) || unk;
31266
+ }
31208
31267
  static parseUrl(url) {
31209
31268
  return parseUrl(url);
31210
31269
  }
@@ -235068,7 +235127,7 @@ var is_in_ci_default = isInCi;
235068
235127
  // ../../node_modules/yocto-spinner/index.js
235069
235128
  import process2 from "node:process";
235070
235129
  import { stripVTControlCharacters } from "node:util";
235071
- var isUnicodeSupported = process2.platform !== "win32" || Boolean(process2.env.WT_SESSION);
235130
+ var isUnicodeSupported = process2.platform !== "win32" || Boolean(process2.env.WT_SESSION) || process2.env.TERM_PROGRAM === "vscode";
235072
235131
  var isInteractive = (stream) => Boolean(stream.isTTY && process2.env.TERM !== "dumb" && !("CI" in process2.env));
235073
235132
  var infoSymbol = exports_base.blue(isUnicodeSupported ? "ℹ" : "i");
235074
235133
  var successSymbol = exports_base.green(isUnicodeSupported ? "✔" : "√");
@@ -245084,8 +245143,11 @@ var DotEnvSchema = z.object({
245084
245143
  SETTLEMINT_WORKSPACE: UniqueNameSchema.optional(),
245085
245144
  SETTLEMINT_APPLICATION: UniqueNameSchema.optional(),
245086
245145
  SETTLEMINT_BLOCKCHAIN_NETWORK: UniqueNameSchema.optional(),
245146
+ SETTLEMINT_BLOCKCHAIN_NETWORK_CHAIN_ID: z.string().optional(),
245087
245147
  SETTLEMINT_BLOCKCHAIN_NODE: UniqueNameSchema.optional(),
245088
- SETTLEMINT_LOAD_BALANCER: UniqueNameSchema.optional(),
245148
+ SETTLEMINT_BLOCKCHAIN_NODE_JSON_RPC_ENDPOINT: UrlSchema.optional(),
245149
+ SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER: UniqueNameSchema.optional(),
245150
+ SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER_JSON_RPC_ENDPOINT: UrlSchema.optional(),
245089
245151
  SETTLEMINT_HASURA: UniqueNameSchema.optional(),
245090
245152
  SETTLEMINT_HASURA_ENDPOINT: UrlSchema.optional(),
245091
245153
  SETTLEMINT_HASURA_ADMIN_SECRET: z.string().optional(),
@@ -245278,7 +245340,7 @@ function pruneCurrentEnv(currentEnv, env2) {
245278
245340
  var package_default = {
245279
245341
  name: "@settlemint/sdk-cli",
245280
245342
  description: "Command-line interface for SettleMint SDK, providing development tools and project management capabilities",
245281
- version: "2.1.4-pra7619575",
245343
+ version: "2.1.4-prb6bb647e",
245282
245344
  type: "module",
245283
245345
  private: false,
245284
245346
  license: "FSL-1.1-MIT",
@@ -245327,8 +245389,8 @@ var package_default = {
245327
245389
  "@inquirer/input": "4.1.9",
245328
245390
  "@inquirer/password": "4.0.12",
245329
245391
  "@inquirer/select": "4.1.1",
245330
- "@settlemint/sdk-js": "2.1.4-pra7619575",
245331
- "@settlemint/sdk-utils": "2.1.4-pra7619575",
245392
+ "@settlemint/sdk-js": "2.1.4-prb6bb647e",
245393
+ "@settlemint/sdk-utils": "2.1.4-prb6bb647e",
245332
245394
  "@types/node": "22.14.1",
245333
245395
  "@types/semver": "7.7.0",
245334
245396
  "@types/which": "3.0.4",
@@ -246504,6 +246566,13 @@ var cancel2 = (msg) => {
246504
246566
  console.log("");
246505
246567
  throw new CancelError2(msg);
246506
246568
  };
246569
+ var CommandError = class extends Error {
246570
+ constructor(message, code, output) {
246571
+ super(message);
246572
+ this.code = code;
246573
+ this.output = output;
246574
+ }
246575
+ };
246507
246576
  async function executeCommand(command, args, options) {
246508
246577
  const child = spawn(command, args, { env: { ...process.env, ...options?.env } });
246509
246578
  process.stdin.pipe(child.stdin);
@@ -246523,14 +246592,14 @@ async function executeCommand(command, args, options) {
246523
246592
  }
246524
246593
  output.push(maskedData);
246525
246594
  });
246526
- child.on("error", (err) => reject(err));
246595
+ child.on("error", (err) => reject(new CommandError(err.message, "code" in err && typeof err.code === "number" ? err.code : 1, output)));
246527
246596
  child.on("close", (code) => {
246528
246597
  if (code === 0 || code === null || code === 143) {
246529
246598
  process.stdin.unpipe(child.stdin);
246530
246599
  resolve(output);
246531
246600
  return;
246532
246601
  }
246533
- reject(new Error(`Command "${command}" exited with code ${code}`));
246602
+ reject(new CommandError(`Command "${command}" exited with code ${code}`, code, output));
246534
246603
  });
246535
246604
  });
246536
246605
  }
@@ -246741,8 +246810,11 @@ var DotEnvSchema2 = z.object({
246741
246810
  SETTLEMINT_WORKSPACE: UniqueNameSchema2.optional(),
246742
246811
  SETTLEMINT_APPLICATION: UniqueNameSchema2.optional(),
246743
246812
  SETTLEMINT_BLOCKCHAIN_NETWORK: UniqueNameSchema2.optional(),
246813
+ SETTLEMINT_BLOCKCHAIN_NETWORK_CHAIN_ID: z.string().optional(),
246744
246814
  SETTLEMINT_BLOCKCHAIN_NODE: UniqueNameSchema2.optional(),
246745
- SETTLEMINT_LOAD_BALANCER: UniqueNameSchema2.optional(),
246815
+ SETTLEMINT_BLOCKCHAIN_NODE_JSON_RPC_ENDPOINT: UrlSchema2.optional(),
246816
+ SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER: UniqueNameSchema2.optional(),
246817
+ SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER_JSON_RPC_ENDPOINT: UrlSchema2.optional(),
246746
246818
  SETTLEMINT_HASURA: UniqueNameSchema2.optional(),
246747
246819
  SETTLEMINT_HASURA_ENDPOINT: UrlSchema2.optional(),
246748
246820
  SETTLEMINT_HASURA_ADMIN_SECRET: z.string().optional(),
@@ -247641,11 +247713,61 @@ var BlockchainNetworkFragment = graphql(`
247641
247713
  healthStatus
247642
247714
  provider
247643
247715
  region
247716
+ ... on BesuQBFTBlockchainNetwork {
247717
+ chainId
247718
+ }
247719
+ ... on BesuIbftv2BlockchainNetwork {
247720
+ chainId
247721
+ }
247722
+ ... on GethPoWBlockchainNetwork {
247723
+ chainId
247724
+ }
247725
+ ... on GethPoSRinkebyBlockchainNetwork {
247726
+ chainId
247727
+ }
247728
+ ... on GethVenidiumBlockchainNetwork {
247729
+ chainId
247730
+ }
247731
+ ... on GethGoerliBlockchainNetwork {
247732
+ chainId
247733
+ }
247734
+ ... on AvalancheBlockchainNetwork {
247735
+ chainId
247736
+ }
247737
+ ... on AvalancheFujiBlockchainNetwork {
247738
+ chainId
247739
+ }
247740
+ ... on BscPoWBlockchainNetwork {
247741
+ chainId
247742
+ }
247743
+ ... on BscPoWTestnetBlockchainNetwork {
247744
+ chainId
247745
+ }
247746
+ ... on PolygonBlockchainNetwork {
247747
+ chainId
247748
+ }
247749
+ ... on PolygonMumbaiBlockchainNetwork {
247750
+ chainId
247751
+ }
247752
+ ... on PolygonEdgePoABlockchainNetwork {
247753
+ chainId
247754
+ }
247755
+ ... on QuorumQBFTBlockchainNetwork {
247756
+ chainId
247757
+ }
247758
+ ... on GethCliqueBlockchainNetwork {
247759
+ chainId
247760
+ }
247644
247761
  blockchainNodes {
247645
247762
  ... on BlockchainNode {
247646
247763
  id
247647
247764
  name
247648
247765
  uniqueName
247766
+ endpoints {
247767
+ id
247768
+ label
247769
+ displayValue
247770
+ }
247649
247771
  }
247650
247772
  }
247651
247773
  }
@@ -247807,6 +247929,51 @@ var BlockchainNodeFragment = graphql(`
247807
247929
  id
247808
247930
  name
247809
247931
  uniqueName
247932
+ ... on BesuQBFTBlockchainNetwork {
247933
+ chainId
247934
+ }
247935
+ ... on BesuIbftv2BlockchainNetwork {
247936
+ chainId
247937
+ }
247938
+ ... on GethPoWBlockchainNetwork {
247939
+ chainId
247940
+ }
247941
+ ... on GethPoSRinkebyBlockchainNetwork {
247942
+ chainId
247943
+ }
247944
+ ... on GethVenidiumBlockchainNetwork {
247945
+ chainId
247946
+ }
247947
+ ... on GethGoerliBlockchainNetwork {
247948
+ chainId
247949
+ }
247950
+ ... on AvalancheBlockchainNetwork {
247951
+ chainId
247952
+ }
247953
+ ... on AvalancheFujiBlockchainNetwork {
247954
+ chainId
247955
+ }
247956
+ ... on BscPoWBlockchainNetwork {
247957
+ chainId
247958
+ }
247959
+ ... on BscPoWTestnetBlockchainNetwork {
247960
+ chainId
247961
+ }
247962
+ ... on PolygonBlockchainNetwork {
247963
+ chainId
247964
+ }
247965
+ ... on PolygonMumbaiBlockchainNetwork {
247966
+ chainId
247967
+ }
247968
+ ... on PolygonEdgePoABlockchainNetwork {
247969
+ chainId
247970
+ }
247971
+ ... on QuorumQBFTBlockchainNetwork {
247972
+ chainId
247973
+ }
247974
+ ... on GethCliqueBlockchainNetwork {
247975
+ chainId
247976
+ }
247810
247977
  }
247811
247978
  }
247812
247979
  privateKeys {
@@ -248050,6 +248217,11 @@ var LoadBalancerFragment = graphql(`
248050
248217
  healthStatus
248051
248218
  provider
248052
248219
  region
248220
+ endpoints {
248221
+ id
248222
+ label
248223
+ displayValue
248224
+ }
248053
248225
  }
248054
248226
  `);
248055
248227
  var getLoadBalancer = graphql(`
@@ -248059,6 +248231,47 @@ var getLoadBalancer = graphql(`
248059
248231
  }
248060
248232
  }
248061
248233
  `, [LoadBalancerFragment]);
248234
+ var getLoadBalancers = graphql(`
248235
+ query getLoadBalancers($applicationUniqueName: String!) {
248236
+ loadBalancersByUniqueName(applicationUniqueName: $applicationUniqueName) {
248237
+ items {
248238
+ ...LoadBalancer
248239
+ }
248240
+ }
248241
+ }
248242
+ `, [LoadBalancerFragment]);
248243
+ var createLoadBalancer = graphql(`
248244
+ mutation createLoadBalancer(
248245
+ $applicationId: ID!
248246
+ $blockchainNetworkId: ID!
248247
+ $name: String!
248248
+ $provider: String!
248249
+ $region: String!
248250
+ $size: ClusterServiceSize
248251
+ $type: ClusterServiceType
248252
+ $connectedNodes: [ID!]!
248253
+ ) {
248254
+ createLoadBalancer(
248255
+ applicationId: $applicationId
248256
+ blockchainNetworkId: $blockchainNetworkId
248257
+ name: $name
248258
+ provider: $provider
248259
+ region: $region
248260
+ size: $size
248261
+ type: $type
248262
+ connectedNodes: $connectedNodes
248263
+ ) {
248264
+ ...LoadBalancer
248265
+ }
248266
+ }
248267
+ `, [LoadBalancerFragment]);
248268
+ var restartLoadBalancer = graphql(`
248269
+ mutation RestartLoadBalancer($uniqueName: String!) {
248270
+ restartLoadBalancerByUniqueName(uniqueName: $uniqueName) {
248271
+ ...LoadBalancer
248272
+ }
248273
+ }
248274
+ `, [LoadBalancerFragment]);
248062
248275
  var loadBalancerRead = (gqlClient) => {
248063
248276
  return async (loadBalancerUniqueName) => {
248064
248277
  const { loadBalancerByUniqueName: loadBalancer } = await gqlClient.request(getLoadBalancer, {
@@ -248067,6 +248280,37 @@ var loadBalancerRead = (gqlClient) => {
248067
248280
  return loadBalancer;
248068
248281
  };
248069
248282
  };
248283
+ var loadBalancerList = (gqlClient) => {
248284
+ return async (applicationUniqueName) => {
248285
+ const {
248286
+ loadBalancersByUniqueName: { items }
248287
+ } = await gqlClient.request(getLoadBalancers, { applicationUniqueName });
248288
+ return items;
248289
+ };
248290
+ };
248291
+ var loadBalancerCreate = (gqlClient) => {
248292
+ return async (args) => {
248293
+ const { applicationUniqueName, blockchainNetworkUniqueName, connectedNodesUniqueNames, ...otherArgs } = args;
248294
+ const [application, blockchainNetwork, connectedNodes] = await Promise.all([
248295
+ applicationRead(gqlClient)(applicationUniqueName),
248296
+ blockchainNetworkRead(gqlClient)(blockchainNetworkUniqueName),
248297
+ Promise.all(connectedNodesUniqueNames.map((uniqueName) => blockchainNodeRead(gqlClient)(uniqueName)))
248298
+ ]);
248299
+ const { createLoadBalancer: loadBalancer } = await gqlClient.request(createLoadBalancer, {
248300
+ ...otherArgs,
248301
+ applicationId: application.id,
248302
+ blockchainNetworkId: blockchainNetwork.id,
248303
+ connectedNodes: connectedNodes.map((node) => node.id)
248304
+ });
248305
+ return loadBalancer;
248306
+ };
248307
+ };
248308
+ var loadBalancerRestart = (gqlClient) => async (loadBalancerUniqueName) => {
248309
+ const { restartLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(restartLoadBalancer, {
248310
+ uniqueName: loadBalancerUniqueName
248311
+ });
248312
+ return loadBalancer;
248313
+ };
248070
248314
  var InsightsFragment = graphql(`
248071
248315
  fragment Insights on Insights {
248072
248316
  __typename
@@ -248767,6 +249011,12 @@ function createSettleMintClient(options) {
248767
249011
  create: blockchainNodeCreate(gqlClient),
248768
249012
  restart: blockchainNodeRestart(gqlClient)
248769
249013
  },
249014
+ loadBalancer: {
249015
+ list: loadBalancerList(gqlClient),
249016
+ read: loadBalancerRead(gqlClient),
249017
+ create: loadBalancerCreate(gqlClient),
249018
+ restart: loadBalancerRestart(gqlClient)
249019
+ },
248770
249020
  middleware: {
248771
249021
  list: middlewareList(gqlClient),
248772
249022
  read: middlewareRead(gqlClient),
@@ -248851,6 +249101,7 @@ var LOCKS = {
248851
249101
  "bun.lockb": "bun",
248852
249102
  "deno.lock": "deno",
248853
249103
  "pnpm-lock.yaml": "pnpm",
249104
+ "pnpm-workspace.yaml": "pnpm",
248854
249105
  "yarn.lock": "yarn",
248855
249106
  "package-lock.json": "npm",
248856
249107
  "npm-shrinkwrap.json": "npm"
@@ -249841,6 +250092,13 @@ function tryParseJson3(value2, defaultValue = null) {
249841
250092
  return defaultValue;
249842
250093
  }
249843
250094
  }
250095
+ function extractJsonObject(value2) {
250096
+ const result = /\{([\s\S]*)\}/.exec(value2);
250097
+ if (!result) {
250098
+ return null;
250099
+ }
250100
+ return tryParseJson3(result[0]);
250101
+ }
249844
250102
  async function retryWhenFailed2(fn, maxRetries = 5, initialSleepTime = 1000, stopOnError) {
249845
250103
  let attempt = 0;
249846
250104
  while (attempt < maxRetries) {
@@ -250141,7 +250399,7 @@ export const postgresPool = createPostgresPool(process.env.SETTLEMINT_HASURA_DAT
250141
250399
  await installDependencies(PACKAGE_NAME, projectDir);
250142
250400
  }
250143
250401
  if (!databaseUrl) {
250144
- console.warn("[Codegen] Missing database environment variables");
250402
+ note("[Codegen] Missing database environment variables", "warn");
250145
250403
  }
250146
250404
  }
250147
250405
 
@@ -251698,6 +251956,7 @@ async function codegenBlockscout(env2) {
251698
251956
  __schema {
251699
251957
  queryType { name }
251700
251958
  mutationType { name }
251959
+ subscriptionType { name }
251701
251960
  types {
251702
251961
  ...FullType
251703
251962
  }
@@ -251779,10 +252038,6 @@ async function codegenBlockscout(env2) {
251779
252038
  ofType {
251780
252039
  kind
251781
252040
  name
251782
- ofType {
251783
- kind
251784
- name
251785
- }
251786
252041
  }
251787
252042
  }
251788
252043
  }
@@ -251792,7 +252047,8 @@ async function codegenBlockscout(env2) {
251792
252047
  }
251793
252048
  }
251794
252049
  }
251795
- `
252050
+ `,
252051
+ operationName: "IntrospectionQuery"
251796
252052
  })
251797
252053
  });
251798
252054
  await writeFile6(introspectionJsonPath, JSON.stringify(data));
@@ -251900,9 +252156,72 @@ export const { client } = createServerMinioClient({
251900
252156
  }
251901
252157
  }
251902
252158
 
252159
+ // src/commands/codegen/codegen-viem.ts
252160
+ var PACKAGE_NAME7 = "@settlemint/sdk-viem";
252161
+ async function codegenViem(env2) {
252162
+ const chainId = env2.SETTLEMINT_BLOCKCHAIN_NETWORK_CHAIN_ID;
252163
+ if (!chainId) {
252164
+ note("[Codegen] No chain ID found, skipping Viem resources generation", "warn");
252165
+ return;
252166
+ }
252167
+ const loadBalancerRpcEndpoint = env2.SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER_JSON_RPC_ENDPOINT;
252168
+ const blockchainNodeRpcEndpoint = env2.SETTLEMINT_BLOCKCHAIN_NODE_JSON_RPC_ENDPOINT;
252169
+ if (!loadBalancerRpcEndpoint && !blockchainNodeRpcEndpoint) {
252170
+ note("[Codegen] No RPC endpoints found, skipping Viem resources generation", "warn");
252171
+ return;
252172
+ }
252173
+ const projectDir = await projectRoot3();
252174
+ if (!await isPackageInstalled(PACKAGE_NAME7, projectDir)) {
252175
+ await installDependencies(PACKAGE_NAME7, projectDir);
252176
+ }
252177
+ const imports = [];
252178
+ if (loadBalancerRpcEndpoint) {
252179
+ imports.push("getPublicClient");
252180
+ }
252181
+ if (blockchainNodeRpcEndpoint) {
252182
+ imports.push("getWalletClient");
252183
+ }
252184
+ const viemTemplate = [`import { ${imports.join(", ")} } from "${PACKAGE_NAME7}";`];
252185
+ if (loadBalancerRpcEndpoint) {
252186
+ viemTemplate.push(`
252187
+ /**
252188
+ * The public client. Use this if you need to read from the blockchain.
252189
+ */
252190
+ export const publicClient = getPublicClient({
252191
+ chainId: process.env.SETTLEMINT_BLOCKCHAIN_NETWORK_CHAIN_ID!,
252192
+ chainName: process.env.SETTLEMINT_BLOCKCHAIN_NETWORK!,
252193
+ rpcUrl: process.env.SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER_JSON_RPC_ENDPOINT!,
252194
+ });`);
252195
+ }
252196
+ if (blockchainNodeRpcEndpoint) {
252197
+ viemTemplate.push(`
252198
+ /**
252199
+ * The wallet client. Use this if you need to write to the blockchain.
252200
+ */
252201
+ export const walletClient = getWalletClient({
252202
+ chainId: process.env.SETTLEMINT_BLOCKCHAIN_NETWORK_CHAIN_ID!,
252203
+ chainName: process.env.SETTLEMINT_BLOCKCHAIN_NETWORK!,
252204
+ rpcUrl: process.env.SETTLEMINT_BLOCKCHAIN_NODE_JSON_RPC_ENDPOINT!,
252205
+ })();
252206
+
252207
+ /**
252208
+ * The wallet client for HD wallets. Use this if you need to write to the blockchain.
252209
+ * HD wallets require a challenge response to be sent with the request.
252210
+ */
252211
+ export const hdWalletClient = getWalletClient({
252212
+ chainId: process.env.SETTLEMINT_BLOCKCHAIN_NETWORK_CHAIN_ID!,
252213
+ chainName: process.env.SETTLEMINT_BLOCKCHAIN_NETWORK!,
252214
+ rpcUrl: process.env.SETTLEMINT_BLOCKCHAIN_NODE_JSON_RPC_ENDPOINT!,
252215
+ });`);
252216
+ }
252217
+ await writeTemplate(viemTemplate.join(`
252218
+ `), "/lib/settlemint", "viem.ts");
252219
+ note("Viem resources generated successfully");
252220
+ }
252221
+
251903
252222
  // src/commands/codegen.ts
251904
252223
  function codegenCommand() {
251905
- return new Command("codegen").option("--prod", "Connect to your production environment").option("--thegraph-subgraph-names <subgraph-names...>", "The name(s) of the TheGraph subgraph(s) to generate (skip if you want to generate all)").description("Generate GraphQL and REST types and queries").usage(createExamples([
252224
+ return new Command("codegen").option("--prod", "Connect to your production environment").option("--thegraph-subgraph-names <subgraph-names...>", "The name(s) of the TheGraph subgraph(s) to generate (skip if you want to generate all)").option("--generate-viem", "Generate Viem resources").description("Generate GraphQL and REST types and queries").usage(createExamples([
251906
252225
  {
251907
252226
  description: "Generate GraphQL types and queries for your dApp",
251908
252227
  command: "codegen"
@@ -251910,8 +252229,12 @@ function codegenCommand() {
251910
252229
  {
251911
252230
  description: "Generate GraphQL types and queries for specific TheGraph subgraphs",
251912
252231
  command: "codegen --thegraph-subgraph-names subgraph1 subgraph2"
252232
+ },
252233
+ {
252234
+ description: "Generate Viem resources",
252235
+ command: "codegen --generate-viem"
251913
252236
  }
251914
- ])).action(async ({ prod, thegraphSubgraphNames }) => {
252237
+ ])).action(async ({ prod, thegraphSubgraphNames, generateViem }) => {
251915
252238
  intro("Generating GraphQL types and queries for your dApp");
251916
252239
  const env2 = await loadEnv(true, !!prod);
251917
252240
  if (!Array.isArray(thegraphSubgraphNames)) {
@@ -251929,6 +252252,10 @@ function codegenCommand() {
251929
252252
  },
251930
252253
  stopMessage: "Tested GraphQL schemas"
251931
252254
  });
252255
+ if (generateViem) {
252256
+ note("Generating Viem resources");
252257
+ await codegenViem(env2);
252258
+ }
251932
252259
  if (hasura) {
251933
252260
  note("Generating Hasura resources");
251934
252261
  await codegenHasura(env2);
@@ -252190,6 +252517,7 @@ async function applicationPrompt(env2, applications, accept) {
252190
252517
  }
252191
252518
 
252192
252519
  // src/prompts/cluster-service/service.prompt.ts
252520
+ var ALL2 = "All";
252193
252521
  async function servicePrompt({
252194
252522
  env: env2,
252195
252523
  services,
@@ -252198,13 +252526,17 @@ async function servicePrompt({
252198
252526
  defaultHandler,
252199
252527
  isRequired = false,
252200
252528
  isCi = is_in_ci_default,
252201
- singleOptionMessage
252529
+ singleOptionMessage,
252530
+ allowAll = false
252202
252531
  }) {
252203
252532
  if (services.length === 0) {
252204
252533
  return;
252205
252534
  }
252206
- const selectedService = services.find((service) => service.uniqueName === env2[envKey]);
252535
+ const selectedService = services.find((service) => Array.isArray(service) ? false : service.uniqueName === env2[envKey]);
252207
252536
  const autoAccept = isCi || accept;
252537
+ if (autoAccept && allowAll) {
252538
+ return services;
252539
+ }
252208
252540
  if (autoAccept && selectedService) {
252209
252541
  return selectedService;
252210
252542
  }
@@ -252212,7 +252544,7 @@ async function servicePrompt({
252212
252544
  return;
252213
252545
  }
252214
252546
  if (isRequired && services.length === 1) {
252215
- if (singleOptionMessage) {
252547
+ if (singleOptionMessage && !Array.isArray(services[0])) {
252216
252548
  note(singleOptionMessage(services[0].uniqueName));
252217
252549
  }
252218
252550
  return services[0];
@@ -252221,13 +252553,37 @@ async function servicePrompt({
252221
252553
  name: `${service.name} (${service.uniqueName})`,
252222
252554
  value: service
252223
252555
  }));
252556
+ if (allowAll) {
252557
+ choices.unshift({
252558
+ name: ALL2,
252559
+ value: services
252560
+ });
252561
+ }
252224
252562
  if (!isRequired) {
252225
252563
  choices.push({
252226
252564
  name: "None",
252227
252565
  value: undefined
252228
252566
  });
252229
252567
  }
252230
- return defaultHandler({ defaultService: selectedService, choices });
252568
+ return defaultHandler({
252569
+ defaultService: selectedService,
252570
+ choices
252571
+ });
252572
+ }
252573
+
252574
+ // src/utils/cluster-service.ts
252575
+ function isValidPrivateKey(privateKey) {
252576
+ return privateKey.privateKeyType !== "HD_ECDSA_P256";
252577
+ }
252578
+ function hasValidPrivateKey(service) {
252579
+ return (service.privateKeys ?? []).some(isValidPrivateKey);
252580
+ }
252581
+ function hasPrivateKey(service) {
252582
+ const keys = service.privateKeys ?? [];
252583
+ return keys.length > 0;
252584
+ }
252585
+ function isRunning(service) {
252586
+ return service === undefined || service?.status === "COMPLETED";
252231
252587
  }
252232
252588
 
252233
252589
  // src/prompts/cluster-service/blockchain-node.prompt.ts
@@ -252238,7 +252594,8 @@ async function blockchainNodePrompt({
252238
252594
  singleOptionMessage,
252239
252595
  promptMessage,
252240
252596
  filterRunningOnly = false,
252241
- isRequired = false
252597
+ isRequired = false,
252598
+ allowAll = false
252242
252599
  }) {
252243
252600
  return servicePrompt({
252244
252601
  env: env2,
@@ -252247,14 +252604,25 @@ async function blockchainNodePrompt({
252247
252604
  envKey: "SETTLEMINT_BLOCKCHAIN_NODE",
252248
252605
  isRequired,
252249
252606
  defaultHandler: async ({ defaultService: defaultNode, choices }) => {
252250
- const filteredChoices = filterRunningOnly ? choices.filter(({ value: node }) => node === undefined || node?.status === "COMPLETED") : choices;
252607
+ const filteredChoices = filterRunningOnly ? choices.filter(({ value: node }) => {
252608
+ return Array.isArray(node) ? true : isRunning(node);
252609
+ }).map((item) => {
252610
+ if (Array.isArray(item.value)) {
252611
+ return {
252612
+ ...item,
252613
+ value: item.value.filter(isRunning)
252614
+ };
252615
+ }
252616
+ return item;
252617
+ }) : choices;
252251
252618
  return esm_default3({
252252
252619
  message: promptMessage ?? "Which blockchain node do you want to connect to?",
252253
252620
  choices: filteredChoices,
252254
252621
  default: defaultNode
252255
252622
  });
252256
252623
  },
252257
- singleOptionMessage
252624
+ singleOptionMessage,
252625
+ allowAll
252258
252626
  });
252259
252627
  }
252260
252628
 
@@ -252559,7 +252927,8 @@ async function servicesSpinner(settlemint, applicationUniqueName, types2) {
252559
252927
  storages,
252560
252928
  privateKeys,
252561
252929
  insights,
252562
- customDeployments
252930
+ customDeployments,
252931
+ loadBalancers
252563
252932
  ] = await Promise.all([
252564
252933
  shouldFetch("blockchain-network") ? settlemint.blockchainNetwork.list(applicationUniqueName) : Promise.resolve([]),
252565
252934
  shouldFetch("blockchain-node") ? settlemint.blockchainNode.list(applicationUniqueName) : Promise.resolve([]),
@@ -252568,7 +252937,8 @@ async function servicesSpinner(settlemint, applicationUniqueName, types2) {
252568
252937
  shouldFetch("storage") ? settlemint.storage.list(applicationUniqueName) : Promise.resolve([]),
252569
252938
  shouldFetch("private-key") ? settlemint.privateKey.list(applicationUniqueName) : Promise.resolve([]),
252570
252939
  shouldFetch("insights") ? settlemint.insights.list(applicationUniqueName) : Promise.resolve([]),
252571
- shouldFetch("custom-deployment") ? settlemint.customDeployment.list(applicationUniqueName) : Promise.resolve([])
252940
+ shouldFetch("custom-deployment") ? settlemint.customDeployment.list(applicationUniqueName) : Promise.resolve([]),
252941
+ shouldFetch("load-balancer") ? settlemint.loadBalancer.list(applicationUniqueName) : Promise.resolve([])
252572
252942
  ]);
252573
252943
  return {
252574
252944
  blockchainNetworks,
@@ -252578,7 +252948,8 @@ async function servicesSpinner(settlemint, applicationUniqueName, types2) {
252578
252948
  storages,
252579
252949
  privateKeys,
252580
252950
  insights,
252581
- customDeployments
252951
+ customDeployments,
252952
+ loadBalancers
252582
252953
  };
252583
252954
  }
252584
252955
  });
@@ -252617,8 +252988,11 @@ async function writeEnvSpinner(prod, env2) {
252617
252988
  SETTLEMINT_WORKSPACE: env2.SETTLEMINT_WORKSPACE,
252618
252989
  SETTLEMINT_APPLICATION: env2.SETTLEMINT_APPLICATION,
252619
252990
  SETTLEMINT_BLOCKCHAIN_NETWORK: env2.SETTLEMINT_BLOCKCHAIN_NETWORK,
252991
+ SETTLEMINT_BLOCKCHAIN_NETWORK_CHAIN_ID: env2.SETTLEMINT_BLOCKCHAIN_NETWORK_CHAIN_ID,
252620
252992
  SETTLEMINT_BLOCKCHAIN_NODE: env2.SETTLEMINT_BLOCKCHAIN_NODE,
252621
- SETTLEMINT_LOAD_BALANCER: env2.SETTLEMINT_LOAD_BALANCER,
252993
+ SETTLEMINT_BLOCKCHAIN_NODE_JSON_RPC_ENDPOINT: env2.SETTLEMINT_BLOCKCHAIN_NODE_JSON_RPC_ENDPOINT,
252994
+ SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER: env2.SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER,
252995
+ SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER_JSON_RPC_ENDPOINT: env2.SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER_JSON_RPC_ENDPOINT,
252622
252996
  SETTLEMINT_HASURA: env2.SETTLEMINT_HASURA,
252623
252997
  SETTLEMINT_HASURA_ENDPOINT: env2.SETTLEMINT_HASURA_ENDPOINT,
252624
252998
  SETTLEMINT_THEGRAPH: env2.SETTLEMINT_THEGRAPH,
@@ -252653,6 +253027,14 @@ async function writeEnvSpinner(prod, env2) {
252653
253027
  });
252654
253028
  }
252655
253029
 
253030
+ // src/utils/blockchain-network.ts
253031
+ function getBlockchainNetworkChainId(blockchainNetwork) {
253032
+ if (!blockchainNetwork) {
253033
+ return;
253034
+ }
253035
+ return "chainId" in blockchainNetwork && typeof blockchainNetwork.chainId === "number" ? blockchainNetwork.chainId.toString() : undefined;
253036
+ }
253037
+
252656
253038
  // src/utils/get-cluster-service-endpoint.ts
252657
253039
  async function getGraphEndpoint(settlemint, service, graphName) {
252658
253040
  if (!service || service.__typename !== "HAGraphMiddleware") {
@@ -252726,6 +253108,51 @@ function getMinioEndpoints(service) {
252726
253108
  SETTLEMINT_MINIO_SECRET_KEY: service?.credentials.find((credential) => credential.id.includes("secret-key"))?.displayValue
252727
253109
  };
252728
253110
  }
253111
+ function getBlockchainNodeEndpoints(service) {
253112
+ if (!service) {
253113
+ return {};
253114
+ }
253115
+ return {
253116
+ SETTLEMINT_BLOCKCHAIN_NODE_JSON_RPC_ENDPOINT: service.endpoints.find((endpoint) => endpoint.id.includes("json-rpc"))?.displayValue
253117
+ };
253118
+ }
253119
+ function getBlockchainNodeOrLoadBalancerEndpoints(service) {
253120
+ if (!service) {
253121
+ return {};
253122
+ }
253123
+ return {
253124
+ SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER_JSON_RPC_ENDPOINT: service.endpoints.find((endpoint) => endpoint.id.includes("json-rpc"))?.displayValue
253125
+ };
253126
+ }
253127
+
253128
+ // src/prompts/cluster-service/blockchain-node-or-load-balancer.prompt.ts
253129
+ async function blockchainNodeOrLoadBalancerPrompt({
253130
+ env: env2,
253131
+ nodes,
253132
+ loadBalancers,
253133
+ accept,
253134
+ singleOptionMessage,
253135
+ promptMessage,
253136
+ filterRunningOnly = false,
253137
+ isRequired = false
253138
+ }) {
253139
+ return servicePrompt({
253140
+ env: env2,
253141
+ services: [...loadBalancers, ...nodes],
253142
+ accept,
253143
+ envKey: "SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER",
253144
+ isRequired,
253145
+ defaultHandler: async ({ defaultService: defaultNode, choices }) => {
253146
+ const filteredChoices = filterRunningOnly ? choices.filter(({ value: node }) => node === undefined || node?.status === "COMPLETED") : choices;
253147
+ return esm_default3({
253148
+ message: promptMessage ?? "Which blockchain node or load balancer do you want to connect to?",
253149
+ choices: filteredChoices,
253150
+ default: defaultNode
253151
+ });
253152
+ },
253153
+ singleOptionMessage
253154
+ });
253155
+ }
252729
253156
 
252730
253157
  // src/commands/connect.ts
252731
253158
  function connectCommand() {
@@ -252746,11 +253173,30 @@ function connectCommand() {
252746
253173
  const workspace = await workspacePrompt(env2, workspaces, acceptDefaults);
252747
253174
  const application = await applicationPrompt(env2, workspace?.applications ?? [], acceptDefaults);
252748
253175
  const aatToken = await applicationAccessTokenPrompt(env2, application, settlemint, acceptDefaults);
252749
- const { middlewares, integrationTools, storages, privateKeys, insights, customDeployments, blockchainNodes } = await servicesSpinner(settlemint, application.uniqueName);
253176
+ const {
253177
+ middlewares,
253178
+ integrationTools,
253179
+ storages,
253180
+ privateKeys,
253181
+ insights,
253182
+ customDeployments,
253183
+ blockchainNodes,
253184
+ loadBalancers
253185
+ } = await servicesSpinner(settlemint, application.uniqueName);
253186
+ const nodesWithPrivateKey = blockchainNodes.filter(hasPrivateKey);
252750
253187
  const blockchainNode = await blockchainNodePrompt({
252751
253188
  env: env2,
252752
- nodes: blockchainNodes,
252753
- accept: acceptDefaults
253189
+ nodes: nodesWithPrivateKey,
253190
+ accept: acceptDefaults,
253191
+ promptMessage: "Which blockchain node do you want to use for sending transactions?"
253192
+ });
253193
+ const nodesWithoutPrivateKey = blockchainNodes.filter((node) => !hasPrivateKey(node));
253194
+ const loadBalancerOrBlockchainNode = await blockchainNodeOrLoadBalancerPrompt({
253195
+ env: env2,
253196
+ nodes: nodesWithoutPrivateKey,
253197
+ loadBalancers,
253198
+ accept: acceptDefaults,
253199
+ promptMessage: "Which load balancer or blockchain node do you want to use for read operations?"
252754
253200
  });
252755
253201
  const hasura = await hasuraPrompt({
252756
253202
  env: env2,
@@ -252816,10 +253262,15 @@ function connectCommand() {
252816
253262
  uniqueName: blockchainNode.blockchainNetwork?.uniqueName
252817
253263
  },
252818
253264
  blockchainNode && {
252819
- type: "Blockchain Node",
253265
+ type: "Blockchain Node (use for sending transactions)",
252820
253266
  name: blockchainNode.name,
252821
253267
  uniqueName: blockchainNode.uniqueName
252822
253268
  },
253269
+ loadBalancerOrBlockchainNode && {
253270
+ type: "Load Balancer or Blockchain Node (use for read operations)",
253271
+ name: loadBalancerOrBlockchainNode.name,
253272
+ uniqueName: loadBalancerOrBlockchainNode.uniqueName
253273
+ },
252823
253274
  hasura && {
252824
253275
  type: "Hasura",
252825
253276
  name: hasura.name,
@@ -252869,7 +253320,11 @@ function connectCommand() {
252869
253320
  SETTLEMINT_WORKSPACE: workspace.uniqueName,
252870
253321
  SETTLEMINT_APPLICATION: application.uniqueName,
252871
253322
  SETTLEMINT_BLOCKCHAIN_NETWORK: blockchainNode?.blockchainNetwork?.uniqueName,
253323
+ SETTLEMINT_BLOCKCHAIN_NETWORK_CHAIN_ID: getBlockchainNetworkChainId(blockchainNode?.blockchainNetwork),
252872
253324
  SETTLEMINT_BLOCKCHAIN_NODE: blockchainNode?.uniqueName,
253325
+ ...getBlockchainNodeEndpoints(blockchainNode),
253326
+ SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER: loadBalancerOrBlockchainNode?.uniqueName,
253327
+ ...getBlockchainNodeOrLoadBalancerEndpoints(loadBalancerOrBlockchainNode),
252873
253328
  SETTLEMINT_HASURA: hasura?.uniqueName,
252874
253329
  ...getHasuraEndpoints(hasura),
252875
253330
  SETTLEMINT_THEGRAPH: thegraph?.uniqueName,
@@ -256211,7 +256666,8 @@ var SETTLEMINT_CLIENT_MAP = {
256211
256666
  "integration tool": "integrationTool",
256212
256667
  storage: "storage",
256213
256668
  insights: "insights",
256214
- "application access token": "applicationAccessToken"
256669
+ "application access token": "applicationAccessToken",
256670
+ "load balancer": "loadBalancer"
256215
256671
  };
256216
256672
  var LABELS_MAP = {
256217
256673
  application: { singular: "application", plural: "applications", command: "app" },
@@ -256232,7 +256688,8 @@ var LABELS_MAP = {
256232
256688
  singular: "application access token",
256233
256689
  plural: "application access tokens",
256234
256690
  command: "application-access-token"
256235
- }
256691
+ },
256692
+ "load balancer": { singular: "load balancer", plural: "load balancers", command: "load-balancer" }
256236
256693
  };
256237
256694
 
256238
256695
  // src/spinners/service.spinner.ts
@@ -256734,7 +257191,10 @@ function getCreateCommand({
256734
257191
  usePersonalAccessToken = true,
256735
257192
  requiresDeployment = true
256736
257193
  }) {
256737
- const cmd2 = new Command(sanitizeCommandName(name3)).alias(alias).description(`Create a new ${subType ? `${subType} ${type4}` : type4} in the SettleMint platform.`).usage(createExamples(examples)).argument("<name>", `The ${subType ? `${subType} ${type4}` : type4} name`).option("-a, --accept-defaults", "Accept the default values").option("-d, --default", `Save as default ${type4}`).option("--prod", "Connect to production environment");
257194
+ const cmd2 = new Command(sanitizeCommandName(name3)).description(`Create a new ${subType ? `${subType} ${type4}` : type4} in the SettleMint platform.`).usage(createExamples(examples)).argument("<name>", `The ${subType ? `${subType} ${type4}` : type4} name`).option("-a, --accept-defaults", "Accept the default values").option("-d, --default", `Save as default ${type4}`).option("--prod", "Connect to production environment");
257195
+ if (alias) {
257196
+ cmd2.alias(alias);
257197
+ }
256738
257198
  if (requiresDeployment) {
256739
257199
  cmd2.option("-w, --wait", "Wait until deployed").option("-r, --restart-if-timeout", "Restart if wait time is exceeded");
256740
257200
  }
@@ -256804,7 +257264,10 @@ function getCreateCommand({
256804
257264
  newEnv.SETTLEMINT_WORKSPACE = (await settlemint.application.read(updatedEnv.SETTLEMINT_APPLICATION)).workspace.uniqueName;
256805
257265
  }
256806
257266
  if (newEnv.SETTLEMINT_BLOCKCHAIN_NODE && newEnv.SETTLEMINT_BLOCKCHAIN_NODE !== env2.SETTLEMINT_BLOCKCHAIN_NODE) {
256807
- newEnv.SETTLEMINT_BLOCKCHAIN_NETWORK = (await settlemint.blockchainNode.read(newEnv.SETTLEMINT_BLOCKCHAIN_NODE)).blockchainNetwork.uniqueName;
257267
+ const newNode = await settlemint.blockchainNode.read(newEnv.SETTLEMINT_BLOCKCHAIN_NODE);
257268
+ newEnv.SETTLEMINT_BLOCKCHAIN_NETWORK = newNode.blockchainNetwork.uniqueName;
257269
+ newEnv.SETTLEMINT_BLOCKCHAIN_NETWORK_CHAIN_ID = getBlockchainNetworkChainId(newNode.blockchainNetwork);
257270
+ newEnv.SETTLEMINT_BLOCKCHAIN_NODE_JSON_RPC_ENDPOINT = getBlockchainNodeEndpoints(newNode).SETTLEMINT_BLOCKCHAIN_NODE_JSON_RPC_ENDPOINT;
256808
257271
  }
256809
257272
  await writeEnvSpinner(!!prod, newEnv);
256810
257273
  note(`${capitalizeFirstLetter2(type4)} ${result.name} set as default`);
@@ -256876,7 +257339,11 @@ function blockchainNetworkBesuCreateCommand() {
256876
257339
  return {
256877
257340
  SETTLEMINT_APPLICATION: applicationUniqueName,
256878
257341
  SETTLEMINT_BLOCKCHAIN_NETWORK: result.uniqueName,
256879
- SETTLEMINT_BLOCKCHAIN_NODE: blockchainNode?.uniqueName
257342
+ SETTLEMINT_BLOCKCHAIN_NETWORK_CHAIN_ID: getBlockchainNetworkChainId(result),
257343
+ SETTLEMINT_BLOCKCHAIN_NODE: blockchainNode?.uniqueName,
257344
+ ...getBlockchainNodeEndpoints(blockchainNode),
257345
+ SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER: undefined,
257346
+ ...getBlockchainNodeOrLoadBalancerEndpoints(undefined)
256880
257347
  };
256881
257348
  }
256882
257349
  };
@@ -257322,12 +257789,14 @@ function blockscoutInsightsCreateCommand() {
257322
257789
  return missingApplication();
257323
257790
  }
257324
257791
  let blockchainNodeUniqueName = loadBalancer ? undefined : blockchainNode ?? env2.SETTLEMINT_BLOCKCHAIN_NODE;
257325
- const loadBalancerUniqueName = blockchainNodeUniqueName ? undefined : loadBalancer ?? env2.SETTLEMINT_LOAD_BALANCER;
257792
+ const loadBalancerUniqueName = blockchainNodeUniqueName ? undefined : loadBalancer ?? env2.SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER;
257326
257793
  if (!blockchainNodeUniqueName && !loadBalancerUniqueName) {
257327
257794
  const blockchainNodes = await serviceSpinner("blockchain node", () => settlemint.blockchainNode.list(applicationUniqueName));
257328
- const node = await blockchainNodePrompt({
257795
+ const loadBalancers = await serviceSpinner("load balancer", () => settlemint.loadBalancer.list(applicationUniqueName));
257796
+ const node = await blockchainNodeOrLoadBalancerPrompt({
257329
257797
  env: env2,
257330
257798
  nodes: blockchainNodes,
257799
+ loadBalancers,
257331
257800
  accept: acceptDefaults,
257332
257801
  isRequired: true
257333
257802
  });
@@ -257440,6 +257909,116 @@ function integrationToolCreateCommand() {
257440
257909
  return cmd2;
257441
257910
  }
257442
257911
 
257912
+ // src/commands/platform/load-balancer/evm/create.ts
257913
+ function loadBalancerEvmCreateCommand() {
257914
+ return getCreateCommand({
257915
+ name: "evm",
257916
+ type: "load balancer",
257917
+ subType: "EVM",
257918
+ execute: (cmd2, baseAction) => {
257919
+ addClusterServiceArgs(cmd2).option("--app, --application <application>", "The application unique name to create the load balancer in (defaults to application from env)").option("--blockchain-nodes <blockchainNodes...>", "Blockchain node unique names where the load balancer connects to (must be from the same network)").option("--blockchain-network <blockchainNetwork>", "Blockchain network unique name where the load balancer connects to").action(async (name3, {
257920
+ application,
257921
+ provider,
257922
+ region,
257923
+ size,
257924
+ type: type4,
257925
+ blockchainNodes,
257926
+ blockchainNetwork,
257927
+ acceptDefaults,
257928
+ ...defaultArgs
257929
+ }) => {
257930
+ return baseAction({
257931
+ ...defaultArgs,
257932
+ acceptDefaults,
257933
+ provider,
257934
+ region
257935
+ }, async ({ settlemint, env: env2, showSpinner, provider: provider2, region: region2 }) => {
257936
+ const applicationUniqueName = application ?? env2.SETTLEMINT_APPLICATION;
257937
+ if (!applicationUniqueName) {
257938
+ return missingApplication();
257939
+ }
257940
+ const applicationBlockchainNodes = await serviceSpinner("blockchain node", () => settlemint.blockchainNode.list(applicationUniqueName));
257941
+ let networkUniqueName = blockchainNetwork;
257942
+ let connectedNodesUniqueNames = blockchainNodes;
257943
+ if (!connectedNodesUniqueNames) {
257944
+ const networks = await serviceSpinner("blockchain network", () => settlemint.blockchainNetwork.list(applicationUniqueName));
257945
+ const network = networkUniqueName ? networks.find((network2) => network2.uniqueName === networkUniqueName) : await blockchainNetworkPrompt({
257946
+ env: env2,
257947
+ networks,
257948
+ accept: acceptDefaults,
257949
+ isRequired: true
257950
+ });
257951
+ if (!network) {
257952
+ return nothingSelectedError("blockchain network");
257953
+ }
257954
+ networkUniqueName = network.uniqueName;
257955
+ const connectedNodes = await blockchainNodePrompt({
257956
+ env: env2,
257957
+ nodes: applicationBlockchainNodes.filter((node) => node.blockchainNetwork?.uniqueName === network.uniqueName),
257958
+ accept: acceptDefaults,
257959
+ promptMessage: "Which blockchain node do you want to connect the load balancer to?",
257960
+ allowAll: true
257961
+ });
257962
+ connectedNodesUniqueNames = Array.isArray(connectedNodes) ? applicationBlockchainNodes.map((node) => node.uniqueName) : connectedNodes ? [connectedNodes.uniqueName] : [];
257963
+ }
257964
+ if (connectedNodesUniqueNames.length === 0) {
257965
+ return cancel2("A load balancer must connect to at least one blockchain node");
257966
+ }
257967
+ const selectedBlockchainNodes = applicationBlockchainNodes.filter((node) => connectedNodesUniqueNames.includes(node.uniqueName));
257968
+ if (selectedBlockchainNodes.length === 0) {
257969
+ return cancel2(`Blockchain node(s) '${connectedNodesUniqueNames.join(", ")}' are not part of the application '${applicationUniqueName}'`);
257970
+ }
257971
+ if (!networkUniqueName) {
257972
+ networkUniqueName = selectedBlockchainNodes[0].blockchainNetwork?.uniqueName;
257973
+ }
257974
+ const onTheSameNetwork = selectedBlockchainNodes.every((node) => node.blockchainNetwork?.uniqueName === networkUniqueName);
257975
+ if (!onTheSameNetwork) {
257976
+ return cancel2("Blockchain nodes must be on the same network");
257977
+ }
257978
+ const result = await showSpinner(() => settlemint.loadBalancer.create({
257979
+ applicationUniqueName,
257980
+ name: name3,
257981
+ blockchainNetworkUniqueName: networkUniqueName,
257982
+ provider: provider2,
257983
+ region: region2,
257984
+ size,
257985
+ type: type4,
257986
+ connectedNodesUniqueNames
257987
+ }));
257988
+ return {
257989
+ result,
257990
+ mapDefaultEnv: () => {
257991
+ return {
257992
+ SETTLEMINT_APPLICATION: applicationUniqueName,
257993
+ SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER: result.uniqueName
257994
+ };
257995
+ }
257996
+ };
257997
+ });
257998
+ });
257999
+ },
258000
+ examples: [
258001
+ {
258002
+ description: "Create an EVM load balancer and save as default",
258003
+ command: "platform create load-balancer evm my-lb --accept-defaults -d"
258004
+ },
258005
+ {
258006
+ description: "Create an EVM load balancer and connect to specific blockchain nodes",
258007
+ command: "platform create load-balancer evm my-lb --blockchain-network my-network --accept-defaults"
258008
+ },
258009
+ {
258010
+ description: "Create an EVM load balancer in a different application",
258011
+ command: "platform create load-balancer evm my-lb --application my-app --accept-defaults"
258012
+ }
258013
+ ]
258014
+ });
258015
+ }
258016
+
258017
+ // src/commands/platform/load-balancer/create.ts
258018
+ function loadBalancerCreateCommand() {
258019
+ return new Command("load-balancer").alias("lb").description("Create a load balancer in the SettleMint platform").addCommand(loadBalancerEvmCreateCommand());
258020
+ }
258021
+
257443
258022
  // src/commands/platform/middleware/graph/create.ts
257444
258023
  function graphMiddlewareCreateCommand() {
257445
258024
  return getCreateCommand({
@@ -257448,7 +258027,7 @@ function graphMiddlewareCreateCommand() {
257448
258027
  subType: "The Graph",
257449
258028
  alias: "gr",
257450
258029
  execute: (cmd2, baseAction) => {
257451
- addClusterServiceArgs(cmd2).option("--application <application>", "Application unique name").option("--blockchain-node <blockchainNode>", "Blockchain Node unique name").action(async (name3, { application, blockchainNode, provider, region, size, type: type4, acceptDefaults, ...defaultArgs }) => {
258030
+ addClusterServiceArgs(cmd2).option("--application <application>", "Application unique name").option("--blockchain-node <blockchainNode>", "Blockchain Node unique name (mutually exclusive with load-balancer)").option("--load-balancer <loadBalancer>", "Load Balancer unique name (mutually exclusive with blockchain-node)").action(async (name3, { application, blockchainNode, loadBalancer, provider, region, size, type: type4, acceptDefaults, ...defaultArgs }) => {
257452
258031
  return baseAction({
257453
258032
  ...defaultArgs,
257454
258033
  acceptDefaults,
@@ -257460,24 +258039,32 @@ function graphMiddlewareCreateCommand() {
257460
258039
  return missingApplication();
257461
258040
  }
257462
258041
  let blockchainNodeUniqueName = blockchainNode;
257463
- if (!blockchainNodeUniqueName) {
258042
+ let loadBalancerUniqueName = loadBalancer;
258043
+ if (!blockchainNodeUniqueName && !loadBalancerUniqueName) {
257464
258044
  const blockchainNodes = await serviceSpinner("blockchain node", () => settlemint.blockchainNode.list(applicationUniqueName));
257465
- const node = await blockchainNodePrompt({
258045
+ const loadBalancers = await serviceSpinner("load balancer", () => settlemint.loadBalancer.list(applicationUniqueName));
258046
+ const nodeOrLoadbalancer = await blockchainNodeOrLoadBalancerPrompt({
257466
258047
  env: env2,
257467
258048
  nodes: blockchainNodes,
258049
+ loadBalancers,
257468
258050
  accept: acceptDefaults,
257469
258051
  isRequired: true
257470
258052
  });
257471
- if (!node) {
257472
- return nothingSelectedError("blockchain node");
258053
+ if (!nodeOrLoadbalancer) {
258054
+ return nothingSelectedError("blockchain node or load balancer");
258055
+ }
258056
+ if (nodeOrLoadbalancer.__typename?.endsWith("LoadBalancer")) {
258057
+ loadBalancerUniqueName = nodeOrLoadbalancer.uniqueName;
258058
+ } else {
258059
+ blockchainNodeUniqueName = nodeOrLoadbalancer.uniqueName;
257473
258060
  }
257474
- blockchainNodeUniqueName = node.uniqueName;
257475
258061
  }
257476
258062
  const result = await showSpinner(() => settlemint.middleware.create({
257477
258063
  name: name3,
257478
258064
  applicationUniqueName,
257479
258065
  interface: "HA_GRAPH",
257480
258066
  blockchainNodeUniqueName,
258067
+ loadBalancerUniqueName,
257481
258068
  provider: provider2,
257482
258069
  region: region2,
257483
258070
  size,
@@ -257543,12 +258130,12 @@ function smartContractPortalMiddlewareCreateCommand() {
257543
258130
  return missingApplication();
257544
258131
  }
257545
258132
  let blockchainNodeUniqueName = loadBalancer ? undefined : blockchainNode ?? env2.SETTLEMINT_BLOCKCHAIN_NODE;
257546
- const loadBalancerUniqueName = blockchainNodeUniqueName ? undefined : loadBalancer ?? env2.SETTLEMINT_LOAD_BALANCER;
258133
+ const loadBalancerUniqueName = blockchainNodeUniqueName ? undefined : loadBalancer ?? env2.SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER;
257547
258134
  if (!blockchainNodeUniqueName && !loadBalancerUniqueName) {
257548
258135
  const blockchainNodes = await serviceSpinner("blockchain node", () => settlemint.blockchainNode.list(applicationUniqueName));
257549
258136
  const node = await blockchainNodePrompt({
257550
258137
  env: env2,
257551
- nodes: blockchainNodes,
258138
+ nodes: blockchainNodes.filter(hasValidPrivateKey),
257552
258139
  accept: acceptDefaults,
257553
258140
  isRequired: true
257554
258141
  });
@@ -257926,7 +258513,7 @@ function storageCreateCommand() {
257926
258513
 
257927
258514
  // src/commands/platform/create.ts
257928
258515
  function createCommand3() {
257929
- return new Command("create").alias("c").description("Create a resource in the SettleMint platform").addCommand(workspaceCreateCommand()).addCommand(applicationCreateCommand()).addCommand(blockchainNetworkCreateCommand()).addCommand(blockchainNodeCreateCommand()).addCommand(privateKeyCreateCommand()).addCommand(middlewareCreateCommand()).addCommand(storageCreateCommand()).addCommand(integrationToolCreateCommand()).addCommand(insightsCreateCommand()).addCommand(applicationAccessTokenCreateCommand());
258516
+ return new Command("create").alias("c").description("Create a resource in the SettleMint platform").addCommand(workspaceCreateCommand()).addCommand(applicationCreateCommand()).addCommand(blockchainNetworkCreateCommand()).addCommand(blockchainNodeCreateCommand()).addCommand(privateKeyCreateCommand()).addCommand(middlewareCreateCommand()).addCommand(storageCreateCommand()).addCommand(integrationToolCreateCommand()).addCommand(insightsCreateCommand()).addCommand(applicationAccessTokenCreateCommand()).addCommand(loadBalancerCreateCommand());
257930
258517
  }
257931
258518
 
257932
258519
  // src/prompts/delete-confirmation.prompt.ts
@@ -258166,6 +258753,19 @@ function integrationToolRestartCommand() {
258166
258753
  return new Command("integration-tool").alias("it").description("Restart an integration tool service in the SettleMint platform").addCommand(hasuraRestartCommand());
258167
258754
  }
258168
258755
 
258756
+ // src/commands/platform/load-balancer/restart.ts
258757
+ function loadBalancerRestartCommand() {
258758
+ return getRestartCommand({
258759
+ name: "load-balancer",
258760
+ type: "load balancer",
258761
+ alias: "lb",
258762
+ envKey: "SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER",
258763
+ restartFunction: async (settlemint, id) => {
258764
+ return settlemint.loadBalancer.restart(id);
258765
+ }
258766
+ });
258767
+ }
258768
+
258169
258769
  // src/commands/platform/middleware/graph/restart.ts
258170
258770
  function graphRestartCommand() {
258171
258771
  return getRestartCommand({
@@ -258232,7 +258832,7 @@ function storageRestartCommand() {
258232
258832
 
258233
258833
  // src/commands/platform/restart.ts
258234
258834
  function restartCommand() {
258235
- const cmd2 = new Command("restart").description("Restart a resource in the SettleMint platform").addCommand(blockchainNetworkRestartCommand()).addCommand(customDeploymentRestartCommand()).addCommand(insightsRestartCommand()).addCommand(integrationToolRestartCommand()).addCommand(middlewareRestartCommand()).addCommand(storageRestartCommand());
258835
+ const cmd2 = new Command("restart").description("Restart a resource in the SettleMint platform").addCommand(blockchainNetworkRestartCommand()).addCommand(customDeploymentRestartCommand()).addCommand(insightsRestartCommand()).addCommand(integrationToolRestartCommand()).addCommand(middlewareRestartCommand()).addCommand(storageRestartCommand()).addCommand(loadBalancerRestartCommand());
258236
258836
  return cmd2;
258237
258837
  }
258238
258838
 
@@ -259075,38 +259675,6 @@ function getStatusAction(status) {
259075
259675
  return "Please try again later.";
259076
259676
  }
259077
259677
 
259078
- // src/prompts/smart-contract-set/address.prompt.ts
259079
- async function addressPrompt({
259080
- env: env2,
259081
- accept,
259082
- prod,
259083
- node,
259084
- hardhatConfig
259085
- }) {
259086
- const possiblePrivateKeys = node.privateKeys?.filter((privateKey) => validPrivateKey(privateKey)) ?? [];
259087
- const defaultAddress = hardhatConfig.networks?.btp?.from ?? possiblePrivateKeys[0]?.address;
259088
- const defaultPossible = accept && defaultAddress;
259089
- if (defaultPossible) {
259090
- if (possiblePrivateKeys.some((privateKey) => privateKey.address?.toLowerCase() === defaultAddress?.toLowerCase())) {
259091
- return defaultAddress;
259092
- }
259093
- note(`Private key with address '${defaultAddress}' is not activated on the node '${node.uniqueName}'.
259094
- Please select another key or activate this key on the node and try again.`, "warn");
259095
- }
259096
- const address = await esm_default3({
259097
- message: "Which private key do you want to deploy from?",
259098
- choices: possiblePrivateKeys.map(({ address: address2, name: name3 }) => ({
259099
- name: name3,
259100
- value: address2
259101
- })),
259102
- default: defaultAddress ?? possiblePrivateKeys[0]?.address
259103
- });
259104
- return address;
259105
- }
259106
- function validPrivateKey(privateKey) {
259107
- return privateKey.privateKeyType !== "HD_ECDSA_P256";
259108
- }
259109
-
259110
259678
  // src/commands/smart-contract-set/hardhat/utils/select-target-node.ts
259111
259679
  async function selectTargetNode({
259112
259680
  env: env2,
@@ -259130,6 +259698,7 @@ async function selectTargetNode({
259130
259698
  nodes: validNodes,
259131
259699
  accept: autoAccept,
259132
259700
  isRequired: true,
259701
+ filterRunningOnly: true,
259133
259702
  promptMessage: "Which blockchain node do you want to connect to? (Only nodes with private keys activated are shown)",
259134
259703
  singleOptionMessage: (node2) => `Using '${node2}' - the only node with active private keys. To use a different node, ensure it has a private key activated.`
259135
259704
  });
@@ -259151,7 +259720,7 @@ function validateNode(node, cancelOnError = true) {
259151
259720
  }
259152
259721
  return false;
259153
259722
  }
259154
- if (node.privateKeys?.filter((privateKey) => validPrivateKey(privateKey)).length === 0) {
259723
+ if (!hasValidPrivateKey(node)) {
259155
259724
  if (cancelOnError) {
259156
259725
  cancel2(`The specified blockchain node '${node.uniqueName}' does not have an ECDSA P256 or HSM ECDSA P256 private key activated. Please activate an ECDSA P256 or HSM ECDSA P256 private key on your node and try again.`);
259157
259726
  }
@@ -259166,26 +259735,61 @@ function validateNode(node, cancelOnError = true) {
259166
259735
  return true;
259167
259736
  }
259168
259737
 
259738
+ // src/prompts/smart-contract-set/address.prompt.ts
259739
+ async function addressPrompt({
259740
+ accept,
259741
+ node,
259742
+ hardhatConfig
259743
+ }) {
259744
+ const possiblePrivateKeys = node.privateKeys?.filter(isValidPrivateKey) ?? [];
259745
+ const defaultAddress = hardhatConfig.networks?.btp?.from ?? possiblePrivateKeys[0]?.address;
259746
+ const defaultPossible = accept && defaultAddress;
259747
+ if (defaultPossible) {
259748
+ if (possiblePrivateKeys.some((privateKey) => privateKey.address?.toLowerCase() === defaultAddress?.toLowerCase())) {
259749
+ return defaultAddress;
259750
+ }
259751
+ note(`Private key with address '${defaultAddress}' is not activated on the node '${node.uniqueName}'.
259752
+ Please select another key or activate this key on the node and try again.`, "warn");
259753
+ }
259754
+ const address = await esm_default3({
259755
+ message: "Which private key do you want to deploy from?",
259756
+ choices: possiblePrivateKeys.map(({ address: address2, name: name3 }) => ({
259757
+ name: name3,
259758
+ value: address2
259759
+ })),
259760
+ default: defaultAddress
259761
+ });
259762
+ return address;
259763
+ }
259764
+
259169
259765
  // src/utils/smart-contract-set/hardhat-config.ts
259170
259766
  async function getHardhatConfigData(envConfig) {
259171
259767
  try {
259172
259768
  const { command, args } = await getPackageManagerExecutable();
259173
- const output = await executeCommand(command, [...args, "ts-node", "-e", `import hardhat from "hardhat";
259174
- console.log(JSON.stringify(hardhat.userConfig));`], {
259769
+ const output = await executeCommand(command, [
259770
+ ...args,
259771
+ "ts-node",
259772
+ "-e",
259773
+ `import hardhat from "hardhat";
259774
+ console.log(JSON.stringify(hardhat.userConfig));`,
259775
+ "--transpileOnly"
259776
+ ], {
259175
259777
  env: {
259176
259778
  ...process.env,
259177
259779
  ...envConfig
259178
259780
  },
259179
259781
  silent: true
259180
259782
  });
259181
- const config3 = tryParseJson3(output.join(" "));
259783
+ const config3 = extractJsonObject(output.join(" "));
259182
259784
  if (isHardhatConfig(config3)) {
259183
259785
  return config3;
259184
259786
  }
259185
- throw new Error("Invalid hardhat config");
259787
+ throw new Error(`Invalid hardhat config: ${output.join(`
259788
+ `)}`);
259186
259789
  } catch (err) {
259187
259790
  const error5 = err;
259188
- note(`Error reading hardhat.config.ts: ${error5.message}`);
259791
+ note(`Error reading hardhat.config.ts: ${error5.output?.join(`
259792
+ `) ?? error5.message}`);
259189
259793
  return {};
259190
259794
  }
259191
259795
  }
@@ -259255,7 +259859,7 @@ function hardhatDeployRemoteCommand() {
259255
259859
  }
259256
259860
  let address = defaultSender ?? null;
259257
259861
  if (!defaultSender) {
259258
- address = await addressPrompt({ env: env2, accept: autoAccept, prod, node, hardhatConfig });
259862
+ address = await addressPrompt({ accept: autoAccept, node, hardhatConfig });
259259
259863
  }
259260
259864
  if (!address) {
259261
259865
  return nothingSelectedError("private key");
@@ -259901,4 +260505,4 @@ async function sdkCliCommand(argv = process.argv) {
259901
260505
  // src/cli.ts
259902
260506
  sdkCliCommand();
259903
260507
 
259904
- //# debugId=1494D9014EC88D8864756E2164756E21
260508
+ //# debugId=BD6E2B1FD50C256064756E2164756E21