@heyamiko/amiko-cli 0.19.0 → 0.20.0

package/dist/index.js

@@ -5,43 +5,25 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
+        get: () => mod[key],
         enumerable: true
       });
-  if (canCache)
-    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: __exportSetter.bind(all, name)
+      set: (newValue) => all[name] = () => newValue
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -861,7 +843,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          }
+          } else {}
         };
       }
       return this;
@@ -3596,7 +3578,7 @@ function getHumanReadableErrorMessage(code, context = {}) {
 function getErrorMessage(code, context = {}) {
   if (true) {
     return getHumanReadableErrorMessage(code, context);
-  }
+  } else {}
 }
 function isSolanaError(e, code) {
   const isSolanaError2 = e instanceof Error && e.name === "SolanaError";
@@ -7660,20 +7642,8 @@ var init_src3 = __esm(() => {
   }
 });
 
-// node_modules/mppx/node_modules/ox/node_modules/@noble/curves/esm/abstract/utils.js
-function equalBytes(a, b) {
-  if (a.length !== b.length)
-    return false;
-  let diff = 0;
-  for (let i = 0;i < a.length; i++)
-    diff |= a[i] ^ b[i];
-  return diff === 0;
-}
-var hasHexBuiltin;
-var init_utils = __esm(() => {
-  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
-});
+// node_modules/mppx/node_modules/ox/_esm/core/Abi.js
+var init_Abi = () => {};
 
 // node_modules/mppx/node_modules/ox/_esm/core/version.js
 var version = "0.1.1";
@@ -7818,827 +7788,187 @@ var init_Errors = __esm(() => {
   })();
 });
 
-// node_modules/mppx/node_modules/ox/_esm/core/internal/bytes.js
-function assertSize(bytes, size_) {
-  if (size(bytes) > size_)
-    throw new SizeOverflowError({
-      givenSize: size(bytes),
-      maxSize: size_
-    });
+// node_modules/@noble/hashes/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
 }
-function assertStartOffset(value, start) {
-  if (typeof start === "number" && start > 0 && start > size(value) - 1)
-    throw new SliceOffsetOutOfBoundsError({
-      offset: start,
-      position: "start",
-      size: size(value)
-    });
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
 }
