@vleap/warps-adapter-fastset 0.1.0-alpha.32 → 0.1.0-alpha.33

package/dist/index.js

@@ -7,8 +7,8 @@ var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -250,14 +250,16 @@ function toHex(bytes) {
 
 // ../../node_modules/@mysten/bcs/dist/esm/uleb.js
 function ulebEncode(num) {
+  let bigNum = BigInt(num);
   const arr = [];
   let len = 0;
-  if (num === 0) {
+  if (bigNum === 0n) {
     return [0];
   }
-  while (num > 0) {
-    arr[len] = num & 127;
-    if (num >>= 7) {
+  while (bigNum > 0) {
+    arr[len] = Number(bigNum & 0x7fn);
+    bigNum >>= 7n;
+    if (bigNum > 0n) {
       arr[len] |= 128;
     }
     len += 1;
@@ -265,20 +267,26 @@ function ulebEncode(num) {
   return arr;
 }
 function ulebDecode(arr) {
-  let total = 0;
-  let shift = 0;
+  let total = 0n;
+  let shift = 0n;
   let len = 0;
   while (true) {
+    if (len >= arr.length) {
+      throw new Error("ULEB decode error: buffer overflow");
+    }
     const byte = arr[len];
     len += 1;
-    total |= (byte & 127) << shift;
+    total += BigInt(byte & 127) << shift;
     if ((byte & 128) === 0) {
       break;
     }
-    shift += 7;
+    shift += 7n;
+  }
+  if (total > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error("ULEB decode error: value exceeds MAX_SAFE_INTEGER");
   }
   return {
-    value: total,
+    value: Number(total),
     length: len
   };
 }
@@ -426,7 +434,10 @@ var BcsWriter = class {
   ensureSizeOrGrow(bytes) {
     const requiredSize = this.bytePosition + bytes;
     if (requiredSize > this.size) {
-      const nextSize = Math.min(this.maxSize, this.size + this.allocateSize);
+      const nextSize = Math.min(
+        this.maxSize,
+        Math.max(this.size + requiredSize, this.size + this.allocateSize)
+      );
       if (requiredSize > nextSize) {
         throw new Error(
           `Attempting to serialize to BCS, but buffer does not have enough size. Allocated size: ${this.size}, Max size: ${this.maxSize}, Required size: ${requiredSize}`
@@ -458,6 +469,18 @@ var BcsWriter = class {
     this.dataView.setUint8(this.bytePosition, Number(value));
     return this.shift(1);
   }
+  /**
+   * Write a U8 value into a buffer and shift cursor position by 1.
+   * @param {Number} value Value to write.
+   * @returns {this}
+   */
+  writeBytes(bytes) {
+    this.ensureSizeOrGrow(bytes.length);
+    for (let i = 0; i < bytes.length; i++) {
+      this.dataView.setUint8(this.bytePosition + i, bytes[i]);
+    }
+    return this.shift(bytes.length);
+  }
   /**
    * Write a U16 value into a buffer and shift cursor position by 2.
    * @param {Number} value Value to write.
@@ -534,6 +557,7 @@ var BcsWriter = class {
    * Adds support for iterations over the object.
    * @returns {Uint8Array}
    */
+  // oxlint-disable-next-line require-yields
   *[Symbol.iterator]() {
     for (let i = 0; i < this.bytePosition; i++) {
       yield this.dataView.getUint8(i);
@@ -619,13 +643,13 @@ var _BcsType = class _BcsType2 {
     return this.parse(fromBase64(b64));
   }
   transform({
-    name: name2,
+    name,
     input,
     output,
     validate
   }) {
     return new _BcsType2({
-      name: name2 ?? this.name,
+      name: name ?? this.name,
       read: (reader) => output ? output(this.read(reader)) : this.read(reader),
       write: (value, writer) => __privateGet(this, _write).call(this, input ? input(value) : value, writer),
       serializedSize: (value) => this.serializedSize(input ? input(value) : value),
@@ -735,7 +759,7 @@ function dynamicSizeBcsType({
   return type;
 }
 function stringLikeBcsType({
-  toBytes: toBytes2,
+  toBytes,
   fromBytes,
   ...options
 }) {
@@ -747,14 +771,14 @@ function stringLikeBcsType({
       return fromBytes(bytes);
     },
     write: (hex, writer) => {
-      const bytes = toBytes2(hex);
+      const bytes = toBytes(hex);
       writer.writeULEB(bytes.length);
       for (let i = 0; i < bytes.length; i++) {
         writer.write8(bytes[i]);
       }
     },
     serialize: (value) => {
-      const bytes = toBytes2(value);
+      const bytes = toBytes(value);
       const size = ulebEncode(bytes.length);
       const result = new Uint8Array(size.length + bytes.length);
       result.set(size, 0);
@@ -786,10 +810,10 @@ function lazyBcsType(cb) {
   });
 }
 var BcsStruct = class extends BcsType {
-  constructor({ name: name2, fields, ...options }) {
+  constructor({ name, fields, ...options }) {
     const canonicalOrder = Object.entries(fields);
     super({
-      name: name2,
+      name,
       serializedSize: (values) => {
         let total = 0;
         for (const [field, type] of canonicalOrder) {
@@ -831,7 +855,7 @@ var BcsEnum = class extends BcsType {
         const index = reader.readULEB();
         const enumEntry = canonicalOrder[index];
         if (!enumEntry) {
-          throw new TypeError(`Unknown value ${index} for enum ${name}`);
+          throw new TypeError(`Unknown value ${index} for enum ${options.name}`);
         }
         const [kind, type] = enumEntry;
         return {
@@ -840,12 +864,12 @@ var BcsEnum = class extends BcsType {
         };
       },
       write: (value, writer) => {
-        const [name2, val] = Object.entries(value).filter(
-          ([name3]) => Object.hasOwn(fields, name3)
+        const [name, val] = Object.entries(value).filter(
+          ([name2]) => Object.hasOwn(fields, name2)
         )[0];
         for (let i = 0; i < canonicalOrder.length; i++) {
           const [optionName, optionType] = canonicalOrder[i];
-          if (optionName === name2) {
+          if (optionName === name) {
             writer.writeULEB(i);
             optionType?.write(val, writer);
             return;
@@ -863,7 +887,7 @@ var BcsEnum = class extends BcsType {
         );
         if (keys.length !== 1) {
           throw new TypeError(
-            `Expected object with one key, but found ${keys.length} for type ${name}}`
+            `Expected object with one key, but found ${keys.length} for type ${options.name}}`
           );
         }
         const [variant] = keys;
@@ -875,9 +899,9 @@ var BcsEnum = class extends BcsType {
   }
 };
 var BcsTuple = class extends BcsType {
-  constructor({ fields, name: name2, ...options }) {
+  constructor({ fields, name, ...options }) {
     super({
-      name: name2 ?? `(${fields.map((t) => t.name).join(", ")})`,
+      name: name ?? `(${fields.map((t) => t.name).join(", ")})`,
       serializedSize: (values) => {
         let total = 0;
         for (let i = 0; i < fields.length; i++) {
@@ -1140,10 +1164,7 @@ var bcs = {
       size,
       read: (reader) => reader.readBytes(size),
       write: (value, writer) => {
-        const array = new Uint8Array(value);
-        for (let i = 0; i < size; i++) {
-          writer.write8(array[i] ?? 0);
-        }
+        writer.writeBytes(new Uint8Array(value));
       },
       ...options,
       name: options?.name ?? `bytes[${size}]`,
@@ -1173,9 +1194,7 @@ var bcs = {
       write: (value, writer) => {
         const array = new Uint8Array(value);
         writer.writeULEB(array.length);
-        for (let i = 0; i < array.length; i++) {
-          writer.write8(array[i] ?? 0);
-        }
+        writer.writeBytes(array);
       },
       ...options,
       name: options?.name ?? "vector<u8>",
@@ -1254,9 +1273,9 @@ var bcs = {
    * })
    * struct.serialize({ a: 1, b: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
    */
-  struct(name2, fields, options) {
+  struct(name, fields, options) {
     return new BcsStruct({
-      name: name2,
+      name,
       fields,
       ...options
     });
@@ -1277,9 +1296,9 @@ var bcs = {
    * enum.serialize({ B: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
    * enum.serialize({ C: true }).toBytes() // Uint8Array [ 2 ]
    */
-  enum(name2, fields, options) {
+  enum(name, fields, options) {
     return new BcsEnum({
-      name: name2,
+      name,
       fields,
       ...options
     });
@@ -2037,10 +2056,10 @@ var invert = (num, md) => {
   }
   return b === 1n ? M(x, md) : err("no inverse");
 };
-var callHash = (name2) => {
-  const fn = hashes[name2];
+var callHash = (name) => {
+  const fn = hashes[name];
   if (typeof fn !== "function")
-    err("hashes." + name2 + " not set");
+    err("hashes." + name + " not set");
   return fn;
 };
 var hash = (msg) => callHash("sha512")(msg);
@@ -2455,15 +2474,21 @@ var wNAF = (n) => {
   return { p, f };
 };
 
-// ../../node_modules/@noble/hashes/esm/utils.js
+// node_modules/@noble/hashes/utils.js
 function isBytes3(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
 }
-function abytes2(b, ...lengths) {
-  if (!isBytes3(b))
-    throw new Error("Uint8Array expected");
-  if (lengths.length > 0 && !lengths.includes(b.length))
-    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+function abytes2(value, length, title = "") {
+  const bytes = isBytes3(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
 }
 function aexists(instance, checkFinished = true) {
   if (instance.destroyed)
@@ -2472,10 +2497,10 @@ function aexists(instance, checkFinished = true) {
     throw new Error("Hash#digest() has already been called");
 }
 function aoutput(out, instance) {
-  abytes2(out);
+  abytes2(out, void 0, "digestInto() output");
   const min = instance.outputLen;
   if (out.length < min) {
-    throw new Error("digestInto() expects output buffer of length at least " + min);
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
   }
 }
 function clean(...arrays) {
@@ -2486,48 +2511,33 @@ function clean(...arrays) {
 function createView(arr) {
   return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
-function utf8ToBytes(str) {
-  if (typeof str !== "string")
-    throw new Error("string expected");
-  return new Uint8Array(new TextEncoder().encode(str));
-}
-function toBytes(data) {
-  if (typeof data === "string")
-    data = utf8ToBytes(data);
-  abytes2(data);
-  return data;
-}
-var Hash = class {
-};
-function createHasher(hashCons) {
-  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
-  const tmp = hashCons();
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
   hashC.outputLen = tmp.outputLen;
   hashC.blockLen = tmp.blockLen;
-  hashC.create = () => hashCons();
-  return hashC;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
 }
+var oidNist = (suffix) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
 
-// ../../node_modules/@noble/hashes/esm/_md.js
-function setBigUint64(view, byteOffset, value, isLE) {
-  if (typeof view.setBigUint64 === "function")
-    return view.setBigUint64(byteOffset, value, isLE);
-  const _32n2 = BigInt(32);
-  const _u32_max = BigInt(4294967295);
-  const wh = Number(value >> _32n2 & _u32_max);
-  const wl = Number(value & _u32_max);
-  const h2 = isLE ? 4 : 0;
-  const l = isLE ? 0 : 4;
-  view.setUint32(byteOffset + h2, wh, isLE);
-  view.setUint32(byteOffset + l, wl, isLE);
-}
-var HashMD = class extends Hash {
+// node_modules/@noble/hashes/_md.js
+var HashMD = class {
   constructor(blockLen, outputLen, padOffset, isLE) {
-    super();
-    this.finished = false;
-    this.length = 0;
-    this.pos = 0;
-    this.destroyed = false;
+    __publicField(this, "blockLen");
+    __publicField(this, "outputLen");
+    __publicField(this, "padOffset");
+    __publicField(this, "isLE");
+    // For partial updates less than block size
+    __publicField(this, "buffer");
+    __publicField(this, "view");
+    __publicField(this, "finished", false);
+    __publicField(this, "length", 0);
+    __publicField(this, "pos", 0);
+    __publicField(this, "destroyed", false);
     this.blockLen = blockLen;
     this.outputLen = outputLen;
     this.padOffset = padOffset;
@@ -2537,7 +2547,6 @@ var HashMD = class extends Hash {
   }
   update(data) {
     aexists(this);
-    data = toBytes(data);
     abytes2(data);
     const { view, buffer, blockLen } = this;
     const len = data.length;
@@ -2575,12 +2584,12 @@ var HashMD = class extends Hash {
     }
     for (let i = pos; i < blockLen; i++)
       buffer[i] = 0;
-    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
     this.process(view, 0);
     const oview = createView(out);
     const len = this.outputLen;
     if (len % 4)
-      throw new Error("_sha2: outputLen should be aligned to 32bit");
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
     const outLen = len / 4;
     const state = this.get();
     if (outLen > state.length)
@@ -2630,7 +2639,7 @@ var SHA512_IV = /* @__PURE__ */ Uint32Array.from([
   327033209
 ]);
 
-// ../../node_modules/@noble/hashes/esm/_u64.js
+// node_modules/@noble/hashes/_u64.js
 var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
 var _32n = /* @__PURE__ */ BigInt(32);
 function fromBig(n, le = false) {
@@ -2665,7 +2674,7 @@ var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0
 var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
 var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
 
-// ../../node_modules/@noble/hashes/esm/sha2.js
+// node_modules/@noble/hashes/sha2.js
 var K512 = /* @__PURE__ */ (() => split([
   "0x428a2f98d728ae22",
   "0x7137449123ef65cd",
@@ -2752,25 +2761,9 @@ var SHA512_Kh = /* @__PURE__ */ (() => K512[0])();
 var SHA512_Kl = /* @__PURE__ */ (() => K512[1])();
 var SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
 var SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
-var SHA512 = class extends HashMD {
-  constructor(outputLen = 64) {
+var SHA2_64B = class extends HashMD {
+  constructor(outputLen) {
     super(128, outputLen, 16, false);
-    this.Ah = SHA512_IV[0] | 0;
-    this.Al = SHA512_IV[1] | 0;
-    this.Bh = SHA512_IV[2] | 0;
-    this.Bl = SHA512_IV[3] | 0;
-    this.Ch = SHA512_IV[4] | 0;
-    this.Cl = SHA512_IV[5] | 0;
-    this.Dh = SHA512_IV[6] | 0;
-    this.Dl = SHA512_IV[7] | 0;
-    this.Eh = SHA512_IV[8] | 0;
-    this.El = SHA512_IV[9] | 0;
-    this.Fh = SHA512_IV[10] | 0;
-    this.Fl = SHA512_IV[11] | 0;
-    this.Gh = SHA512_IV[12] | 0;
-    this.Gl = SHA512_IV[13] | 0;
-    this.Hh = SHA512_IV[14] | 0;
-    this.Hl = SHA512_IV[15] | 0;
   }
   // prettier-ignore
   get() {
@@ -2863,13 +2856,34 @@ var SHA512 = class extends HashMD {
     this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
   }
 };
-var sha512 = /* @__PURE__ */ createHasher(() => new SHA512());
-
-// ../../node_modules/@noble/hashes/esm/sha512.js
-var sha5122 = sha512;
+var _SHA512 = class extends SHA2_64B {
+  constructor() {
+    super(64);
+    __publicField(this, "Ah", SHA512_IV[0] | 0);
+    __publicField(this, "Al", SHA512_IV[1] | 0);
+    __publicField(this, "Bh", SHA512_IV[2] | 0);
+    __publicField(this, "Bl", SHA512_IV[3] | 0);
+    __publicField(this, "Ch", SHA512_IV[4] | 0);
+    __publicField(this, "Cl", SHA512_IV[5] | 0);
+    __publicField(this, "Dh", SHA512_IV[6] | 0);
+    __publicField(this, "Dl", SHA512_IV[7] | 0);
+    __publicField(this, "Eh", SHA512_IV[8] | 0);
+    __publicField(this, "El", SHA512_IV[9] | 0);
+    __publicField(this, "Fh", SHA512_IV[10] | 0);
+    __publicField(this, "Fl", SHA512_IV[11] | 0);
+    __publicField(this, "Gh", SHA512_IV[12] | 0);
+    __publicField(this, "Gl", SHA512_IV[13] | 0);
+    __publicField(this, "Hh", SHA512_IV[14] | 0);
+    __publicField(this, "Hl", SHA512_IV[15] | 0);
+  }
+};
+var sha512 = /* @__PURE__ */ createHasher(
+  () => new _SHA512(),
+  /* @__PURE__ */ oidNist(3)
+);
 
 // src/sdk/ed25519-setup.ts
-hashes.sha512 = sha5122;
+hashes.sha512 = sha512;
 
 // src/WarpFastsetWallet.ts
 var WarpFastsetWallet = class {
@@ -3006,7 +3020,7 @@ var getFastsetAdapter = createFastsetAdapter(import_warps6.WarpChainName.Fastset
 @noble/ed25519/index.js:
   (*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) *)
 
-@noble/hashes/esm/utils.js:
+@noble/hashes/utils.js:
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 //# sourceMappingURL=index.js.map