-function assertEndOffset(value, start, end) {
-  if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
-    throw new SliceOffsetOutOfBoundsError({
-      offset: end,
-      position: "end",
-      size: size(value)
-    });
-  }
+function abytes(b, ...lengths) {
+  if (!isBytes(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 charCodeToBase16(char) {
-  if (char >= charCodeMap.zero && char <= charCodeMap.nine)
-    return char - charCodeMap.zero;
-  if (char >= charCodeMap.A && char <= charCodeMap.F)
-    return char - (charCodeMap.A - 10);
-  if (char >= charCodeMap.a && char <= charCodeMap.f)
-    return char - (charCodeMap.a - 10);
-  return;
+function ahash(h) {
+  if (typeof h !== "function" || typeof h.create !== "function")
+    throw new Error("Hash should be wrapped by utils.createHasher");
+  anumber(h.outputLen);
+  anumber(h.blockLen);
 }
-function pad2(bytes, options2 = {}) {
-  const { dir, size: size2 = 32 } = options2;
-  if (size2 === 0)
-    return bytes;
-  if (bytes.length > size2)
-    throw new SizeExceedsPaddingSizeError({
-      size: bytes.length,
-      targetSize: size2,
-      type: "Bytes"
-    });
-  const paddedBytes = new Uint8Array(size2);
-  for (let i = 0;i < size2; i++) {
-    const padEnd = dir === "right";
-    paddedBytes[padEnd ? i : size2 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
-  }
-  return paddedBytes;
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
 }
-function trim(value, options2 = {}) {
-  const { dir = "left" } = options2;
-  let data = value;
-  let sliceLength = 0;
-  for (let i = 0;i < data.length - 1; i++) {
-    if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
-      sliceLength++;
-    else
-      break;
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
   }
-  data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
-  return data;
-}
-var charCodeMap;
-var init_bytes = __esm(() => {
-  init_Bytes();
-  charCodeMap = {
-    zero: 48,
-    nine: 57,
-    A: 65,
-    F: 70,
-    a: 97,
-    f: 102
-  };
-});
-
-// node_modules/mppx/node_modules/ox/_esm/core/internal/hex.js
-function assertSize2(hex, size_) {
-  if (size2(hex) > size_)
-    throw new SizeOverflowError2({
-      givenSize: size2(hex),
-      maxSize: size_
-    });
 }
-function pad3(hex_, options2 = {}) {
-  const { dir, size: size3 = 32 } = options2;
-  if (size3 === 0)
-    return hex_;
-  const hex = hex_.replace("0x", "");
-  if (hex.length > size3 * 2)
-    throw new SizeExceedsPaddingSizeError2({
-      size: Math.ceil(hex.length / 2),
-      targetSize: size3,
-      type: "Hex"
-    });
-  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
 }
-var init_hex = __esm(() => {
-  init_Hex();
-});
-
-// node_modules/mppx/node_modules/ox/_esm/core/Json.js
-var exports_Json = {};
-__export(exports_Json, {
-  stringify: () => stringify2,
-  parse: () => parse,
-  canonicalize: () => canonicalize
-});
-function canonicalize(value) {
-  if (value === null || typeof value === "boolean" || typeof value === "string")
-    return JSON.stringify(value);
-  if (typeof value === "number") {
-    if (!Number.isFinite(value))
-      throw new TypeError("Cannot canonicalize non-finite number");
-    return Object.is(value, -0) ? "0" : JSON.stringify(value);
-  }
-  if (typeof value === "bigint")
-    throw new TypeError("Cannot canonicalize bigint");
-  if (Array.isArray(value))
-    return `[${value.map((item) => canonicalize(item)).join(",")}]`;
-  if (typeof value === "object") {
-    const entries = Object.keys(value).sort().reduce((acc, key) => {
-      const v = value[key];
-      if (v !== undefined)
-        acc.push(`${JSON.stringify(key)}:${canonicalize(v)}`);
-      return acc;
-    }, []);
-    return `{${entries.join(",")}}`;
+function clean(...arrays) {
+  for (let i = 0;i < arrays.length; i++) {
+    arrays[i].fill(0);
   }
-  return;
 }
-function parse(string, reviver) {
-  return JSON.parse(string, (key, value_) => {
-    const value = value_;
-    if (typeof value === "string" && value.endsWith(bigIntSuffix))
-      return BigInt(value.slice(0, -bigIntSuffix.length));
-    return typeof reviver === "function" ? reviver(key, value) : value;
-  });
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
-function stringify2(value, replacer, space) {
-  return JSON.stringify(value, (key, value2) => {
-    if (typeof replacer === "function")
-      return replacer(key, value2);
-    if (typeof value2 === "bigint")
-      return value2.toString() + bigIntSuffix;
-    return value2;
-  }, space);
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
 }
-var bigIntSuffix = "#__bigint";
-
-// node_modules/mppx/node_modules/ox/_esm/core/Hex.js
-function assert(value, options2 = {}) {
-  const { strict = false } = options2;
-  if (!value)
-    throw new InvalidHexTypeError(value);
-  if (typeof value !== "string")
-    throw new InvalidHexTypeError(value);
-  if (strict) {
-    if (!/^0x[0-9a-fA-F]*$/.test(value))
-      throw new InvalidHexValueError(value);
-  }
-  if (!value.startsWith("0x"))
-    throw new InvalidHexValueError(value);
+function rotl(word, shift) {
+  return word << shift | word >>> 32 - shift >>> 0;
 }
-function fromBytes(value, options2 = {}) {
-  let string = "";
-  for (let i = 0;i < value.length; i++)
-    string += hexes[value[i]];
-  const hex = `0x${string}`;
-  if (typeof options2.size === "number") {
-    assertSize2(hex, options2.size);
-    return padRight(hex, options2.size);
-  }
-  return hex;
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
 }
-function fromNumber(value, options2 = {}) {
-  const { signed, size: size3 } = options2;
-  const value_ = BigInt(value);
-  let maxValue;
-  if (size3) {
-    if (signed)
-      maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
-    else
-      maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
-  } else if (typeof value === "number") {
-    maxValue = BigInt(Number.MAX_SAFE_INTEGER);
-  }
-  const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
-  if (maxValue && value_ > maxValue || value_ < minValue) {
-    const suffix = typeof value === "bigint" ? "n" : "";
-    throw new IntegerOutOfRangeError({
-      max: maxValue ? `${maxValue}${suffix}` : undefined,
-      min: `${minValue}${suffix}`,
-      signed,
-      size: size3,
-      value: `${value}${suffix}`
-    });
+function byteSwap32(arr) {
+  for (let i = 0;i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
   }
-  const stringValue = (signed && value_ < 0 ? BigInt.asUintN(size3 * 8, BigInt(value_)) : value_).toString(16);
-  const hex = `0x${stringValue}`;
-  if (size3)
-    return padLeft(hex, size3);
-  return hex;
-}
-function padLeft(value, size3) {
-  return pad3(value, { dir: "left", size: size3 });
-}
-function padRight(value, size3) {
-  return pad3(value, { dir: "right", size: size3 });
+  return arr;
 }
-function size2(value) {
-  return Math.ceil((value.length - 2) / 2);
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
 }
-function toBigInt(hex, options2 = {}) {
-  const { signed } = options2;
-  if (options2.size)
-    assertSize2(hex, options2.size);
-  const value = BigInt(hex);
-  if (!signed)
-    return value;
-  const size3 = (hex.length - 2) / 2;
-  const max_unsigned = (1n << BigInt(size3) * 8n) - 1n;
-  const max_signed = max_unsigned >> 1n;
-  if (value <= max_signed)
-    return value;
-  return value - max_unsigned - 1n;
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
 }
-function toNumber(hex, options2 = {}) {
-  const { signed, size: size3 } = options2;
-  if (!signed && !size3)
-    return Number(hex);
-  return Number(toBigInt(hex, options2));
+
+class Hash {
 }
-function validate2(value, options2 = {}) {
-  const { strict = false } = options2;
-  try {
-    assert(value, { strict });
-    return true;
-  } catch {
-    return false;
-  }
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
 }
-var hexes, IntegerOutOfRangeError, InvalidHexTypeError, InvalidHexValueError, SizeOverflowError2, SizeExceedsPaddingSizeError2;
-var init_Hex = __esm(() => {
-  init_Errors();
-  init_hex();
-  hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
-  IntegerOutOfRangeError = class IntegerOutOfRangeError extends BaseError {
-    constructor({ max, min, signed, size: size3, value }) {
-      super(`Number \`${value}\` is not in safe${size3 ? ` ${size3 * 8}-bit` : ""}${signed ? " signed" : " unsigned"} integer range ${max ? `(\`${min}\` to \`${max}\`)` : `(above \`${min}\`)`}`);
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Hex.IntegerOutOfRangeError"
-      });
+var isLE, swap32IfBE;
+var init_utils = __esm(() => {
+  /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+  isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+  swap32IfBE = isLE ? (u) => u : byteSwap32;
+});
+
+// node_modules/@noble/hashes/esm/hmac.js
+var HMAC, hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+var init_hmac = __esm(() => {
+  init_utils();
+  HMAC = class HMAC extends Hash {
+    constructor(hash, _key) {
+      super();
+      this.finished = false;
+      this.destroyed = false;
+      ahash(hash);
+      const key = toBytes(_key);
+      this.iHash = hash.create();
+      if (typeof this.iHash.update !== "function")
+        throw new Error("Expected instance of class which extends utils.Hash");
+      this.blockLen = this.iHash.blockLen;
+      this.outputLen = this.iHash.outputLen;
+      const blockLen = this.blockLen;
+      const pad2 = new Uint8Array(blockLen);
+      pad2.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+      for (let i = 0;i < pad2.length; i++)
+        pad2[i] ^= 54;
+      this.iHash.update(pad2);
+      this.oHash = hash.create();
+      for (let i = 0;i < pad2.length; i++)
+        pad2[i] ^= 54 ^ 92;
+      this.oHash.update(pad2);
+      clean(pad2);
     }
-  };
-  InvalidHexTypeError = class InvalidHexTypeError extends BaseError {
-    constructor(value) {
-      super(`Value \`${typeof value === "object" ? stringify2(value) : value}\` of type \`${typeof value}\` is an invalid hex type.`, {
-        metaMessages: ['Hex types must be represented as `"0x${string}"`.']
-      });
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Hex.InvalidHexTypeError"
-      });
+    update(buf) {
+      aexists(this);
+      this.iHash.update(buf);
+      return this;
     }
-  };
-  InvalidHexValueError = class InvalidHexValueError extends BaseError {
-    constructor(value) {
-      super(`Value \`${value}\` is an invalid hex value.`, {
-        metaMessages: [
-          'Hex values must start with `"0x"` and contain only hexadecimal characters (0-9, a-f, A-F).'
-        ]
-      });
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Hex.InvalidHexValueError"
-      });
+    digestInto(out) {
+      aexists(this);
+      abytes(out, this.outputLen);
+      this.finished = true;
+      this.iHash.digestInto(out);
+      this.oHash.update(out);
+      this.oHash.digestInto(out);
+      this.destroy();
     }
-  };
-  SizeOverflowError2 = class SizeOverflowError2 extends BaseError {
-    constructor({ givenSize, maxSize }) {
-      super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Hex.SizeOverflowError"
-      });
+    digest() {
+      const out = new Uint8Array(this.oHash.outputLen);
+      this.digestInto(out);
+      return out;
     }
-  };
-  SizeExceedsPaddingSizeError2 = class SizeExceedsPaddingSizeError2 extends BaseError {
-    constructor({ size: size3, targetSize, type }) {
-      super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size3}\`) exceeds padding size (\`${targetSize}\`).`);
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Hex.SizeExceedsPaddingSizeError"
-      });
+    _cloneInto(to) {
+      to || (to = Object.create(Object.getPrototypeOf(this), {}));
+      const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+      to = to;
+      to.finished = finished;
+      to.destroyed = destroyed;
+      to.blockLen = blockLen;
+      to.outputLen = outputLen;
+      to.oHash = oHash._cloneInto(to.oHash);
+      to.iHash = iHash._cloneInto(to.iHash);
+      return to;
+    }
+    clone() {
+      return this._cloneInto();
+    }
+    destroy() {
+      this.destroyed = true;
+      this.oHash.destroy();
+      this.iHash.destroy();
     }
   };
+  hmac.create = (hash, key) => new HMAC(hash, key);
 });
 
-// node_modules/mppx/node_modules/ox/_esm/core/Bytes.js
-var exports_Bytes = {};
-__export(exports_Bytes, {
-  validate: () => validate3,
-  trimRight: () => trimRight,
-  trimLeft: () => trimLeft,
-  toString: () => toString,
-  toNumber: () => toNumber2,
-  toHex: () => toHex,
-  toBoolean: () => toBoolean,
-  toBigInt: () => toBigInt2,
-  slice: () => slice,
-  size: () => size,
-  random: () => random,
-  padRight: () => padRight2,
-  padLeft: () => padLeft2,
-  isEqual: () => isEqual,
-  fromString: () => fromString,
-  fromNumber: () => fromNumber2,
-  fromHex: () => fromHex,
-  fromBoolean: () => fromBoolean,
-  fromArray: () => fromArray,
-  from: () => from,
-  concat: () => concat,
-  assert: () => assert2,
-  SliceOffsetOutOfBoundsError: () => SliceOffsetOutOfBoundsError,
-  SizeOverflowError: () => SizeOverflowError,
-  SizeExceedsPaddingSizeError: () => SizeExceedsPaddingSizeError,
-  InvalidBytesTypeError: () => InvalidBytesTypeError,
-  InvalidBytesBooleanError: () => InvalidBytesBooleanError
-});
-function assert2(value) {
-  if (value instanceof Uint8Array)
-    return;
-  if (!value)
-    throw new InvalidBytesTypeError(value);
-  if (typeof value !== "object")
-    throw new InvalidBytesTypeError(value);
-  if (!("BYTES_PER_ELEMENT" in value))
-    throw new InvalidBytesTypeError(value);
-  if (value.BYTES_PER_ELEMENT !== 1 || value.constructor.name !== "Uint8Array")
-    throw new InvalidBytesTypeError(value);
-}
-function concat(...values) {
-  let length = 0;
-  for (const arr of values) {
-    length += arr.length;
-  }
-  const result = new Uint8Array(length);
-  for (let i = 0, index = 0;i < values.length; i++) {
-    const arr = values[i];
-    result.set(arr, index);
-    index += arr.length;
-  }
-  return result;
-}
-function from(value) {
-  if (value instanceof Uint8Array)
-    return value;
-  if (typeof value === "string")
-    return fromHex(value);
-  return fromArray(value);
+// node_modules/@noble/hashes/esm/_md.js
+function setBigUint64(view, byteOffset, value, isLE2) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE2);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE2 ? 4 : 0;
+  const l = isLE2 ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE2);
+  view.setUint32(byteOffset + l, wl, isLE2);
 }
-function fromArray(value) {
-  return value instanceof Uint8Array ? value : new Uint8Array(value);
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
 }
-function fromBoolean(value, options2 = {}) {
-  const { size: size3 } = options2;
-  const bytes = new Uint8Array(1);
-  bytes[0] = Number(value);
-  if (typeof size3 === "number") {
-    assertSize(bytes, size3);
-    return padLeft2(bytes, size3);
-  }
-  return bytes;
-}
-function fromHex(value, options2 = {}) {
-  const { size: size3 } = options2;
-  let hex = value;
-  if (size3) {
-    assertSize2(value, size3);
-    hex = padRight(value, size3);
-  }
-  let hexString = hex.slice(2);
-  if (hexString.length % 2)
-    hexString = `0${hexString}`;
-  const length = hexString.length / 2;
-  const bytes = new Uint8Array(length);
-  for (let index = 0, j = 0;index < length; index++) {
-    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
-    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
-    if (nibbleLeft === undefined || nibbleRight === undefined) {
-      throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
-    }
-    bytes[index] = nibbleLeft << 4 | nibbleRight;
-  }
-  return bytes;
-}
-function fromNumber2(value, options2) {
-  const hex = fromNumber(value, options2);
-  return fromHex(hex);
-}
-function fromString(value, options2 = {}) {
-  const { size: size3 } = options2;
-  const bytes = encoder.encode(value);
-  if (typeof size3 === "number") {
-    assertSize(bytes, size3);
-    return padRight2(bytes, size3);
-  }
-  return bytes;
-}
-function isEqual(bytesA, bytesB) {
-  return equalBytes(bytesA, bytesB);
-}
-function padLeft2(value, size3) {
-  return pad2(value, { dir: "left", size: size3 });
-}
-function padRight2(value, size3) {
-  return pad2(value, { dir: "right", size: size3 });
-}
-function random(length) {
-  return crypto.getRandomValues(new Uint8Array(length));
-}
-function size(value) {
-  return value.length;
-}
-function slice(value, start, end, options2 = {}) {
-  const { strict } = options2;
-  assertStartOffset(value, start);
-  const value_ = value.slice(start, end);
-  if (strict)
-    assertEndOffset(value_, start, end);
-  return value_;
-}
-function toBigInt2(bytes, options2 = {}) {
-  const { size: size3 } = options2;
-  if (typeof size3 !== "undefined")
-    assertSize(bytes, size3);
-  const hex = fromBytes(bytes, options2);
-  return toBigInt(hex, options2);
-}
-function toBoolean(bytes, options2 = {}) {
-  const { size: size3 } = options2;
-  let bytes_ = bytes;
-  if (typeof size3 !== "undefined") {
-    assertSize(bytes_, size3);
-    bytes_ = trimLeft(bytes_);
-  }
-  if (bytes_.length > 1 || bytes_[0] > 1)
-    throw new InvalidBytesBooleanError(bytes_);
-  return Boolean(bytes_[0]);
-}
-function toHex(value, options2 = {}) {
-  return fromBytes(value, options2);
-}
-function toNumber2(bytes, options2 = {}) {
-  const { size: size3 } = options2;
-  if (typeof size3 !== "undefined")
-    assertSize(bytes, size3);
-  const hex = fromBytes(bytes, options2);
-  return toNumber(hex, options2);
-}
-function toString(bytes, options2 = {}) {
-  const { size: size3 } = options2;
-  let bytes_ = bytes;
-  if (typeof size3 !== "undefined") {
-    assertSize(bytes_, size3);
-    bytes_ = trimRight(bytes_);
-  }
-  return decoder.decode(bytes_);
-}
-function trimLeft(value) {
-  return trim(value, { dir: "left" });
-}
-function trimRight(value) {
-  return trim(value, { dir: "right" });
-}
-function validate3(value) {
-  try {
-    assert2(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var decoder, encoder, InvalidBytesBooleanError, InvalidBytesTypeError, SizeOverflowError, SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
-var init_Bytes = __esm(() => {
-  init_utils();
-  init_Errors();
-  init_Hex();
-  init_bytes();
-  init_hex();
-  decoder = /* @__PURE__ */ new TextDecoder;
-  encoder = /* @__PURE__ */ new TextEncoder;
-  InvalidBytesBooleanError = class InvalidBytesBooleanError extends BaseError {
-    constructor(bytes) {
-      super(`Bytes value \`${bytes}\` is not a valid boolean.`, {
-        metaMessages: [
-          "The bytes array must contain a single byte of either a `0` or `1` value."
-        ]
-      });
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Bytes.InvalidBytesBooleanError"
-      });
-    }
-  };
-  InvalidBytesTypeError = class InvalidBytesTypeError extends BaseError {
-    constructor(value) {
-      super(`Value \`${typeof value === "object" ? stringify2(value) : value}\` of type \`${typeof value}\` is an invalid Bytes value.`, {
-        metaMessages: ["Bytes values must be of type `Bytes`."]
-      });
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Bytes.InvalidBytesTypeError"
-      });
-    }
-  };
-  SizeOverflowError = class SizeOverflowError extends BaseError {
-    constructor({ givenSize, maxSize }) {
-      super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Bytes.SizeOverflowError"
-      });
-    }
-  };
-  SliceOffsetOutOfBoundsError = class SliceOffsetOutOfBoundsError extends BaseError {
-    constructor({ offset, position, size: size3 }) {
-      super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size3}\`).`);
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Bytes.SliceOffsetOutOfBoundsError"
-      });
-    }
-  };
-  SizeExceedsPaddingSizeError = class SizeExceedsPaddingSizeError extends BaseError {
-    constructor({ size: size3, targetSize, type }) {
-      super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size3}\`) exceeds padding size (\`${targetSize}\`).`);
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Bytes.SizeExceedsPaddingSizeError"
-      });
-    }
-  };
-});
-
-// node_modules/mppx/node_modules/ox/_esm/core/Base64.js
-var exports_Base64 = {};
-__export(exports_Base64, {
-  toString: () => toString2,
-  toHex: () => toHex2,
-  toBytes: () => toBytes,
-  fromString: () => fromString2,
-  fromHex: () => fromHex2,
-  fromBytes: () => fromBytes2
-});
-function fromBytes2(value, options2 = {}) {
-  const { pad: pad4 = true, url = false } = options2;
-  const encoded = new Uint8Array(Math.ceil(value.length / 3) * 4);
-  for (let i = 0, j = 0;j < value.length; i += 4, j += 3) {
-    const y = (value[j] << 16) + (value[j + 1] << 8) + (value[j + 2] | 0);
-    encoded[i] = integerToCharacter[y >> 18];
-    encoded[i + 1] = integerToCharacter[y >> 12 & 63];
-    encoded[i + 2] = integerToCharacter[y >> 6 & 63];
-    encoded[i + 3] = integerToCharacter[y & 63];
-  }
-  const k = value.length % 3;
-  const end = Math.floor(value.length / 3) * 4 + (k && k + 1);
-  let base64 = decoder2.decode(new Uint8Array(encoded.buffer, 0, end));
-  if (pad4 && k === 1)
-    base64 += "==";
-  if (pad4 && k === 2)
-    base64 += "=";
-  if (url)
-    base64 = base64.replaceAll("+", "-").replaceAll("/", "_");
-  return base64;
-}
-function fromHex2(value, options2 = {}) {
-  return fromBytes2(fromHex(value), options2);
-}
-function fromString2(value, options2 = {}) {
-  return fromBytes2(fromString(value), options2);
-}
-function toBytes(value) {
-  const base64 = value.replace(/=+$/, "");
-  const size3 = base64.length;
-  const decoded = new Uint8Array(size3 + 3);
-  encoder2.encodeInto(base64 + "===", decoded);
-  for (let i = 0, j = 0;i < base64.length; i += 4, j += 3) {
-    const x = (characterToInteger[decoded[i]] << 18) + (characterToInteger[decoded[i + 1]] << 12) + (characterToInteger[decoded[i + 2]] << 6) + characterToInteger[decoded[i + 3]];
-    decoded[j] = x >> 16;
-    decoded[j + 1] = x >> 8 & 255;
-    decoded[j + 2] = x & 255;
-  }
-  const decodedSize = (size3 >> 2) * 3 + (size3 % 4 && size3 % 4 - 1);
-  return new Uint8Array(decoded.buffer, 0, decodedSize);
-}
-function toHex2(value) {
-  return fromBytes(toBytes(value));
-}
-function toString2(value) {
-  return toString(toBytes(value));
-}
-var encoder2, decoder2, integerToCharacter, characterToInteger;
-var init_Base64 = __esm(() => {
-  init_Bytes();
-  init_Hex();
-  encoder2 = /* @__PURE__ */ new TextEncoder;
-  decoder2 = /* @__PURE__ */ new TextDecoder;
-  integerToCharacter = /* @__PURE__ */ Object.fromEntries(Array.from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").map((a, i) => [i, a.charCodeAt(0)]));
-  characterToInteger = {
-    ...Object.fromEntries(Array.from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").map((a, i) => [a.charCodeAt(0), i])),
-    [61]: 0,
-    [45]: 62,
-    [95]: 63
-  };
-});
-
-// node_modules/@noble/hashes/esm/utils.js
-function isBytes(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-function anumber(n) {
-  if (!Number.isSafeInteger(n) || n < 0)
-    throw new Error("positive integer expected, got " + n);
-}
-function abytes(b, ...lengths) {
-  if (!isBytes(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 ahash(h) {
-  if (typeof h !== "function" || typeof h.create !== "function")
-    throw new Error("Hash should be wrapped by utils.createHasher");
-  anumber(h.outputLen);
-  anumber(h.blockLen);
-}
-function aexists(instance, checkFinished = true) {
-  if (instance.destroyed)
-    throw new Error("Hash instance has been destroyed");
-  if (checkFinished && instance.finished)
-    throw new Error("Hash#digest() has already been called");
-}
-function aoutput(out, instance) {
-  abytes(out);
-  const min = instance.outputLen;
-  if (out.length < min) {
-    throw new Error("digestInto() expects output buffer of length at least " + min);
-  }
-}
-function u32(arr) {
-  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-}
-function clean(...arrays) {
-  for (let i = 0;i < arrays.length; i++) {
-    arrays[i].fill(0);
-  }
-}
-function createView(arr) {
-  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-function rotr(word, shift) {
-  return word << 32 - shift | word >>> shift;
-}
-function rotl(word, shift) {
-  return word << shift | word >>> 32 - shift >>> 0;
-}
-function byteSwap(word) {
-  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
-}
-function byteSwap32(arr) {
-  for (let i = 0;i < arr.length; i++) {
-    arr[i] = byteSwap(arr[i]);
-  }
-  return arr;
-}
-function utf8ToBytes(str) {
-  if (typeof str !== "string")
-    throw new Error("string expected");
-  return new Uint8Array(new TextEncoder().encode(str));
-}
-function toBytes2(data) {
-  if (typeof data === "string")
-    data = utf8ToBytes(data);
-  abytes(data);
-  return data;
-}
-
-class Hash {
-}
-function createHasher(hashCons) {
-  const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
-  const tmp = hashCons();
-  hashC.outputLen = tmp.outputLen;
-  hashC.blockLen = tmp.blockLen;
-  hashC.create = () => hashCons();
-  return hashC;
-}
-var isLE, swap32IfBE;
-var init_utils2 = __esm(() => {
-  /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
-  swap32IfBE = isLE ? (u) => u : byteSwap32;
-});
-
-// node_modules/@noble/hashes/esm/hmac.js
-var HMAC, hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
-var init_hmac = __esm(() => {
-  init_utils2();
-  HMAC = class HMAC extends Hash {
-    constructor(hash, _key) {
-      super();
-      this.finished = false;
-      this.destroyed = false;
-      ahash(hash);
-      const key = toBytes2(_key);
-      this.iHash = hash.create();
-      if (typeof this.iHash.update !== "function")
-        throw new Error("Expected instance of class which extends utils.Hash");
-      this.blockLen = this.iHash.blockLen;
-      this.outputLen = this.iHash.outputLen;
-      const blockLen = this.blockLen;
-      const pad4 = new Uint8Array(blockLen);
-      pad4.set(key.length > blockLen ? hash.create().update(key).digest() : key);
-      for (let i = 0;i < pad4.length; i++)
-        pad4[i] ^= 54;
-      this.iHash.update(pad4);
-      this.oHash = hash.create();
-      for (let i = 0;i < pad4.length; i++)
-        pad4[i] ^= 54 ^ 92;
-      this.oHash.update(pad4);
-      clean(pad4);
-    }
-    update(buf) {
-      aexists(this);
-      this.iHash.update(buf);
-      return this;
-    }
-    digestInto(out) {
-      aexists(this);
-      abytes(out, this.outputLen);
-      this.finished = true;
-      this.iHash.digestInto(out);
-      this.oHash.update(out);
-      this.oHash.digestInto(out);
-      this.destroy();
-    }
-    digest() {
-      const out = new Uint8Array(this.oHash.outputLen);
-      this.digestInto(out);
-      return out;
-    }
-    _cloneInto(to) {
-      to || (to = Object.create(Object.getPrototypeOf(this), {}));
-      const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
-      to = to;
-      to.finished = finished;
-      to.destroyed = destroyed;
-      to.blockLen = blockLen;
-      to.outputLen = outputLen;
-      to.oHash = oHash._cloneInto(to.oHash);
-      to.iHash = iHash._cloneInto(to.iHash);
-      return to;
-    }
-    clone() {
-      return this._cloneInto();
-    }
-    destroy() {
-      this.destroyed = true;
-      this.oHash.destroy();
-      this.iHash.destroy();
-    }
-  };
-  hmac.create = (hash, key) => new HMAC(hash, key);
-});
-
-// node_modules/@noble/hashes/esm/_md.js
-function setBigUint64(view, byteOffset, value, isLE2) {
-  if (typeof view.setBigUint64 === "function")
-    return view.setBigUint64(byteOffset, value, isLE2);
-  const _32n = BigInt(32);
-  const _u32_max = BigInt(4294967295);
-  const wh = Number(value >> _32n & _u32_max);
-  const wl = Number(value & _u32_max);
-  const h = isLE2 ? 4 : 0;
-  const l = isLE2 ? 0 : 4;
-  view.setUint32(byteOffset + h, wh, isLE2);
-  view.setUint32(byteOffset + l, wl, isLE2);
-}
-function Chi(a, b, c) {
-  return a & b ^ ~a & c;
-}
-function Maj(a, b, c) {
-  return a & b ^ a & c ^ b & c;
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
 }
 var HashMD, SHA256_IV;
 var init__md = __esm(() => {
-  init_utils2();
+  init_utils();
   HashMD = class HashMD extends Hash {
     constructor(blockLen, outputLen, padOffset, isLE2) {
       super();
@@ -8655,7 +7985,7 @@ var init__md = __esm(() => {
     }
     update(data) {
       aexists(this);
-      data = toBytes2(data);
+      data = toBytes(data);
       abytes(data);
       const { view, buffer, blockLen } = this;
       const len = data.length;
@@ -8756,7 +8086,7 @@ function ripemd_f(group, x, y, z) {
 var Rho160, Id160, Pi160, idxLR, idxL, idxR, shifts160, shiftsL160, shiftsR160, Kl160, Kr160, BUF_160, RIPEMD160, ripemd160;
 var init_legacy = __esm(() => {
   init__md();
-  init_utils2();
+  init_utils();
   Rho160 = /* @__PURE__ */ Uint8Array.from([
     7,
     4,
@@ -8937,7 +8267,7 @@ function keccakP(s, rounds = 24) {
 var _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_PI, SHA3_ROTL, _SHA3_IOTA, IOTAS, SHA3_IOTA_H, SHA3_IOTA_L, rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s), rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s), Keccak, gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen)), keccak_256;
 var init_sha3 = __esm(() => {
   init__u64();
-  init_utils2();
+  init_utils();
   _0n = BigInt(0);
   _1n = BigInt(1);
   _2n = BigInt(2);
@@ -8993,7 +8323,7 @@ var init_sha3 = __esm(() => {
     }
     update(data) {
       aexists(this);
-      data = toBytes2(data);
+      data = toBytes(data);
       abytes(data);
       const { blockLen, state } = this;
       const len = data.length;
@@ -9006,283 +8336,3128 @@ var init_sha3 = __esm(() => {
       }
       return this;
     }
-    finish() {
-      if (this.finished)
-        return;
-      this.finished = true;
-      const { state, suffix, pos, blockLen } = this;
-      state[pos] ^= suffix;
-      if ((suffix & 128) !== 0 && pos === blockLen - 1)
-        this.keccak();
-      state[blockLen - 1] ^= 128;
-      this.keccak();
+    finish() {
+      if (this.finished)
+        return;
+      this.finished = true;
+      const { state, suffix, pos, blockLen } = this;
+      state[pos] ^= suffix;
+      if ((suffix & 128) !== 0 && pos === blockLen - 1)
+        this.keccak();
+      state[blockLen - 1] ^= 128;
+      this.keccak();
+    }
+    writeInto(out) {
+      aexists(this, false);
+      abytes(out);
+      this.finish();
+      const bufferOut = this.state;
+      const { blockLen } = this;
+      for (let pos = 0, len = out.length;pos < len; ) {
+        if (this.posOut >= blockLen)
+          this.keccak();
+        const take = Math.min(blockLen - this.posOut, len - pos);
+        out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+        this.posOut += take;
+        pos += take;
+      }
+      return out;
+    }
+    xofInto(out) {
+      if (!this.enableXOF)
+        throw new Error("XOF is not possible for this instance");
+      return this.writeInto(out);
+    }
+    xof(bytes) {
+      anumber(bytes);
+      return this.xofInto(new Uint8Array(bytes));
+    }
+    digestInto(out) {
+      aoutput(out, this);
+      if (this.finished)
+        throw new Error("digest() was already called");
+      this.writeInto(out);
+      this.destroy();
+      return out;
+    }
+    digest() {
+      return this.digestInto(new Uint8Array(this.outputLen));
+    }
+    destroy() {
+      this.destroyed = true;
+      clean(this.state);
+    }
+    _cloneInto(to) {
+      const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+      to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+      to.state32.set(this.state32);
+      to.pos = this.pos;
+      to.posOut = this.posOut;
+      to.finished = this.finished;
+      to.rounds = rounds;
+      to.suffix = suffix;
+      to.outputLen = outputLen;
+      to.enableXOF = enableXOF;
+      to.destroyed = this.destroyed;
+      return to;
+    }
+  };
+  keccak_256 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
+});
+
+// node_modules/@noble/hashes/esm/sha2.js
+var SHA256_K, SHA256_W, SHA256, sha256;
+var init_sha2 = __esm(() => {
+  init__md();
+  init_utils();
+  SHA256_K = /* @__PURE__ */ Uint32Array.from([
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+  ]);
+  SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+  SHA256 = class SHA256 extends HashMD {
+    constructor(outputLen = 32) {
+      super(64, outputLen, 8, false);
+      this.A = SHA256_IV[0] | 0;
+      this.B = SHA256_IV[1] | 0;
+      this.C = SHA256_IV[2] | 0;
+      this.D = SHA256_IV[3] | 0;
+      this.E = SHA256_IV[4] | 0;
+      this.F = SHA256_IV[5] | 0;
+      this.G = SHA256_IV[6] | 0;
+      this.H = SHA256_IV[7] | 0;
+    }
+    get() {
+      const { A, B, C, D: D2, E, F, G, H } = this;
+      return [A, B, C, D2, E, F, G, H];
+    }
+    set(A, B, C, D2, E, F, G, H) {
+      this.A = A | 0;
+      this.B = B | 0;
+      this.C = C | 0;
+      this.D = D2 | 0;
+      this.E = E | 0;
+      this.F = F | 0;
+      this.G = G | 0;
+      this.H = H | 0;
+    }
+    process(view, offset) {
+      for (let i = 0;i < 16; i++, offset += 4)
+        SHA256_W[i] = view.getUint32(offset, false);
+      for (let i = 16;i < 64; i++) {
+        const W15 = SHA256_W[i - 15];
+        const W2 = SHA256_W[i - 2];
+        const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+        const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+        SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+      }
+      let { A, B, C, D: D2, E, F, G, H } = this;
+      for (let i = 0;i < 64; i++) {
+        const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+        const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+        const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+        const T2 = sigma0 + Maj(A, B, C) | 0;
+        H = G;
+        G = F;
+        F = E;
+        E = D2 + T1 | 0;
+        D2 = C;
+        C = B;
+        B = A;
+        A = T1 + T2 | 0;
+      }
+      A = A + this.A | 0;
+      B = B + this.B | 0;
+      C = C + this.C | 0;
+      D2 = D2 + this.D | 0;
+      E = E + this.E | 0;
+      F = F + this.F | 0;
+      G = G + this.G | 0;
+      H = H + this.H | 0;
+      this.set(A, B, C, D2, E, F, G, H);
+    }
+    roundClean() {
+      clean(SHA256_W);
+    }
+    destroy() {
+      this.set(0, 0, 0, 0, 0, 0, 0, 0);
+      clean(this.buffer);
+    }
+  };
+  sha256 = /* @__PURE__ */ createHasher(() => new SHA256);
+});
+
+// node_modules/@noble/hashes/esm/sha256.js
+var sha2562;
+var init_sha256 = __esm(() => {
+  init_sha2();
+  sha2562 = sha256;
+});
+
+// node_modules/mppx/node_modules/ox/node_modules/@noble/curves/esm/abstract/utils.js
+function equalBytes(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0;i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+var hasHexBuiltin;
+var init_utils2 = __esm(() => {
+  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+  hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/internal/bytes.js
+function assertSize(bytes, size_) {
+  if (size(bytes) > size_)
+    throw new SizeOverflowError({
+      givenSize: size(bytes),
+      maxSize: size_
+    });
+}
+function assertStartOffset(value, start) {
+  if (typeof start === "number" && start > 0 && start > size(value) - 1)
+    throw new SliceOffsetOutOfBoundsError({
+      offset: start,
+      position: "start",
+      size: size(value)
+    });
+}
+function assertEndOffset(value, start, end) {
+  if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
+    throw new SliceOffsetOutOfBoundsError({
+      offset: end,
+      position: "end",
+      size: size(value)
+    });
+  }
+}
+function charCodeToBase16(char) {
+  if (char >= charCodeMap.zero && char <= charCodeMap.nine)
+    return char - charCodeMap.zero;
+  if (char >= charCodeMap.A && char <= charCodeMap.F)
+    return char - (charCodeMap.A - 10);
+  if (char >= charCodeMap.a && char <= charCodeMap.f)
+    return char - (charCodeMap.a - 10);
+  return;
+}
+function pad2(bytes, options2 = {}) {
+  const { dir, size: size2 = 32 } = options2;
+  if (size2 === 0)
+    return bytes;
+  if (bytes.length > size2)
+    throw new SizeExceedsPaddingSizeError({
+      size: bytes.length,
+      targetSize: size2,
+      type: "Bytes"
+    });
+  const paddedBytes = new Uint8Array(size2);
+  for (let i = 0;i < size2; i++) {
+    const padEnd = dir === "right";
+    paddedBytes[padEnd ? i : size2 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+  }
+  return paddedBytes;
+}
+function trim(value, options2 = {}) {
+  const { dir = "left" } = options2;
+  let data = value;
+  let sliceLength = 0;
+  for (let i = 0;i < data.length - 1; i++) {
+    if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
+      sliceLength++;
+    else
+      break;
+  }
+  data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
+  return data;
+}
+var charCodeMap;
+var init_bytes = __esm(() => {
+  init_Bytes();
+  charCodeMap = {
+    zero: 48,
+    nine: 57,
+    A: 65,
+    F: 70,
+    a: 97,
+    f: 102
+  };
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/internal/hex.js
+function assertSize2(hex, size_) {
+  if (size2(hex) > size_)
+    throw new SizeOverflowError2({
+      givenSize: size2(hex),
+      maxSize: size_
+    });
+}
+function pad3(hex_, options2 = {}) {
+  const { dir, size: size3 = 32 } = options2;
+  if (size3 === 0)
+    return hex_;
+  const hex = hex_.replace("0x", "");
+  if (hex.length > size3 * 2)
+    throw new SizeExceedsPaddingSizeError2({
+      size: Math.ceil(hex.length / 2),
+      targetSize: size3,
+      type: "Hex"
+    });
+  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
+}
+var init_hex = __esm(() => {
+  init_Hex();
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/Json.js
+var exports_Json = {};
+__export(exports_Json, {
+  stringify: () => stringify2,
+  parse: () => parse,
+  canonicalize: () => canonicalize
+});
+function canonicalize(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string")
+    return JSON.stringify(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new TypeError("Cannot canonicalize non-finite number");
+    return Object.is(value, -0) ? "0" : JSON.stringify(value);
+  }
+  if (typeof value === "bigint")
+    throw new TypeError("Cannot canonicalize bigint");
+  if (Array.isArray(value))
+    return `[${value.map((item) => canonicalize(item)).join(",")}]`;
+  if (typeof value === "object") {
+    const entries = Object.keys(value).sort().reduce((acc, key) => {
+      const v = value[key];
+      if (v !== undefined)
+        acc.push(`${JSON.stringify(key)}:${canonicalize(v)}`);
+      return acc;
+    }, []);
+    return `{${entries.join(",")}}`;
+  }
+  return;
+}
+function parse(string, reviver) {
+  return JSON.parse(string, (key, value_) => {
+    const value = value_;
+    if (typeof value === "string" && value.endsWith(bigIntSuffix))
+      return BigInt(value.slice(0, -bigIntSuffix.length));
+    return typeof reviver === "function" ? reviver(key, value) : value;
+  });
+}
+function stringify2(value, replacer, space) {
+  return JSON.stringify(value, (key, value2) => {
+    if (typeof replacer === "function")
+      return replacer(key, value2);
+    if (typeof value2 === "bigint")
+      return value2.toString() + bigIntSuffix;
+    return value2;
+  }, space);
+}
+var bigIntSuffix = "#__bigint";
+
+// node_modules/mppx/node_modules/ox/_esm/core/Hex.js
+function assert(value, options2 = {}) {
+  const { strict = false } = options2;
+  if (!value)
+    throw new InvalidHexTypeError(value);
+  if (typeof value !== "string")
+    throw new InvalidHexTypeError(value);
+  if (strict) {
+    if (!/^0x[0-9a-fA-F]*$/.test(value))
+      throw new InvalidHexValueError(value);
+  }
+  if (!value.startsWith("0x"))
+    throw new InvalidHexValueError(value);
+}
+function concat(...values) {
+  return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
+}
+function fromBoolean(value, options2 = {}) {
+  const hex = `0x${Number(value)}`;
+  if (typeof options2.size === "number") {
+    assertSize2(hex, options2.size);
+    return padLeft(hex, options2.size);
+  }
+  return hex;
+}
+function fromBytes(value, options2 = {}) {
+  let string = "";
+  for (let i = 0;i < value.length; i++)
+    string += hexes[value[i]];
+  const hex = `0x${string}`;
+  if (typeof options2.size === "number") {
+    assertSize2(hex, options2.size);
+    return padRight(hex, options2.size);
+  }
+  return hex;
+}
+function fromNumber(value, options2 = {}) {
+  const { signed, size: size3 } = options2;
+  const value_ = BigInt(value);
+  let maxValue;
+  if (size3) {
+    if (signed)
+      maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
+    else
+      maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
+  } else if (typeof value === "number") {
+    maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+  }
+  const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
+  if (maxValue && value_ > maxValue || value_ < minValue) {
+    const suffix = typeof value === "bigint" ? "n" : "";
+    throw new IntegerOutOfRangeError({
+      max: maxValue ? `${maxValue}${suffix}` : undefined,
+      min: `${minValue}${suffix}`,
+      signed,
+      size: size3,
+      value: `${value}${suffix}`
+    });
+  }
+  const stringValue = (signed && value_ < 0 ? BigInt.asUintN(size3 * 8, BigInt(value_)) : value_).toString(16);
+  const hex = `0x${stringValue}`;
+  if (size3)
+    return padLeft(hex, size3);
+  return hex;
+}
+function fromString(value, options2 = {}) {
+  return fromBytes(encoder.encode(value), options2);
+}
+function padLeft(value, size3) {
+  return pad3(value, { dir: "left", size: size3 });
+}
+function padRight(value, size3) {
+  return pad3(value, { dir: "right", size: size3 });
+}
+function size2(value) {
+  return Math.ceil((value.length - 2) / 2);
+}
+function toBigInt(hex, options2 = {}) {
+  const { signed } = options2;
+  if (options2.size)
+    assertSize2(hex, options2.size);
+  const value = BigInt(hex);
+  if (!signed)
+    return value;
+  const size3 = (hex.length - 2) / 2;
+  const max_unsigned = (1n << BigInt(size3) * 8n) - 1n;
+  const max_signed = max_unsigned >> 1n;
+  if (value <= max_signed)
+    return value;
+  return value - max_unsigned - 1n;
+}
+function toNumber(hex, options2 = {}) {
+  const { signed, size: size3 } = options2;
+  if (!signed && !size3)
+    return Number(hex);
+  return Number(toBigInt(hex, options2));
+}
+function validate2(value, options2 = {}) {
+  const { strict = false } = options2;
+  try {
+    assert(value, { strict });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var encoder, hexes, IntegerOutOfRangeError, InvalidHexTypeError, InvalidHexValueError, SizeOverflowError2, SizeExceedsPaddingSizeError2;
+var init_Hex = __esm(() => {
+  init_Errors();
+  init_hex();
+  encoder = /* @__PURE__ */ new TextEncoder;
+  hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+  IntegerOutOfRangeError = class IntegerOutOfRangeError extends BaseError {
+    constructor({ max, min, signed, size: size3, value }) {
+      super(`Number \`${value}\` is not in safe${size3 ? ` ${size3 * 8}-bit` : ""}${signed ? " signed" : " unsigned"} integer range ${max ? `(\`${min}\` to \`${max}\`)` : `(above \`${min}\`)`}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Hex.IntegerOutOfRangeError"
+      });
+    }
+  };
+  InvalidHexTypeError = class InvalidHexTypeError extends BaseError {
+    constructor(value) {
+      super(`Value \`${typeof value === "object" ? stringify2(value) : value}\` of type \`${typeof value}\` is an invalid hex type.`, {
+        metaMessages: ['Hex types must be represented as `"0x${string}"`.']
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Hex.InvalidHexTypeError"
+      });
+    }
+  };
+  InvalidHexValueError = class InvalidHexValueError extends BaseError {
+    constructor(value) {
+      super(`Value \`${value}\` is an invalid hex value.`, {
+        metaMessages: [
+          'Hex values must start with `"0x"` and contain only hexadecimal characters (0-9, a-f, A-F).'
+        ]
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Hex.InvalidHexValueError"
+      });
+    }
+  };
+  SizeOverflowError2 = class SizeOverflowError2 extends BaseError {
+    constructor({ givenSize, maxSize }) {
+      super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Hex.SizeOverflowError"
+      });
+    }
+  };
+  SizeExceedsPaddingSizeError2 = class SizeExceedsPaddingSizeError2 extends BaseError {
+    constructor({ size: size3, targetSize, type }) {
+      super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size3}\`) exceeds padding size (\`${targetSize}\`).`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Hex.SizeExceedsPaddingSizeError"
+      });
+    }
+  };
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/Bytes.js
+var exports_Bytes = {};
+__export(exports_Bytes, {
+  validate: () => validate3,
+  trimRight: () => trimRight,
+  trimLeft: () => trimLeft,
+  toString: () => toString,
+  toNumber: () => toNumber2,
+  toHex: () => toHex,
+  toBoolean: () => toBoolean,
+  toBigInt: () => toBigInt2,
+  slice: () => slice,
+  size: () => size,
+  random: () => random,
+  padRight: () => padRight2,
+  padLeft: () => padLeft2,
+  isEqual: () => isEqual,
+  fromString: () => fromString2,
+  fromNumber: () => fromNumber2,
+  fromHex: () => fromHex,
+  fromBoolean: () => fromBoolean2,
+  fromArray: () => fromArray,
+  from: () => from,
+  concat: () => concat2,
+  assert: () => assert2,
+  SliceOffsetOutOfBoundsError: () => SliceOffsetOutOfBoundsError,
+  SizeOverflowError: () => SizeOverflowError,
+  SizeExceedsPaddingSizeError: () => SizeExceedsPaddingSizeError,
+  InvalidBytesTypeError: () => InvalidBytesTypeError,
+  InvalidBytesBooleanError: () => InvalidBytesBooleanError
+});
+function assert2(value) {
+  if (value instanceof Uint8Array)
+    return;
+  if (!value)
+    throw new InvalidBytesTypeError(value);
+  if (typeof value !== "object")
+    throw new InvalidBytesTypeError(value);
+  if (!("BYTES_PER_ELEMENT" in value))
+    throw new InvalidBytesTypeError(value);
+  if (value.BYTES_PER_ELEMENT !== 1 || value.constructor.name !== "Uint8Array")
+    throw new InvalidBytesTypeError(value);
+}
+function concat2(...values) {
+  let length = 0;
+  for (const arr of values) {
+    length += arr.length;
+  }
+  const result = new Uint8Array(length);
+  for (let i = 0, index = 0;i < values.length; i++) {
+    const arr = values[i];
+    result.set(arr, index);
+    index += arr.length;
+  }
+  return result;
+}
+function from(value) {
+  if (value instanceof Uint8Array)
+    return value;
+  if (typeof value === "string")
+    return fromHex(value);
+  return fromArray(value);
+}
+function fromArray(value) {
+  return value instanceof Uint8Array ? value : new Uint8Array(value);
+}
+function fromBoolean2(value, options2 = {}) {
+  const { size: size3 } = options2;
+  const bytes = new Uint8Array(1);
+  bytes[0] = Number(value);
+  if (typeof size3 === "number") {
+    assertSize(bytes, size3);
+    return padLeft2(bytes, size3);
+  }
+  return bytes;
+}
+function fromHex(value, options2 = {}) {
+  const { size: size3 } = options2;
+  let hex = value;
+  if (size3) {
+    assertSize2(value, size3);
+    hex = padRight(value, size3);
+  }
+  let hexString = hex.slice(2);
+  if (hexString.length % 2)
+    hexString = `0${hexString}`;
+  const length = hexString.length / 2;
+  const bytes = new Uint8Array(length);
+  for (let index = 0, j = 0;index < length; index++) {
+    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
+    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+    if (nibbleLeft === undefined || nibbleRight === undefined) {
+      throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+    }
+    bytes[index] = nibbleLeft << 4 | nibbleRight;
+  }
+  return bytes;
+}
+function fromNumber2(value, options2) {
+  const hex = fromNumber(value, options2);
+  return fromHex(hex);
+}
+function fromString2(value, options2 = {}) {
+  const { size: size3 } = options2;
+  const bytes = encoder2.encode(value);
+  if (typeof size3 === "number") {
+    assertSize(bytes, size3);
+    return padRight2(bytes, size3);
+  }
+  return bytes;
+}
+function isEqual(bytesA, bytesB) {
+  return equalBytes(bytesA, bytesB);
+}
+function padLeft2(value, size3) {
+  return pad2(value, { dir: "left", size: size3 });
+}
+function padRight2(value, size3) {
+  return pad2(value, { dir: "right", size: size3 });
+}
+function random(length) {
+  return crypto.getRandomValues(new Uint8Array(length));
+}
+function size(value) {
+  return value.length;
+}
+function slice(value, start, end, options2 = {}) {
+  const { strict } = options2;
+  assertStartOffset(value, start);
+  const value_ = value.slice(start, end);
+  if (strict)
+    assertEndOffset(value_, start, end);
+  return value_;
+}
+function toBigInt2(bytes, options2 = {}) {
+  const { size: size3 } = options2;
+  if (typeof size3 !== "undefined")
+    assertSize(bytes, size3);
+  const hex = fromBytes(bytes, options2);
+  return toBigInt(hex, options2);
+}
+function toBoolean(bytes, options2 = {}) {
+  const { size: size3 } = options2;
+  let bytes_ = bytes;
+  if (typeof size3 !== "undefined") {
+    assertSize(bytes_, size3);
+    bytes_ = trimLeft(bytes_);
+  }
+  if (bytes_.length > 1 || bytes_[0] > 1)
+    throw new InvalidBytesBooleanError(bytes_);
+  return Boolean(bytes_[0]);
+}
+function toHex(value, options2 = {}) {
+  return fromBytes(value, options2);
+}
+function toNumber2(bytes, options2 = {}) {
+  const { size: size3 } = options2;
+  if (typeof size3 !== "undefined")
+    assertSize(bytes, size3);
+  const hex = fromBytes(bytes, options2);
+  return toNumber(hex, options2);
+}
+function toString(bytes, options2 = {}) {
+  const { size: size3 } = options2;
+  let bytes_ = bytes;
+  if (typeof size3 !== "undefined") {
+    assertSize(bytes_, size3);
+    bytes_ = trimRight(bytes_);
+  }
+  return decoder.decode(bytes_);
+}
+function trimLeft(value) {
+  return trim(value, { dir: "left" });
+}
+function trimRight(value) {
+  return trim(value, { dir: "right" });
+}
+function validate3(value) {
+  try {
+    assert2(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var decoder, encoder2, InvalidBytesBooleanError, InvalidBytesTypeError, SizeOverflowError, SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
+var init_Bytes = __esm(() => {
+  init_utils2();
+  init_Errors();
+  init_Hex();
+  init_bytes();
+  init_hex();
+  decoder = /* @__PURE__ */ new TextDecoder;
+  encoder2 = /* @__PURE__ */ new TextEncoder;
+  InvalidBytesBooleanError = class InvalidBytesBooleanError extends BaseError {
+    constructor(bytes) {
+      super(`Bytes value \`${bytes}\` is not a valid boolean.`, {
+        metaMessages: [
+          "The bytes array must contain a single byte of either a `0` or `1` value."
+        ]
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Bytes.InvalidBytesBooleanError"
+      });
+    }
+  };
+  InvalidBytesTypeError = class InvalidBytesTypeError extends BaseError {
+    constructor(value) {
+      super(`Value \`${typeof value === "object" ? stringify2(value) : value}\` of type \`${typeof value}\` is an invalid Bytes value.`, {
+        metaMessages: ["Bytes values must be of type `Bytes`."]
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Bytes.InvalidBytesTypeError"
+      });
+    }
+  };
+  SizeOverflowError = class SizeOverflowError extends BaseError {
+    constructor({ givenSize, maxSize }) {
+      super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Bytes.SizeOverflowError"
+      });
+    }
+  };
+  SliceOffsetOutOfBoundsError = class SliceOffsetOutOfBoundsError extends BaseError {
+    constructor({ offset, position, size: size3 }) {
+      super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size3}\`).`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Bytes.SliceOffsetOutOfBoundsError"
+      });
+    }
+  };
+  SizeExceedsPaddingSizeError = class SizeExceedsPaddingSizeError extends BaseError {
+    constructor({ size: size3, targetSize, type }) {
+      super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size3}\`) exceeds padding size (\`${targetSize}\`).`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Bytes.SizeExceedsPaddingSizeError"
+      });
+    }
+  };
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/Hash.js
+var exports_Hash = {};
+__export(exports_Hash, {
+  validate: () => validate4,
+  sha256: () => sha2563,
+  ripemd160: () => ripemd1603,
+  keccak256: () => keccak256,
+  hmac256: () => hmac256
+});
+function keccak256(value, options2 = {}) {
+  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
+  const bytes = keccak_256(from(value));
+  if (as === "Bytes")
+    return bytes;
+  return fromBytes(bytes);
+}
+function hmac256(key, value, options2 = {}) {
+  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
+  const bytes = hmac(sha2562, from(key), from(value));
+  if (as === "Bytes")
+    return bytes;
+  return fromBytes(bytes);
+}
+function ripemd1603(value, options2 = {}) {
+  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
+  const bytes = ripemd1602(from(value));
+  if (as === "Bytes")
+    return bytes;
+  return fromBytes(bytes);
+}
+function sha2563(value, options2 = {}) {
+  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
+  const bytes = sha2562(from(value));
+  if (as === "Bytes")
+    return bytes;
+  return fromBytes(bytes);
+}
+function validate4(value) {
+  return validate2(value) && size2(value) === 32;
+}
+var init_Hash = __esm(() => {
+  init_hmac();
+  init_ripemd160();
+  init_sha3();
+  init_sha256();
+  init_Bytes();
+  init_Hex();
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/internal/lru.js
+var LruMap;
+var init_lru = __esm(() => {
+  LruMap = class LruMap extends Map {
+    constructor(size3) {
+      super();
+      Object.defineProperty(this, "maxSize", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      this.maxSize = size3;
+    }
+    get(key) {
+      const value = super.get(key);
+      if (super.has(key) && value !== undefined) {
+        this.delete(key);
+        super.set(key, value);
+      }
+      return value;
+    }
+    set(key, value) {
+      super.set(key, value);
+      if (this.maxSize && this.size > this.maxSize) {
+        const firstKey = this.keys().next().value;
+        if (firstKey)
+          this.delete(firstKey);
+      }
+      return this;
+    }
+  };
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/Caches.js
+var caches, checksum;
+var init_Caches = __esm(() => {
+  init_lru();
+  caches = {
+    checksum: /* @__PURE__ */ new LruMap(8192)
+  };
+  checksum = caches.checksum;
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/PublicKey.js
+var init_PublicKey = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Address.js
+function assert3(value, options2 = {}) {
+  const { strict = true } = options2;
+  if (!addressRegex.test(value))
+    throw new InvalidAddressError({
+      address: value,
+      cause: new InvalidInputError
+    });
+  if (strict) {
+    if (value.toLowerCase() === value)
+      return;
+    if (checksum2(value) !== value)
+      throw new InvalidAddressError({
+        address: value,
+        cause: new InvalidChecksumError
+      });
+  }
+}
+function checksum2(address2) {
+  if (checksum.has(address2))
+    return checksum.get(address2);
+  assert3(address2, { strict: false });
+  const hexAddress = address2.substring(2).toLowerCase();
+  const hash = keccak256(fromString2(hexAddress), { as: "Bytes" });
+  const characters = hexAddress.split("");
+  for (let i = 0;i < 40; i += 2) {
+    if (hash[i >> 1] >> 4 >= 8 && characters[i]) {
+      characters[i] = characters[i].toUpperCase();
+    }
+    if ((hash[i >> 1] & 15) >= 8 && characters[i + 1]) {
+      characters[i + 1] = characters[i + 1].toUpperCase();
+    }
+  }
+  const result = `0x${characters.join("")}`;
+  checksum.set(address2, result);
+  return result;
+}
+var addressRegex, InvalidAddressError, InvalidInputError, InvalidChecksumError;
+var init_Address = __esm(() => {
+  init_Bytes();
+  init_Caches();
+  init_Errors();
+  init_Hash();
+  addressRegex = /^0x[a-fA-F0-9]{40}$/;
+  InvalidAddressError = class InvalidAddressError extends BaseError {
+    constructor({ address: address2, cause }) {
+      super(`Address "${address2}" is invalid.`, {
+        cause
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Address.InvalidAddressError"
+      });
+    }
+  };
+  InvalidInputError = class InvalidInputError extends BaseError {
+    constructor() {
+      super("Address is not a 20 byte (40 hexadecimal character) value.");
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Address.InvalidInputError"
+      });
+    }
+  };
+  InvalidChecksumError = class InvalidChecksumError extends BaseError {
+    constructor() {
+      super("Address does not match its checksum counterpart.");
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Address.InvalidChecksumError"
+      });
+    }
+  };
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/AbiItem.js
+var init_AbiItem = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Solidity.js
+var arrayRegex, bytesRegex, integerRegex, maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
+var init_Solidity = __esm(() => {
+  arrayRegex = /^(.*)\[([0-9]*)\]$/;
+  bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+  integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+  maxInt8 = 2n ** (8n - 1n) - 1n;
+  maxInt16 = 2n ** (16n - 1n) - 1n;
+  maxInt24 = 2n ** (24n - 1n) - 1n;
+  maxInt32 = 2n ** (32n - 1n) - 1n;
+  maxInt40 = 2n ** (40n - 1n) - 1n;
+  maxInt48 = 2n ** (48n - 1n) - 1n;
+  maxInt56 = 2n ** (56n - 1n) - 1n;
+  maxInt64 = 2n ** (64n - 1n) - 1n;
+  maxInt72 = 2n ** (72n - 1n) - 1n;
+  maxInt80 = 2n ** (80n - 1n) - 1n;
+  maxInt88 = 2n ** (88n - 1n) - 1n;
+  maxInt96 = 2n ** (96n - 1n) - 1n;
+  maxInt104 = 2n ** (104n - 1n) - 1n;
+  maxInt112 = 2n ** (112n - 1n) - 1n;
+  maxInt120 = 2n ** (120n - 1n) - 1n;
+  maxInt128 = 2n ** (128n - 1n) - 1n;
+  maxInt136 = 2n ** (136n - 1n) - 1n;
+  maxInt144 = 2n ** (144n - 1n) - 1n;
+  maxInt152 = 2n ** (152n - 1n) - 1n;
+  maxInt160 = 2n ** (160n - 1n) - 1n;
+  maxInt168 = 2n ** (168n - 1n) - 1n;
+  maxInt176 = 2n ** (176n - 1n) - 1n;
+  maxInt184 = 2n ** (184n - 1n) - 1n;
+  maxInt192 = 2n ** (192n - 1n) - 1n;
+  maxInt200 = 2n ** (200n - 1n) - 1n;
+  maxInt208 = 2n ** (208n - 1n) - 1n;
+  maxInt216 = 2n ** (216n - 1n) - 1n;
+  maxInt224 = 2n ** (224n - 1n) - 1n;
+  maxInt232 = 2n ** (232n - 1n) - 1n;
+  maxInt240 = 2n ** (240n - 1n) - 1n;
+  maxInt248 = 2n ** (248n - 1n) - 1n;
+  maxInt256 = 2n ** (256n - 1n) - 1n;
+  minInt8 = -(2n ** (8n - 1n));
+  minInt16 = -(2n ** (16n - 1n));
+  minInt24 = -(2n ** (24n - 1n));
+  minInt32 = -(2n ** (32n - 1n));
+  minInt40 = -(2n ** (40n - 1n));
+  minInt48 = -(2n ** (48n - 1n));
+  minInt56 = -(2n ** (56n - 1n));
+  minInt64 = -(2n ** (64n - 1n));
+  minInt72 = -(2n ** (72n - 1n));
+  minInt80 = -(2n ** (80n - 1n));
+  minInt88 = -(2n ** (88n - 1n));
+  minInt96 = -(2n ** (96n - 1n));
+  minInt104 = -(2n ** (104n - 1n));
+  minInt112 = -(2n ** (112n - 1n));
+  minInt120 = -(2n ** (120n - 1n));
+  minInt128 = -(2n ** (128n - 1n));
+  minInt136 = -(2n ** (136n - 1n));
+  minInt144 = -(2n ** (144n - 1n));
+  minInt152 = -(2n ** (152n - 1n));
+  minInt160 = -(2n ** (160n - 1n));
+  minInt168 = -(2n ** (168n - 1n));
+  minInt176 = -(2n ** (176n - 1n));
+  minInt184 = -(2n ** (184n - 1n));
+  minInt192 = -(2n ** (192n - 1n));
+  minInt200 = -(2n ** (200n - 1n));
+  minInt208 = -(2n ** (208n - 1n));
+  minInt216 = -(2n ** (216n - 1n));
+  minInt224 = -(2n ** (224n - 1n));
+  minInt232 = -(2n ** (232n - 1n));
+  minInt240 = -(2n ** (240n - 1n));
+  minInt248 = -(2n ** (248n - 1n));
+  minInt256 = -(2n ** (256n - 1n));
+  maxUint8 = 2n ** 8n - 1n;
+  maxUint16 = 2n ** 16n - 1n;
+  maxUint24 = 2n ** 24n - 1n;
+  maxUint32 = 2n ** 32n - 1n;
+  maxUint40 = 2n ** 40n - 1n;
+  maxUint48 = 2n ** 48n - 1n;
+  maxUint56 = 2n ** 56n - 1n;
+  maxUint64 = 2n ** 64n - 1n;
+  maxUint72 = 2n ** 72n - 1n;
+  maxUint80 = 2n ** 80n - 1n;
+  maxUint88 = 2n ** 88n - 1n;
+  maxUint96 = 2n ** 96n - 1n;
+  maxUint104 = 2n ** 104n - 1n;
+  maxUint112 = 2n ** 112n - 1n;
+  maxUint120 = 2n ** 120n - 1n;
+  maxUint128 = 2n ** 128n - 1n;
+  maxUint136 = 2n ** 136n - 1n;
+  maxUint144 = 2n ** 144n - 1n;
+  maxUint152 = 2n ** 152n - 1n;
+  maxUint160 = 2n ** 160n - 1n;
+  maxUint168 = 2n ** 168n - 1n;
+  maxUint176 = 2n ** 176n - 1n;
+  maxUint184 = 2n ** 184n - 1n;
+  maxUint192 = 2n ** 192n - 1n;
+  maxUint200 = 2n ** 200n - 1n;
+  maxUint208 = 2n ** 208n - 1n;
+  maxUint216 = 2n ** 216n - 1n;
+  maxUint224 = 2n ** 224n - 1n;
+  maxUint232 = 2n ** 232n - 1n;
+  maxUint240 = 2n ** 240n - 1n;
+  maxUint248 = 2n ** 248n - 1n;
+  maxUint256 = 2n ** 256n - 1n;
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/AbiParameters.js
+function encodePacked(types, values) {
+  if (types.length !== values.length)
+    throw new LengthMismatchError({
+      expectedLength: types.length,
+      givenLength: values.length
+    });
+  const data = [];
+  for (let i = 0;i < types.length; i++) {
+    const type = types[i];
+    const value = values[i];
+    data.push(encodePacked.encode(type, value));
+  }
+  return concat(...data);
+}
+var BytesSizeMismatchError, LengthMismatchError, InvalidTypeError;
+var init_AbiParameters = __esm(() => {
+  init_Address();
+  init_Errors();
+  init_Hex();
+  init_Solidity();
+  (function(encodePacked2) {
+    function encode(type, value, isArray = false) {
+      if (type === "address") {
+        const address2 = value;
+        assert3(address2);
+        return padLeft(address2.toLowerCase(), isArray ? 32 : 0);
+      }
+      if (type === "string")
+        return fromString(value);
+      if (type === "bytes")
+        return value;
+      if (type === "bool")
+        return padLeft(fromBoolean(value), isArray ? 32 : 1);
+      const intMatch = type.match(integerRegex);
+      if (intMatch) {
+        const [_type, baseType, bits = "256"] = intMatch;
+        const size3 = Number.parseInt(bits, 10) / 8;
+        return fromNumber(value, {
+          size: isArray ? 32 : size3,
+          signed: baseType === "int"
+        });
+      }
+      const bytesMatch = type.match(bytesRegex);
+      if (bytesMatch) {
+        const [_type, size3] = bytesMatch;
+        if (Number.parseInt(size3, 10) !== (value.length - 2) / 2)
+          throw new BytesSizeMismatchError({
+            expectedSize: Number.parseInt(size3, 10),
+            value
+          });
+        return padRight(value, isArray ? 32 : 0);
+      }
+      const arrayMatch = type.match(arrayRegex);
+      if (arrayMatch && Array.isArray(value)) {
+        const [_type, childType] = arrayMatch;
+        const data = [];
+        for (let i = 0;i < value.length; i++) {
+          data.push(encode(childType, value[i], true));
+        }
+        if (data.length === 0)
+          return "0x";
+        return concat(...data);
+      }
+      throw new InvalidTypeError(type);
+    }
+    encodePacked2.encode = encode;
+  })(encodePacked || (encodePacked = {}));
+  BytesSizeMismatchError = class BytesSizeMismatchError extends BaseError {
+    constructor({ expectedSize, value }) {
+      super(`Size of bytes "${value}" (bytes${size2(value)}) does not match expected size (bytes${expectedSize}).`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "AbiParameters.BytesSizeMismatchError"
+      });
+    }
+  };
+  LengthMismatchError = class LengthMismatchError extends BaseError {
+    constructor({ expectedLength, givenLength }) {
+      super([
+        "ABI encoding parameters/values length mismatch.",
+        `Expected length (parameters): ${expectedLength}`,
+        `Given length (values): ${givenLength}`
+      ].join(`
+`));
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "AbiParameters.LengthMismatchError"
+      });
+    }
+  };
+  InvalidTypeError = class InvalidTypeError extends BaseError {
+    constructor(type) {
+      super(`Type \`${type}\` is not a valid ABI Type.`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "AbiParameters.InvalidTypeError"
+      });
+    }
+  };
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/AbiConstructor.js
+var init_AbiConstructor = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/AbiError.js
+var init_AbiError = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/AbiEvent.js
+var init_AbiEvent = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/AbiFunction.js
+var init_AbiFunction = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/AccessList.js
+var init_AccessList = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/AccountProof.js
+var init_AccountProof = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/AesGcm.js
+var init_AesGcm = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Rlp.js
+var init_Rlp = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Signature.js
+var init_Signature = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Authorization.js
+var init_Authorization = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Base32.js
+var init_Base32 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Base58.js
+var init_Base58 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Base64.js
+var exports_Base64 = {};
+__export(exports_Base64, {
+  toString: () => toString2,
+  toHex: () => toHex2,
+  toBytes: () => toBytes2,
+  fromString: () => fromString3,
+  fromHex: () => fromHex2,
+  fromBytes: () => fromBytes2
+});
+function fromBytes2(value, options2 = {}) {
+  const { pad: pad4 = true, url = false } = options2;
+  const encoded = new Uint8Array(Math.ceil(value.length / 3) * 4);
+  for (let i = 0, j = 0;j < value.length; i += 4, j += 3) {
+    const y = (value[j] << 16) + (value[j + 1] << 8) + (value[j + 2] | 0);
+    encoded[i] = integerToCharacter[y >> 18];
+    encoded[i + 1] = integerToCharacter[y >> 12 & 63];
+    encoded[i + 2] = integerToCharacter[y >> 6 & 63];
+    encoded[i + 3] = integerToCharacter[y & 63];
+  }
+  const k = value.length % 3;
+  const end = Math.floor(value.length / 3) * 4 + (k && k + 1);
+  let base64 = decoder2.decode(new Uint8Array(encoded.buffer, 0, end));
+  if (pad4 && k === 1)
+    base64 += "==";
+  if (pad4 && k === 2)
+    base64 += "=";
+  if (url)
+    base64 = base64.replaceAll("+", "-").replaceAll("/", "_");
+  return base64;
+}
+function fromHex2(value, options2 = {}) {
+  return fromBytes2(fromHex(value), options2);
+}
+function fromString3(value, options2 = {}) {
+  return fromBytes2(fromString2(value), options2);
+}
+function toBytes2(value) {
+  const base64 = value.replace(/=+$/, "");
+  const size3 = base64.length;
+  const decoded = new Uint8Array(size3 + 3);
+  encoder3.encodeInto(base64 + "===", decoded);
+  for (let i = 0, j = 0;i < base64.length; i += 4, j += 3) {
+    const x = (characterToInteger[decoded[i]] << 18) + (characterToInteger[decoded[i + 1]] << 12) + (characterToInteger[decoded[i + 2]] << 6) + characterToInteger[decoded[i + 3]];
+    decoded[j] = x >> 16;
+    decoded[j + 1] = x >> 8 & 255;
+    decoded[j + 2] = x & 255;
+  }
+  const decodedSize = (size3 >> 2) * 3 + (size3 % 4 && size3 % 4 - 1);
+  return new Uint8Array(decoded.buffer, 0, decodedSize);
+}
+function toHex2(value) {
+  return fromBytes(toBytes2(value));
+}
+function toString2(value) {
+  return toString(toBytes2(value));
+}
+var encoder3, decoder2, integerToCharacter, characterToInteger;
+var init_Base64 = __esm(() => {
+  init_Bytes();
+  init_Hex();
+  encoder3 = /* @__PURE__ */ new TextEncoder;
+  decoder2 = /* @__PURE__ */ new TextDecoder;
+  integerToCharacter = /* @__PURE__ */ Object.fromEntries(Array.from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").map((a, i) => [i, a.charCodeAt(0)]));
+  characterToInteger = {
+    ...Object.fromEntries(Array.from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").map((a, i) => [a.charCodeAt(0), i])),
+    [61]: 0,
+    [45]: 62,
+    [95]: 63
+  };
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/Bech32m.js
+var init_Bech32m = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/BinaryStateTree.js
+var init_BinaryStateTree = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Blobs.js
+var blobsPerTransaction = 6, bytesPerFieldElement = 32, fieldElementsPerBlob = 4096, bytesPerBlob, maxBytesPerTransaction;
+var init_Blobs = __esm(() => {
+  bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
+  maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - 1 - 1 * fieldElementsPerBlob * blobsPerTransaction;
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/Transaction.js
+var init_Transaction = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Withdrawal.js
+var init_Withdrawal = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Block.js
+var init_Block = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/BlockOverrides.js
+var init_BlockOverrides = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Bloom.js
+var init_Bloom = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Bls.js
+var init_Bls = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/BlsPoint.js
+var init_BlsPoint = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Cbor.js
+function getEncodable(value) {
+  if (typeof value === "undefined")
+    return { length: 1, encode: (cursor) => cursor.pushUint8(247) };
+  if (value === null)
+    return { length: 1, encode: (cursor) => cursor.pushUint8(246) };
+  if (typeof value === "boolean")
+    return {
+      length: 1,
+      encode: (cursor) => cursor.pushUint8(value ? 245 : 244)
+    };
+  if (typeof value === "number")
+    return getEncodable.number(value);
+  if (typeof value === "bigint")
+    throw new UnsupportedBigIntError;
+  if (typeof value === "string")
+    return getEncodable.string(value);
+  if (Array.isArray(value))
+    return getEncodable.array(value);
+  if (value instanceof Uint8Array)
+    return getEncodable.byteString(value);
+  if (value instanceof ArrayBuffer)
+    return getEncodable.byteString(new Uint8Array(value));
+  if (ArrayBuffer.isView(value))
+    return getEncodable.byteString(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+  if (value instanceof Map)
+    return getEncodable.map(value);
+  if (typeof value === "object")
+    return getEncodable.object(value);
+  throw new UnexpectedTokenError({ token: String(value) });
+}
+function decodeCursor(cursor) {
+  const initialByte = cursor.readUint8();
+  const majorType = initialByte >> 5;
+  const additionalInfo = initialByte & 31;
+  switch (majorType) {
+    case 0:
+      return decodeCursor.readUnsignedInteger(cursor, additionalInfo);
+    case 1:
+      return decodeCursor.readNegativeInteger(cursor, additionalInfo);
+    case 2:
+      return decodeCursor.readByteString(cursor, additionalInfo);
+    case 3:
+      return decodeCursor.readTextString(cursor, additionalInfo);
+    case 4:
+      return decodeCursor.readArray(cursor, additionalInfo);
+    case 5:
+      return decodeCursor.readMap(cursor, additionalInfo);
+    case 6:
+      throw new UnsupportedTagError({ tag: additionalInfo });
+    case 7:
+      return decodeCursor.readSimpleOrFloat(cursor, additionalInfo);
+    default:
+      throw new InvalidMajorTypeError({ majorType });
+  }
+}
+var InvalidMajorTypeError, InvalidAdditionalInfoError, Unsupported64BitIntegerError, UnsupportedTagError, InvalidIndefiniteLengthChunkError, InvalidSimpleValueError, UnsupportedBigIntError, UnexpectedTokenError, NumberTooLargeError, StringTooLargeError, ArrayTooLargeError, ObjectTooLargeError, ByteStringTooLargeError;
+var init_Cbor = __esm(() => {
+  init_Bytes();
+  init_Errors();
+  InvalidMajorTypeError = class InvalidMajorTypeError extends BaseError {
+    constructor({ majorType }) {
+      super(`Invalid CBOR major type: ${majorType}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.InvalidMajorTypeError"
+      });
+    }
+  };
+  InvalidAdditionalInfoError = class InvalidAdditionalInfoError extends BaseError {
+    constructor({ additionalInfo }) {
+      super(`Invalid CBOR additional info: ${additionalInfo}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.InvalidAdditionalInfoError"
+      });
+    }
+  };
+  Unsupported64BitIntegerError = class Unsupported64BitIntegerError extends BaseError {
+    constructor() {
+      super("64-bit integers are not supported in CBOR decoding.");
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.Unsupported64BitIntegerError"
+      });
+    }
+  };
+  UnsupportedTagError = class UnsupportedTagError extends BaseError {
+    constructor({ tag }) {
+      super(`CBOR tagged data (tag ${tag}) is not yet supported.`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.UnsupportedTagError"
+      });
+    }
+  };
+  InvalidIndefiniteLengthChunkError = class InvalidIndefiniteLengthChunkError extends BaseError {
+    constructor({ type }) {
+      super(`Invalid chunk type in indefinite-length ${type}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.InvalidIndefiniteLengthChunkError"
+      });
+    }
+  };
+  InvalidSimpleValueError = class InvalidSimpleValueError extends BaseError {
+    constructor({ value }) {
+      super(`Invalid CBOR simple value: ${value}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.InvalidSimpleValueError"
+      });
+    }
+  };
+  UnsupportedBigIntError = class UnsupportedBigIntError extends BaseError {
+    constructor() {
+      super("BigInt values are not supported in CBOR encoding.");
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.UnsupportedBigIntError"
+      });
+    }
+  };
+  UnexpectedTokenError = class UnexpectedTokenError extends BaseError {
+    constructor({ token }) {
+      super(`Unexpected token: ${token}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.UnexpectedTokenError"
+      });
+    }
+  };
+  NumberTooLargeError = class NumberTooLargeError extends BaseError {
+    constructor({ number }) {
+      super(`Number exceeds maximum safe integer (${Number.MAX_SAFE_INTEGER}): ${number}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.NumberTooLargeError"
+      });
+    }
+  };
+  StringTooLargeError = class StringTooLargeError extends BaseError {
+    constructor({ size: size3 }) {
+      super(`String length exceeds maximum (4294967295): ${size3}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.StringTooLargeError"
+      });
+    }
+  };
+  ArrayTooLargeError = class ArrayTooLargeError extends BaseError {
+    constructor({ size: size3 }) {
+      super(`Array length exceeds maximum (4294967295): ${size3}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.ArrayTooLargeError"
+      });
+    }
+  };
+  ObjectTooLargeError = class ObjectTooLargeError extends BaseError {
+    constructor({ size: size3 }) {
+      super(`Object size exceeds maximum (4294967295): ${size3}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.ObjectTooLargeError"
+      });
+    }
+  };
+  ByteStringTooLargeError = class ByteStringTooLargeError extends BaseError {
+    constructor({ size: size3 }) {
+      super(`Byte string length exceeds maximum (4294967295): ${size3}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.ByteStringTooLargeError"
+      });
+    }
+  };
+  (function(getEncodable2) {
+    function number(value) {
+      if (!Number.isSafeInteger(value)) {
+        const float32 = Math.fround(value);
+        if (Number.isNaN(value) || value === float32)
+          return {
+            length: 5,
+            encode(cursor) {
+              cursor.pushUint8(250);
+              cursor.dataView.setFloat32(cursor.position, value, false);
+              cursor.position += 4;
+            }
+          };
+        return {
+          length: 9,
+          encode(cursor) {
+            cursor.pushUint8(251);
+            cursor.dataView.setFloat64(cursor.position, value, false);
+            cursor.position += 8;
+          }
+        };
+      }
+      if (value >= 0) {
+        if (value <= 23)
+          return { length: 1, encode: (cursor) => cursor.pushUint8(value) };
+        if (value <= 255)
+          return {
+            length: 2,
+            encode: (cursor) => {
+              cursor.pushUint8(24);
+              cursor.pushUint8(value);
+            }
+          };
+        if (value <= 65535)
+          return {
+            length: 3,
+            encode: (cursor) => {
+              cursor.pushUint8(25);
+              cursor.pushUint16(value);
+            }
+          };
+        if (value <= 4294967295)
+          return {
+            length: 5,
+            encode: (cursor) => {
+              cursor.pushUint8(26);
+              cursor.pushUint32(value);
+            }
+          };
+        throw new NumberTooLargeError({ number: value.toString(10) });
+      }
+      const positiveNumber = -1 - value;
+      if (value >= -24)
+        return {
+          length: 1,
+          encode: (cursor) => cursor.pushUint8(32 + positiveNumber)
+        };
+      if (positiveNumber <= 255)
+        return {
+          length: 2,
+          encode: (cursor) => {
+            cursor.pushUint8(56);
+            cursor.pushUint8(positiveNumber);
+          }
+        };
+      if (positiveNumber <= 65535)
+        return {
+          length: 3,
+          encode: (cursor) => {
+            cursor.pushUint8(57);
+            cursor.pushUint16(positiveNumber);
+          }
+        };
+      if (positiveNumber <= 4294967295)
+        return {
+          length: 5,
+          encode: (cursor) => {
+            cursor.pushUint8(58);
+            cursor.pushUint32(positiveNumber);
+          }
+        };
+      throw new NumberTooLargeError({ number: value.toString(10) });
+    }
+    getEncodable2.number = number;
+    function string(value) {
+      const encoded = fromString2(value);
+      const size3 = encoded.length;
+      if (size3 <= 23)
+        return {
+          length: 1 + size3,
+          encode(cursor) {
+            cursor.pushUint8(96 + size3);
+            if (size3 > 0)
+              cursor.pushBytes(encoded);
+          }
+        };
+      if (size3 <= 255)
+        return {
+          length: 2 + size3,
+          encode(cursor) {
+            cursor.pushUint8(120);
+            cursor.pushUint8(size3);
+            cursor.pushBytes(encoded);
+          }
+        };
+      if (size3 <= 65535)
+        return {
+          length: 3 + size3,
+          encode(cursor) {
+            cursor.pushUint8(121);
+            cursor.pushUint16(size3);
+            cursor.pushBytes(encoded);
+          }
+        };
+      if (size3 <= 4294967295)
+        return {
+          length: 5 + size3,
+          encode(cursor) {
+            cursor.pushUint8(122);
+            cursor.pushUint32(size3);
+            cursor.pushBytes(encoded);
+          }
+        };
+      throw new StringTooLargeError({ size: size3 });
+    }
+    getEncodable2.string = string;
+    function array(value) {
+      const items = value.map((item) => getEncodable2(item));
+      const bodyLength = items.reduce((acc, item) => acc + item.length, 0);
+      const size3 = value.length;
+      if (size3 <= 23)
+        return {
+          length: 1 + bodyLength,
+          encode(cursor) {
+            cursor.pushUint8(128 + size3);
+            for (const item of items)
+              item.encode(cursor);
+          }
+        };
+      if (size3 <= 255)
+        return {
+          length: 2 + bodyLength,
+          encode(cursor) {
+            cursor.pushUint8(152);
+            cursor.pushUint8(size3);
+            for (const item of items)
+              item.encode(cursor);
+          }
+        };
+      if (size3 <= 65535)
+        return {
+          length: 3 + bodyLength,
+          encode(cursor) {
+            cursor.pushUint8(153);
+            cursor.pushUint16(size3);
+            for (const item of items)
+              item.encode(cursor);
+          }
+        };
+      if (size3 <= 4294967295)
+        return {
+          length: 5 + bodyLength,
+          encode(cursor) {
+            cursor.pushUint8(154);
+            cursor.pushUint32(size3);
+            for (const item of items)
+              item.encode(cursor);
+          }
+        };
+      throw new ArrayTooLargeError({ size: size3 });
+    }
+    getEncodable2.array = array;
+    function byteString(value) {
+      const size3 = value.byteLength;
+      if (size3 <= 23)
+        return {
+          length: 1 + size3,
+          encode(cursor) {
+            cursor.pushUint8(64 + size3);
+            cursor.pushBytes(value);
+          }
+        };
+      if (size3 <= 255)
+        return {
+          length: 2 + size3,
+          encode(cursor) {
+            cursor.pushUint8(88);
+            cursor.pushUint8(size3);
+            cursor.pushBytes(value);
+          }
+        };
+      if (size3 <= 65535)
+        return {
+          length: 3 + size3,
+          encode(cursor) {
+            cursor.pushUint8(89);
+            cursor.pushUint16(size3);
+            cursor.pushBytes(value);
+          }
+        };
+      if (size3 <= 4294967295)
+        return {
+          length: 5 + size3,
+          encode(cursor) {
+            cursor.pushUint8(90);
+            cursor.pushUint32(size3);
+            cursor.pushBytes(value);
+          }
+        };
+      throw new ByteStringTooLargeError({ size: size3 });
+    }
+    getEncodable2.byteString = byteString;
+    function object(value) {
+      const keys2 = Object.keys(value);
+      const entries = keys2.map((key) => ({
+        key: getEncodable2(key),
+        value: getEncodable2(value[key])
+      }));
+      const bodyLength = entries.reduce((acc, entry) => acc + entry.key.length + entry.value.length, 0);
+      const size3 = keys2.length;
+      if (size3 <= 23)
+        return {
+          length: 1 + bodyLength,
+          encode(cursor) {
+            cursor.pushUint8(160 + size3);
+            for (const entry of entries) {
+              entry.key.encode(cursor);
+              entry.value.encode(cursor);
+            }
+          }
+        };
+      if (size3 <= 255)
+        return {
+          length: 2 + bodyLength,
+          encode(cursor) {
+            cursor.pushUint8(184);
+            cursor.pushUint8(size3);
+            for (const entry of entries) {
+              entry.key.encode(cursor);
+              entry.value.encode(cursor);
+            }
+          }
+        };
+      if (size3 <= 65535)
+        return {
+          length: 3 + bodyLength,
+          encode(cursor) {
+            cursor.pushUint8(185);
+            cursor.pushUint16(size3);
+            for (const entry of entries) {
+              entry.key.encode(cursor);
+              entry.value.encode(cursor);
+            }
+          }
+        };
+      if (size3 <= 4294967295)
+        return {
+          length: 5 + bodyLength,
+          encode(cursor) {
+            cursor.pushUint8(186);
+            cursor.pushUint32(size3);
+            for (const entry of entries) {
+              entry.key.encode(cursor);
+              entry.value.encode(cursor);
+            }
+          }
+        };
+      throw new ObjectTooLargeError({ size: size3 });
+    }
+    getEncodable2.object = object;
+    function map(value) {
+      const entries = [];
+      for (const [k, v] of value)
+        entries.push({ key: getEncodable2(k), value: getEncodable2(v) });
+      const bodyLength = entries.reduce((acc, entry) => acc + entry.key.length + entry.value.length, 0);
+      const size3 = value.size;
+      if (size3 <= 23)
+        return {
+          length: 1 + bodyLength,
+          encode(cursor) {
+            cursor.pushUint8(160 + size3);
+            for (const entry of entries) {
+              entry.key.encode(cursor);
+              entry.value.encode(cursor);
+            }
+          }
+        };
+      if (size3 <= 255)
+        return {
+          length: 2 + bodyLength,
+          encode(cursor) {
+            cursor.pushUint8(184);
+            cursor.pushUint8(size3);
+            for (const entry of entries) {
+              entry.key.encode(cursor);
+              entry.value.encode(cursor);
+            }
+          }
+        };
+      if (size3 <= 65535)
+        return {
+          length: 3 + bodyLength,
+          encode(cursor) {
+            cursor.pushUint8(185);
+            cursor.pushUint16(size3);
+            for (const entry of entries) {
+              entry.key.encode(cursor);
+              entry.value.encode(cursor);
+            }
+          }
+        };
+      if (size3 <= 4294967295)
+        return {
+          length: 5 + bodyLength,
+          encode(cursor) {
+            cursor.pushUint8(186);
+            cursor.pushUint32(size3);
+            for (const entry of entries) {
+              entry.key.encode(cursor);
+              entry.value.encode(cursor);
+            }
+          }
+        };
+      throw new ObjectTooLargeError({ size: size3 });
+    }
+    getEncodable2.map = map;
+  })(getEncodable || (getEncodable = {}));
+  (function(decodeCursor2) {
+    function readLength(cursor, additionalInfo) {
+      if (additionalInfo < 24)
+        return additionalInfo;
+      if (additionalInfo === 24)
+        return cursor.readUint8();
+      if (additionalInfo === 25)
+        return cursor.readUint16();
+      if (additionalInfo === 26)
+        return cursor.readUint32();
+      if (additionalInfo === 27)
+        throw new Unsupported64BitIntegerError;
+      throw new InvalidAdditionalInfoError({ additionalInfo });
+    }
+    function readUnsignedInteger(cursor, additionalInfo) {
+      return readLength(cursor, additionalInfo);
+    }
+    decodeCursor2.readUnsignedInteger = readUnsignedInteger;
+    function readNegativeInteger(cursor, additionalInfo) {
+      const value = readLength(cursor, additionalInfo);
+      return -1 - value;
+    }
+    decodeCursor2.readNegativeInteger = readNegativeInteger;
+    function readByteString(cursor, additionalInfo) {
+      if (additionalInfo === 31) {
+        const chunks = [];
+        let totalLength = 0;
+        while (true) {
+          const byte = cursor.inspectUint8();
+          if (byte === 255) {
+            cursor.readUint8();
+            break;
+          }
+          const chunk = decodeCursor2(cursor);
+          if (!(chunk instanceof Uint8Array))
+            throw new InvalidIndefiniteLengthChunkError({ type: "byte string" });
+          chunks.push(chunk);
+          totalLength += chunk.length;
+        }
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+          result.set(chunk, offset);
+          offset += chunk.length;
+        }
+        return result;
+      }
+      const length = readLength(cursor, additionalInfo);
+      return cursor.readBytes(length);
+    }
+    decodeCursor2.readByteString = readByteString;
+    function readTextString(cursor, additionalInfo) {
+      if (additionalInfo === 31) {
+        const chunks = [];
+        while (true) {
+          const byte = cursor.inspectUint8();
+          if (byte === 255) {
+            cursor.readUint8();
+            break;
+          }
+          const chunk = decodeCursor2(cursor);
+          if (typeof chunk !== "string")
+            throw new InvalidIndefiniteLengthChunkError({ type: "text string" });
+          chunks.push(chunk);
+        }
+        return chunks.join("");
+      }
+      const length = readLength(cursor, additionalInfo);
+      const bytes = cursor.readBytes(length);
+      return toString(bytes);
+    }
+    decodeCursor2.readTextString = readTextString;
+    function readArray(cursor, additionalInfo) {
+      if (additionalInfo === 31) {
+        const result2 = [];
+        while (true) {
+          const byte = cursor.inspectUint8();
+          if (byte === 255) {
+            cursor.readUint8();
+            break;
+          }
+          result2.push(decodeCursor2(cursor));
+        }
+        return result2;
+      }
+      const length = readLength(cursor, additionalInfo);
+      const result = [];
+      for (let i = 0;i < length; i++) {
+        result.push(decodeCursor2(cursor));
+      }
+      return result;
+    }
+    decodeCursor2.readArray = readArray;
+    function readMap(cursor, additionalInfo) {
+      if (additionalInfo === 31) {
+        const result2 = {};
+        while (true) {
+          const byte = cursor.inspectUint8();
+          if (byte === 255) {
+            cursor.readUint8();
+            break;
+          }
+          const key = decodeCursor2(cursor);
+          const keyStr = typeof key === "string" ? key : typeof key === "number" ? String(key) : String(key);
+          const value = decodeCursor2(cursor);
+          result2[keyStr] = value;
+        }
+        return result2;
+      }
+      const length = readLength(cursor, additionalInfo);
+      const result = {};
+      for (let i = 0;i < length; i++) {
+        const key = decodeCursor2(cursor);
+        const keyStr = typeof key === "string" ? key : typeof key === "number" ? String(key) : String(key);
+        const value = decodeCursor2(cursor);
+        result[keyStr] = value;
+      }
+      return result;
+    }
+    decodeCursor2.readMap = readMap;
+    function readSimpleOrFloat(cursor, additionalInfo) {
+      if (additionalInfo === 20)
+        return false;
+      if (additionalInfo === 21)
+        return true;
+      if (additionalInfo === 22)
+        return null;
+      if (additionalInfo === 23)
+        return;
+      if (additionalInfo === 25) {
+        const bits = cursor.readUint16();
+        return getFloat16(bits);
+      }
+      if (additionalInfo === 26) {
+        const value = cursor.dataView.getFloat32(cursor.position, false);
+        cursor.position += 4;
+        return value;
+      }
+      if (additionalInfo === 27) {
+        const value = cursor.dataView.getFloat64(cursor.position, false);
+        cursor.position += 8;
+        return value;
+      }
+      if (additionalInfo === 24) {
+        const simpleValue = cursor.readUint8();
+        if (simpleValue < 32)
+          throw new InvalidSimpleValueError({ value: simpleValue });
+        return;
+      }
+      throw new InvalidAdditionalInfoError({ additionalInfo });
+    }
+    decodeCursor2.readSimpleOrFloat = readSimpleOrFloat;
+    function getFloat16(bits) {
+      const sign = bits >> 15 & 1;
+      const exponent = bits >> 10 & 31;
+      const fraction = bits & 1023;
+      if (exponent === 0) {
+        if (fraction === 0)
+          return sign ? -0 : 0;
+        const value2 = 2 ** -14 * (fraction / 1024);
+        return sign ? -value2 : value2;
+      }
+      if (exponent === 31) {
+        if (fraction === 0)
+          return sign ? -Infinity : Infinity;
+        return NaN;
+      }
+      const value = 2 ** (exponent - 15) * (1 + fraction / 1024);
+      return sign ? -value : value;
+    }
+  })(decodeCursor || (decodeCursor = {}));
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/CompactSize.js
+var init_CompactSize = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/ContractAddress.js
+var init_ContractAddress = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/CoseKey.js
+var init_CoseKey = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Ed25519.js
+var init_Ed25519 = () => {};
+
+// node_modules/@adraffy/ens-normalize/dist/index.mjs
+var FENCED, S0 = 44032, L0 = 4352, V0 = 4449, T0 = 4519, L_COUNT = 19, V_COUNT = 21, T_COUNT = 28, N_COUNT, S_COUNT, S1, L1, V1, T1;
+var init_dist = __esm(() => {
+  FENCED = new Map([[8217, "apostrophe"], [8260, "fraction slash"], [12539, "middle dot"]]);
+  N_COUNT = V_COUNT * T_COUNT;
+  S_COUNT = L_COUNT * N_COUNT;
+  S1 = S0 + S_COUNT;
+  L1 = L0 + L_COUNT;
+  V1 = V0 + V_COUNT;
+  T1 = T0 + T_COUNT;
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/Ens.js
+var init_Ens = __esm(() => {
+  init_dist();
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/Fee.js
+var init_Fee = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Filter.js
+var init_Filter = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Secp256k1.js
+var init_Secp256k1 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/HdKey.js
+var init_HdKey = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Keystore.js
+var init_Keystore = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Log.js
+var init_Log = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Mnemonic.js
+var init_Mnemonic = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/P256.js
+var init_P256 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/PersonalMessage.js
+var init_PersonalMessage = () => {};
+
+// node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS((exports, module) => {
+  var has = Object.prototype.hasOwnProperty;
+  var prefix = "~";
+  function Events() {}
+  if (Object.create) {
+    Events.prototype = Object.create(null);
+    if (!new Events().__proto__)
+      prefix = false;
+  }
+  function EE(fn, context, once) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once || false;
+  }
+  function addListener(emitter, event, fn, context, once) {
+    if (typeof fn !== "function") {
+      throw new TypeError("The listener must be a function");
+    }
+    var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+    if (!emitter._events[evt])
+      emitter._events[evt] = listener, emitter._eventsCount++;
+    else if (!emitter._events[evt].fn)
+      emitter._events[evt].push(listener);
+    else
+      emitter._events[evt] = [emitter._events[evt], listener];
+    return emitter;
+  }
+  function clearEvent(emitter, evt) {
+    if (--emitter._eventsCount === 0)
+      emitter._events = new Events;
+    else
+      delete emitter._events[evt];
+  }
+  function EventEmitter() {
+    this._events = new Events;
+    this._eventsCount = 0;
+  }
+  EventEmitter.prototype.eventNames = function eventNames() {
+    var names = [], events, name;
+    if (this._eventsCount === 0)
+      return names;
+    for (name in events = this._events) {
+      if (has.call(events, name))
+        names.push(prefix ? name.slice(1) : name);
+    }
+    if (Object.getOwnPropertySymbols) {
+      return names.concat(Object.getOwnPropertySymbols(events));
+    }
+    return names;
+  };
+  EventEmitter.prototype.listeners = function listeners(event) {
+    var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+    if (!handlers)
+      return [];
+    if (handlers.fn)
+      return [handlers.fn];
+    for (var i = 0, l = handlers.length, ee = new Array(l);i < l; i++) {
+      ee[i] = handlers[i].fn;
+    }
+    return ee;
+  };
+  EventEmitter.prototype.listenerCount = function listenerCount(event) {
+    var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+    if (!listeners)
+      return 0;
+    if (listeners.fn)
+      return 1;
+    return listeners.length;
+  };
+  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return false;
+    var listeners = this._events[evt], len = arguments.length, args, i;
+    if (listeners.fn) {
+      if (listeners.once)
+        this.removeListener(event, listeners.fn, undefined, true);
+      switch (len) {
+        case 1:
+          return listeners.fn.call(listeners.context), true;
+        case 2:
+          return listeners.fn.call(listeners.context, a1), true;
+        case 3:
+          return listeners.fn.call(listeners.context, a1, a2), true;
+        case 4:
+          return listeners.fn.call(listeners.context, a1, a2, a3), true;
+        case 5:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+        case 6:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+      }
+      for (i = 1, args = new Array(len - 1);i < len; i++) {
+        args[i - 1] = arguments[i];
+      }
+      listeners.fn.apply(listeners.context, args);
+    } else {
+      var length = listeners.length, j;
+      for (i = 0;i < length; i++) {
+        if (listeners[i].once)
+          this.removeListener(event, listeners[i].fn, undefined, true);
+        switch (len) {
+          case 1:
+            listeners[i].fn.call(listeners[i].context);
+            break;
+          case 2:
+            listeners[i].fn.call(listeners[i].context, a1);
+            break;
+          case 3:
+            listeners[i].fn.call(listeners[i].context, a1, a2);
+            break;
+          case 4:
+            listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+            break;
+          default:
+            if (!args)
+              for (j = 1, args = new Array(len - 1);j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+            listeners[i].fn.apply(listeners[i].context, args);
+        }
+      }
+    }
+    return true;
+  };
+  EventEmitter.prototype.on = function on(event, fn, context) {
+    return addListener(this, event, fn, context, false);
+  };
+  EventEmitter.prototype.once = function once(event, fn, context) {
+    return addListener(this, event, fn, context, true);
+  };
+  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return this;
+    if (!fn) {
+      clearEvent(this, evt);
+      return this;
+    }
+    var listeners = this._events[evt];
+    if (listeners.fn) {
+      if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+        clearEvent(this, evt);
+      }
+    } else {
+      for (var i = 0, events = [], length = listeners.length;i < length; i++) {
+        if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+          events.push(listeners[i]);
+        }
+      }
+      if (events.length)
+        this._events[evt] = events.length === 1 ? events[0] : events;
+      else
+        clearEvent(this, evt);
+    }
+    return this;
+  };
+  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+    var evt;
+    if (event) {
+      evt = prefix ? prefix + event : event;
+      if (this._events[evt])
+        clearEvent(this, evt);
+    } else {
+      this._events = new Events;
+      this._eventsCount = 0;
+    }
+    return this;
+  };
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+  EventEmitter.prefixed = prefix;
+  EventEmitter.EventEmitter = EventEmitter;
+  if (typeof module !== "undefined") {
+    module.exports = EventEmitter;
+  }
+});
+
+// node_modules/eventemitter3/index.mjs
+var import__2;
+var init_eventemitter3 = __esm(() => {
+  import__2 = __toESM(require_eventemitter3(), 1);
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/RpcResponse.js
+var BaseError2, InvalidInputError2, ResourceNotFoundError, ResourceUnavailableError, TransactionRejectedError, MethodNotSupportedError, LimitExceededError, VersionNotSupportedError, InvalidRequestError, MethodNotFoundError, InvalidParamsError, InternalError, ParseError;
+var init_RpcResponse = __esm(() => {
+  BaseError2 = class BaseError2 extends Error {
+    constructor(errorObject) {
+      const { cause, code, message, data, stack } = errorObject;
+      super(message, { cause });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.BaseError"
+      });
+      Object.defineProperty(this, "cause", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "stack", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "data", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      this.cause = cause;
+      this.code = code;
+      this.data = data;
+      this.stack = stack ?? "";
+    }
+  };
+  InvalidInputError2 = class InvalidInputError2 extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        code: InvalidInputError2.code,
+        data: parameters.data,
+        message: parameters.message ?? "Missing or invalid parameters."
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32000
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.InvalidInputError"
+      });
+    }
+  };
+  Object.defineProperty(InvalidInputError2, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: -32000
+  });
+  ResourceNotFoundError = class ResourceNotFoundError extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        code: ResourceNotFoundError.code,
+        data: parameters.data,
+        message: parameters.message ?? "Requested resource not found."
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32001
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.ResourceNotFoundError"
+      });
+    }
+  };
+  Object.defineProperty(ResourceNotFoundError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: -32001
+  });
+  ResourceUnavailableError = class ResourceUnavailableError extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        code: ResourceUnavailableError.code,
+        data: parameters.data,
+        message: parameters.message ?? "Requested resource not available."
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32002
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.ResourceUnavailableError"
+      });
+    }
+  };
+  Object.defineProperty(ResourceUnavailableError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: -32002
+  });
+  TransactionRejectedError = class TransactionRejectedError extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        code: TransactionRejectedError.code,
+        data: parameters.data,
+        message: parameters.message ?? "Transaction creation failed."
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32003
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.TransactionRejectedError"
+      });
+    }
+  };
+  Object.defineProperty(TransactionRejectedError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: -32003
+  });
+  MethodNotSupportedError = class MethodNotSupportedError extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        code: MethodNotSupportedError.code,
+        data: parameters.data,
+        message: parameters.message ?? "Method is not implemented."
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32004
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.MethodNotSupportedError"
+      });
+    }
+  };
+  Object.defineProperty(MethodNotSupportedError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: -32004
+  });
+  LimitExceededError = class LimitExceededError extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        code: LimitExceededError.code,
+        data: parameters.data,
+        message: parameters.message ?? "Rate limit exceeded."
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32005
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.LimitExceededError"
+      });
+    }
+  };
+  Object.defineProperty(LimitExceededError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: -32005
+  });
+  VersionNotSupportedError = class VersionNotSupportedError extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        code: VersionNotSupportedError.code,
+        data: parameters.data,
+        message: parameters.message ?? "JSON-RPC version not supported."
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32006
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.VersionNotSupportedError"
+      });
+    }
+  };
+  Object.defineProperty(VersionNotSupportedError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: -32006
+  });
+  InvalidRequestError = class InvalidRequestError extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        code: InvalidRequestError.code,
+        data: parameters.data,
+        message: parameters.message ?? "Input is not a valid JSON-RPC request."
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32600
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.InvalidRequestError"
+      });
+    }
+  };
+  Object.defineProperty(InvalidRequestError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: -32600
+  });
+  MethodNotFoundError = class MethodNotFoundError extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        code: MethodNotFoundError.code,
+        data: parameters.data,
+        message: parameters.message ?? "Method does not exist."
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32601
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.MethodNotFoundError"
+      });
+    }
+  };
+  Object.defineProperty(MethodNotFoundError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: -32601
+  });
+  InvalidParamsError = class InvalidParamsError extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        code: InvalidParamsError.code,
+        data: parameters.data,
+        message: parameters.message ?? "Invalid method parameters."
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32602
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.InvalidParamsError"
+      });
+    }
+  };
+  Object.defineProperty(InvalidParamsError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: -32602
+  });
+  InternalError = class InternalError extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        cause: parameters.cause,
+        code: InternalError.code,
+        data: parameters.data,
+        message: parameters.message ?? "Internal JSON-RPC error.",
+        stack: parameters.stack
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32603
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.InternalError"
+      });
+    }
+  };
+  Object.defineProperty(InternalError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: -32603
+  });
+  ParseError = class ParseError extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        code: ParseError.code,
+        data: parameters.data,
+        message: parameters.message ?? "Failed to parse JSON-RPC response."
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32700
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.ParseError"
+      });
     }
-    writeInto(out) {
-      aexists(this, false);
-      abytes(out);
-      this.finish();
-      const bufferOut = this.state;
-      const { blockLen } = this;
-      for (let pos = 0, len = out.length;pos < len; ) {
-        if (this.posOut >= blockLen)
-          this.keccak();
-        const take = Math.min(blockLen - this.posOut, len - pos);
-        out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
-        this.posOut += take;
-        pos += take;
-      }
-      return out;
+  };
+  Object.defineProperty(ParseError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: -32700
+  });
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/Provider.js
+var ProviderRpcError, UserRejectedRequestError, UnauthorizedError, UnsupportedMethodError, DisconnectedError, ChainDisconnectedError, SwitchChainError, UnsupportedNonOptionalCapabilityError, UnsupportedChainIdError, DuplicateIdError, UnknownBundleIdError, BundleTooLargeError, AtomicReadyWalletRejectedUpgradeError, AtomicityNotSupportedError;
+var init_Provider = __esm(() => {
+  init_eventemitter3();
+  ProviderRpcError = class ProviderRpcError extends Error {
+    constructor(code, message) {
+      super(message);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "ProviderRpcError"
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "details", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      this.code = code;
+      this.details = message;
     }
-    xofInto(out) {
-      if (!this.enableXOF)
-        throw new Error("XOF is not possible for this instance");
-      return this.writeInto(out);
+  };
+  UserRejectedRequestError = class UserRejectedRequestError extends ProviderRpcError {
+    constructor({ message = "The user rejected the request." } = {}) {
+      super(4001, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 4001
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.UserRejectedRequestError"
+      });
     }
-    xof(bytes) {
-      anumber(bytes);
-      return this.xofInto(new Uint8Array(bytes));
+  };
+  Object.defineProperty(UserRejectedRequestError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 4001
+  });
+  UnauthorizedError = class UnauthorizedError extends ProviderRpcError {
+    constructor({ message = "The requested method and/or account has not been authorized by the user." } = {}) {
+      super(4100, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 4100
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.UnauthorizedError"
+      });
     }
-    digestInto(out) {
-      aoutput(out, this);
-      if (this.finished)
-        throw new Error("digest() was already called");
-      this.writeInto(out);
-      this.destroy();
-      return out;
+  };
+  Object.defineProperty(UnauthorizedError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 4100
+  });
+  UnsupportedMethodError = class UnsupportedMethodError extends ProviderRpcError {
+    constructor({ message = "The provider does not support the requested method." } = {}) {
+      super(4200, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 4200
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.UnsupportedMethodError"
+      });
     }
-    digest() {
-      return this.digestInto(new Uint8Array(this.outputLen));
+  };
+  Object.defineProperty(UnsupportedMethodError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 4200
+  });
+  DisconnectedError = class DisconnectedError extends ProviderRpcError {
+    constructor({ message = "The provider is disconnected from all chains." } = {}) {
+      super(4900, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 4900
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.DisconnectedError"
+      });
     }
-    destroy() {
-      this.destroyed = true;
-      clean(this.state);
+  };
+  Object.defineProperty(DisconnectedError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 4900
+  });
+  ChainDisconnectedError = class ChainDisconnectedError extends ProviderRpcError {
+    constructor({ message = "The provider is not connected to the requested chain." } = {}) {
+      super(4901, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 4901
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.ChainDisconnectedError"
+      });
     }
-    _cloneInto(to) {
-      const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
-      to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
-      to.state32.set(this.state32);
-      to.pos = this.pos;
-      to.posOut = this.posOut;
-      to.finished = this.finished;
-      to.rounds = rounds;
-      to.suffix = suffix;
-      to.outputLen = outputLen;
-      to.enableXOF = enableXOF;
-      to.destroyed = this.destroyed;
-      return to;
+  };
+  Object.defineProperty(ChainDisconnectedError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 4901
+  });
+  SwitchChainError = class SwitchChainError extends ProviderRpcError {
+    constructor({ message = "An error occurred when attempting to switch chain." } = {}) {
+      super(4902, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 4902
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.SwitchChainError"
+      });
     }
   };
-  keccak_256 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
-});
-
-// node_modules/@noble/hashes/esm/sha2.js
-var SHA256_K, SHA256_W, SHA256, sha256;
-var init_sha2 = __esm(() => {
-  init__md();
-  init_utils2();
-  SHA256_K = /* @__PURE__ */ Uint32Array.from([
-    1116352408,
-    1899447441,
-    3049323471,
-    3921009573,
-    961987163,
-    1508970993,
-    2453635748,
-    2870763221,
-    3624381080,
-    310598401,
-    607225278,
-    1426881987,
-    1925078388,
-    2162078206,
-    2614888103,
-    3248222580,
-    3835390401,
-    4022224774,
-    264347078,
-    604807628,
-    770255983,
-    1249150122,
-    1555081692,
-    1996064986,
-    2554220882,
-    2821834349,
-    2952996808,
-    3210313671,
-    3336571891,
-    3584528711,
-    113926993,
-    338241895,
-    666307205,
-    773529912,
-    1294757372,
-    1396182291,
-    1695183700,
-    1986661051,
-    2177026350,
-    2456956037,
-    2730485921,
-    2820302411,
-    3259730800,
-    3345764771,
-    3516065817,
-    3600352804,
-    4094571909,
-    275423344,
-    430227734,
-    506948616,
-    659060556,
-    883997877,
-    958139571,
-    1322822218,
-    1537002063,
-    1747873779,
-    1955562222,
-    2024104815,
-    2227730452,
-    2361852424,
-    2428436474,
-    2756734187,
-    3204031479,
-    3329325298
-  ]);
-  SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-  SHA256 = class SHA256 extends HashMD {
-    constructor(outputLen = 32) {
-      super(64, outputLen, 8, false);
-      this.A = SHA256_IV[0] | 0;
-      this.B = SHA256_IV[1] | 0;
-      this.C = SHA256_IV[2] | 0;
-      this.D = SHA256_IV[3] | 0;
-      this.E = SHA256_IV[4] | 0;
-      this.F = SHA256_IV[5] | 0;
-      this.G = SHA256_IV[6] | 0;
-      this.H = SHA256_IV[7] | 0;
+  Object.defineProperty(SwitchChainError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 4902
+  });
+  UnsupportedNonOptionalCapabilityError = class UnsupportedNonOptionalCapabilityError extends ProviderRpcError {
+    constructor({ message = "This Wallet does not support a capability that was not marked as optional." } = {}) {
+      super(5700, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 5700
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.UnsupportedNonOptionalCapabilityError"
+      });
     }
-    get() {
-      const { A, B, C, D: D2, E, F, G, H } = this;
-      return [A, B, C, D2, E, F, G, H];
+  };
+  Object.defineProperty(UnsupportedNonOptionalCapabilityError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 5700
+  });
+  UnsupportedChainIdError = class UnsupportedChainIdError extends ProviderRpcError {
+    constructor({ message = "This Wallet does not support the requested chain ID." } = {}) {
+      super(5710, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 5710
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.UnsupportedChainIdError"
+      });
     }
-    set(A, B, C, D2, E, F, G, H) {
-      this.A = A | 0;
-      this.B = B | 0;
-      this.C = C | 0;
-      this.D = D2 | 0;
-      this.E = E | 0;
-      this.F = F | 0;
-      this.G = G | 0;
-      this.H = H | 0;
+  };
+  Object.defineProperty(UnsupportedChainIdError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 5710
+  });
+  DuplicateIdError = class DuplicateIdError extends ProviderRpcError {
+    constructor({ message = "There is already a bundle submitted with this ID." } = {}) {
+      super(5720, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 5720
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.DuplicateIdError"
+      });
     }
-    process(view, offset) {
-      for (let i = 0;i < 16; i++, offset += 4)
-        SHA256_W[i] = view.getUint32(offset, false);
-      for (let i = 16;i < 64; i++) {
-        const W15 = SHA256_W[i - 15];
-        const W2 = SHA256_W[i - 2];
-        const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-        const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
-        SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
-      }
-      let { A, B, C, D: D2, E, F, G, H } = this;
-      for (let i = 0;i < 64; i++) {
-        const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-        const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-        const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
-        const T2 = sigma0 + Maj(A, B, C) | 0;
-        H = G;
-        G = F;
-        F = E;
-        E = D2 + T1 | 0;
-        D2 = C;
-        C = B;
-        B = A;
-        A = T1 + T2 | 0;
-      }
-      A = A + this.A | 0;
-      B = B + this.B | 0;
-      C = C + this.C | 0;
-      D2 = D2 + this.D | 0;
-      E = E + this.E | 0;
-      F = F + this.F | 0;
-      G = G + this.G | 0;
-      H = H + this.H | 0;
-      this.set(A, B, C, D2, E, F, G, H);
+  };
+  Object.defineProperty(DuplicateIdError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 5720
+  });
+  UnknownBundleIdError = class UnknownBundleIdError extends ProviderRpcError {
+    constructor({ message = "This bundle id is unknown / has not been submitted." } = {}) {
+      super(5730, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 5730
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.UnknownBundleIdError"
+      });
     }
-    roundClean() {
-      clean(SHA256_W);
+  };
+  Object.defineProperty(UnknownBundleIdError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 5730
+  });
+  BundleTooLargeError = class BundleTooLargeError extends ProviderRpcError {
+    constructor({ message = "The call bundle is too large for the Wallet to process." } = {}) {
+      super(5740, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 5740
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.BundleTooLargeError"
+      });
     }
-    destroy() {
-      this.set(0, 0, 0, 0, 0, 0, 0, 0);
-      clean(this.buffer);
+  };
+  Object.defineProperty(BundleTooLargeError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 5740
+  });
+  AtomicReadyWalletRejectedUpgradeError = class AtomicReadyWalletRejectedUpgradeError extends ProviderRpcError {
+    constructor({ message = "The Wallet can support atomicity after an upgrade, but the user rejected the upgrade." } = {}) {
+      super(5750, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 5750
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.AtomicReadyWalletRejectedUpgradeError"
+      });
     }
   };
-  sha256 = /* @__PURE__ */ createHasher(() => new SHA256);
+  Object.defineProperty(AtomicReadyWalletRejectedUpgradeError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 5750
+  });
+  AtomicityNotSupportedError = class AtomicityNotSupportedError extends ProviderRpcError {
+    constructor({ message = "The wallet does not support atomic execution but the request requires it." } = {}) {
+      super(5760, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 5760
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.AtomicityNotSupportedError"
+      });
+    }
+  };
+  Object.defineProperty(AtomicityNotSupportedError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 5760
+  });
 });
 
-// node_modules/@noble/hashes/esm/sha256.js
-var sha2562;
-var init_sha256 = __esm(() => {
-  init_sha2();
-  sha2562 = sha256;
-});
+// node_modules/mppx/node_modules/ox/_esm/core/RpcTransport.js
+var init_RpcTransport = () => {};
 
-// node_modules/mppx/node_modules/ox/_esm/core/Hash.js
-var exports_Hash = {};
-__export(exports_Hash, {
-  validate: () => validate4,
-  sha256: () => sha2563,
-  ripemd160: () => ripemd1603,
-  keccak256: () => keccak256,
-  hmac256: () => hmac256
-});
-function keccak256(value, options2 = {}) {
-  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
-  const bytes = keccak_256(from(value));
-  if (as === "Bytes")
-    return bytes;
-  return fromBytes(bytes);
-}
-function hmac256(key, value, options2 = {}) {
-  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
-  const bytes = hmac(sha2562, from(key), from(value));
-  if (as === "Bytes")
-    return bytes;
-  return fromBytes(bytes);
-}
-function ripemd1603(value, options2 = {}) {
-  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
-  const bytes = ripemd1602(from(value));
-  if (as === "Bytes")
-    return bytes;
-  return fromBytes(bytes);
-}
-function sha2563(value, options2 = {}) {
-  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
-  const bytes = sha2562(from(value));
-  if (as === "Bytes")
-    return bytes;
-  return fromBytes(bytes);
-}
-function validate4(value) {
-  return validate2(value) && size2(value) === 32;
-}
-var init_Hash = __esm(() => {
-  init_hmac();
-  init_ripemd160();
-  init_sha3();
-  init_sha256();
-  init_Bytes();
-  init_Hex();
-});
+// node_modules/mppx/node_modules/ox/_esm/core/Siwe.js
+var init_Siwe = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/StateOverrides.js
+var init_StateOverrides = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TransactionReceipt.js
+var init_TransactionReceipt = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TransactionRequest.js
+var init_TransactionRequest = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Value.js
+var init_Value = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TxEnvelope.js
+var init_TxEnvelope = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TxEnvelopeEip1559.js
+var init_TxEnvelopeEip1559 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TxEnvelopeEip2930.js
+var init_TxEnvelopeEip2930 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TxEnvelopeEip4844.js
+var init_TxEnvelopeEip4844 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TxEnvelopeEip7702.js
+var init_TxEnvelopeEip7702 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TxEnvelopeLegacy.js
+var init_TxEnvelopeLegacy = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TypedData.js
+var init_TypedData = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/ValidatorData.js
+var init_ValidatorData = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/WebAuthnP256.js
+var init_WebAuthnP256 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/WebCryptoP256.js
+var init_WebCryptoP256 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/X25519.js
+var init_X25519 = () => {};
 
 // node_modules/mppx/node_modules/ox/_esm/index.js
 var init__esm = __esm(() => {
+  init_Abi();
+  init_AbiConstructor();
+  init_AbiError();
+  init_AbiEvent();
+  init_AbiFunction();
+  init_AbiItem();
+  init_AbiParameters();
+  init_AccessList();
+  init_AccountProof();
+  init_Address();
+  init_AesGcm();
+  init_Authorization();
+  init_Base32();
+  init_Base58();
   init_Base64();
+  init_Bech32m();
+  init_BinaryStateTree();
+  init_Blobs();
+  init_Block();
+  init_BlockOverrides();
+  init_Bloom();
+  init_Bls();
+  init_BlsPoint();
   init_Bytes();
+  init_Caches();
+  init_Cbor();
+  init_CompactSize();
+  init_ContractAddress();
+  init_CoseKey();
+  init_Ed25519();
+  init_Ens();
+  init_Errors();
+  init_Fee();
+  init_Filter();
   init_Hash();
+  init_HdKey();
   init_Hex();
+  init_Keystore();
+  init_Log();
+  init_Mnemonic();
+  init_P256();
+  init_PersonalMessage();
+  init_Provider();
+  init_PublicKey();
+  init_Rlp();
+  init_RpcResponse();
+  init_RpcTransport();
+  init_Secp256k1();
+  init_Signature();
+  init_Siwe();
+  init_Solidity();
+  init_StateOverrides();
+  init_Transaction();
+  init_TransactionReceipt();
+  init_TransactionRequest();
+  init_TxEnvelope();
+  init_TxEnvelopeEip1559();
+  init_TxEnvelopeEip2930();
+  init_TxEnvelopeEip4844();
+  init_TxEnvelopeEip7702();
+  init_TxEnvelopeLegacy();
+  init_TypedData();
+  init_ValidatorData();
+  init_Value();
+  init_WebAuthnP256();
+  init_WebCryptoP256();
+  init_Withdrawal();
+  init_X25519();
 });
 
+// node_modules/mppx/dist/BodyDigest.js
+var init_BodyDigest = () => {};
+
 // node_modules/mppx/dist/PaymentRequest.js
 function deserialize(encoded) {
   const json = exports_Base64.toString(encoded);
@@ -9433,7 +11608,7 @@ __export(exports_util, {
   assertNever: () => assertNever,
   assertIs: () => assertIs,
   assertEqual: () => assertEqual,
-  assert: () => assert3,
+  assert: () => assert4,
   allowsEval: () => allowsEval,
   aborted: () => aborted,
   NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
@@ -9450,7 +11625,7 @@ function assertIs(_arg) {}
 function assertNever(_x) {
   throw new Error("Unexpected value in exhaustive check");
 }
-function assert3(_) {}
+function assert4(_) {}
 function getEnumValues(entries) {
   const numericValues = Object.values(entries).filter((v) => typeof v === "number");
   const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
@@ -19992,7 +22167,7 @@ function finalize(ctx, schema) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {}
+  } else if (ctx.target === "openapi-3.0") {} else {}
   if (ctx.external?.uri) {
     const id = ctx.external.registry.get(schema)?.id;
     if (!id)
@@ -20257,7 +22432,7 @@ var formatMap, stringProcessor = (schema, ctx, _json, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      }
+      } else {}
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -22670,6 +24845,12 @@ var init_Credential = __esm(() => {
   };
 });
 
+// node_modules/mppx/dist/Errors.js
+var init_Errors2 = () => {};
+
+// node_modules/mppx/dist/Expires.js
+var init_Expires = () => {};
+
 // node_modules/mppx/dist/Method.js
 var exports_Method = {};
 __export(exports_Method, {
@@ -22701,9 +24882,32 @@ function toServer(method, options2) {
   };
 }
 
+// node_modules/mppx/dist/Receipt.js
+var Schema2;
+var init_Receipt = __esm(() => {
+  init_zod();
+  Schema2 = object({
+    method: string2(),
+    reference: string2(),
+    externalId: optional(string2()),
+    status: literal("success"),
+    timestamp: datetime3()
+  });
+});
+
+// node_modules/mppx/dist/Store.js
+var init_Store = () => {};
+
 // node_modules/mppx/dist/index.js
-var init_dist = __esm(() => {
+var init_dist2 = __esm(() => {
+  init_BodyDigest();
+  init_Challenge();
   init_Credential();
+  init_Errors2();
+  init_Expires();
+  init_PaymentRequest();
+  init_Receipt();
+  init_Store();
   init_zod();
 });
 
@@ -22720,7 +24924,7 @@ var init_constants = __esm(() => {
 // node_modules/@solana/mpp/dist/Methods.js
 var charge;
 var init_Methods = __esm(() => {
-  init_dist();
+  init_dist2();
   charge = exports_Method.from({
     intent: "charge",
     name: "solana",
@@ -22911,7 +25115,7 @@ var init_Charge = __esm(() => {
   init_src();
   init_src2();
   init_src3();
-  init_dist();
+  init_dist2();
   init_constants();
   init_Methods();
 });
@@ -23095,7 +25299,9 @@ var init_Mppx = __esm(() => {
 
 // node_modules/mppx/dist/client/index.js
 var init_client = __esm(() => {
+  init_Expires();
   init_Mppx();
+  init_Transport();
 });
 
 // node_modules/@solana/mpp/dist/client/index.js
@@ -27521,18 +29727,18 @@ async function uploadCreateInput(auth, source, kind) {
   if (file2.size > config2.maxBytes) {
     throw new Error(`"${source}" is ${file2.size} bytes; the ${kind} limit is ${config2.maxBytes} bytes (${KIND_ACCEPTS[kind]}).`);
   }
-  const session2 = await amikoWebFetch(auth, "/api/create/uploads", {
+  const session = await amikoWebFetch(auth, "/api/create/uploads", {
     method: "POST",
     body: { contentType: mime, sizeBytes: file2.size },
     timeoutMs: 30000
   });
-  if (!session2.uploadUrl || !session2.path) {
+  if (!session.uploadUrl || !session.path) {
     throw new Error(`Could not start the upload for "${source}".`);
   }
-  await presignedPut(session2.uploadUrl, file2.buffer, mime);
+  await presignedPut(session.uploadUrl, file2.buffer, mime);
   const finalized = await amikoWebFetch(auth, "/api/create/uploads", {
     method: "PUT",
-    body: { path: session2.path },
+    body: { path: session.path },
     timeoutMs: 30000
   });
   if (!finalized.url) {
@@ -33814,7 +36020,7 @@ function registerPostCommand(program2) {
       process.exit(1);
     }
   });
-  program2.command("drafts").description("List your draft posts (newest first)").option("--limit <n>", "Max results (1-100, default 20)", "20").option("--offset <n>", "Pagination offset", "0").option("--json", "Output as JSON").action(async (opts) => {
+  program2.command("drafts").description("List draft posts (newest first). Defaults to only YOUR OWN drafts (this twin's). Pass --all to include the owner's own drafts and other twins'.").option("--limit <n>", "Max results (1-100, default 20)", "20").option("--offset <n>", "Pagination offset", "0").option("--all", "Include every draft the owner holds — the owner's own composer drafts and other twins' — not just this twin's").option("--json", "Output as JSON").action(async (opts) => {
     const limit = Number(opts.limit ?? "20");
     const offset = Number(opts.offset ?? "0");
     if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
@@ -33832,14 +36038,15 @@ function registerPostCommand(program2) {
         query: {
           status: "draft",
           limit,
-          offset
+          offset,
+          ...opts.all ? { all: "true" } : {}
         }
       });
       spinner?.stop();
       const posts = data.posts ?? [];
       renderOutput(data, () => {
         if (posts.length === 0) {
-          console.log(dim('No drafts. Save one with: amiko post create --content "..." --draft'));
+          console.log(dim(opts.all ? 'No drafts. Save one with: amiko post create --content "..." --draft' : `No drafts of yours. Save one with: amiko post create --content "..." --draft (or --all to see the owner's own drafts)`));
           return;
         }
         console.log(heading(`Drafts — ${posts.length}`));