@heyamiko/amiko-cli 0.14.0-beta.7 → 0.14.0-beta.8

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,392 +7788,1190 @@ 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];
+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);
   }
-  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;
+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);
   }
-  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 createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
-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 rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
 }
-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 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;
+  return arr;
 }
-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 utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
 }
-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 toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
 }
-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);
+class Hash {
 }
-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 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;
 }
-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 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 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 Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD, SHA256_IV;
+var init__md = __esm(() => {
+  init_utils();
+  HashMD = class HashMD extends Hash {
+    constructor(blockLen, outputLen, padOffset, isLE2) {
+      super();
+      this.finished = false;
+      this.length = 0;
+      this.pos = 0;
+      this.destroyed = false;
+      this.blockLen = blockLen;
+      this.outputLen = outputLen;
+      this.padOffset = padOffset;
+      this.isLE = isLE2;
+      this.buffer = new Uint8Array(blockLen);
+      this.view = createView(this.buffer);
+    }
+    update(data) {
+      aexists(this);
+      data = toBytes(data);
+      abytes(data);
+      const { view, buffer, blockLen } = this;
+      const len = data.length;
+      for (let pos = 0;pos < len; ) {
+        const take = Math.min(blockLen - this.pos, len - pos);
+        if (take === blockLen) {
+          const dataView = createView(data);
+          for (;blockLen <= len - pos; pos += blockLen)
+            this.process(dataView, pos);
+          continue;
+        }
+        buffer.set(data.subarray(pos, pos + take), this.pos);
+        this.pos += take;
+        pos += take;
+        if (this.pos === blockLen) {
+          this.process(view, 0);
+          this.pos = 0;
+        }
+      }
+      this.length += data.length;
+      this.roundClean();
+      return this;
+    }
+    digestInto(out) {
+      aexists(this);
+      aoutput(out, this);
+      this.finished = true;
+      const { buffer, view, blockLen, isLE: isLE2 } = this;
+      let { pos } = this;
+      buffer[pos++] = 128;
+      clean(this.buffer.subarray(pos));
+      if (this.padOffset > blockLen - pos) {
+        this.process(view, 0);
+        pos = 0;
+      }
+      for (let i = pos;i < blockLen; i++)
+        buffer[i] = 0;
+      setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
+      this.process(view, 0);
+      const oview = createView(out);
+      const len = this.outputLen;
+      if (len % 4)
+        throw new Error("_sha2: outputLen should be aligned to 32bit");
+      const outLen = len / 4;
+      const state = this.get();
+      if (outLen > state.length)
+        throw new Error("_sha2: outputLen bigger than state");
+      for (let i = 0;i < outLen; i++)
+        oview.setUint32(4 * i, state[i], isLE2);
+    }
+    digest() {
+      const { buffer, outputLen } = this;
+      this.digestInto(buffer);
+      const res = buffer.slice(0, outputLen);
+      this.destroy();
+      return res;
+    }
+    _cloneInto(to) {
+      to || (to = new this.constructor);
+      to.set(...this.get());
+      const { blockLen, buffer, length, finished, destroyed, pos } = this;
+      to.destroyed = destroyed;
+      to.finished = finished;
+      to.length = length;
+      to.pos = pos;
+      if (length % blockLen)
+        to.buffer.set(buffer);
+      return to;
+    }
+    clone() {
+      return this._cloneInto();
+    }
+  };
+  SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+});
+
+// node_modules/@noble/hashes/esm/legacy.js
+function ripemd_f(group, x, y, z) {
+  if (group === 0)
+    return x ^ y ^ z;
+  if (group === 1)
+    return x & y | ~x & z;
+  if (group === 2)
+    return (x | ~y) ^ z;
+  if (group === 3)
+    return x & z | y & ~z;
+  return 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_utils();
+  Rho160 = /* @__PURE__ */ Uint8Array.from([
+    7,
+    4,
+    13,
+    1,
+    10,
+    6,
+    15,
+    3,
+    12,
+    0,
+    9,
+    5,
+    2,
+    14,
+    11,
+    8
+  ]);
+  Id160 = /* @__PURE__ */ (() => Uint8Array.from(new Array(16).fill(0).map((_, i) => i)))();
+  Pi160 = /* @__PURE__ */ (() => Id160.map((i) => (9 * i + 5) % 16))();
+  idxLR = /* @__PURE__ */ (() => {
+    const L = [Id160];
+    const R = [Pi160];
+    const res = [L, R];
+    for (let i = 0;i < 4; i++)
+      for (let j of res)
+        j.push(j[i].map((k) => Rho160[k]));
+    return res;
+  })();
+  idxL = /* @__PURE__ */ (() => idxLR[0])();
+  idxR = /* @__PURE__ */ (() => idxLR[1])();
+  shifts160 = /* @__PURE__ */ [
+    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
+    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
+    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
+    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
+    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
+  ].map((i) => Uint8Array.from(i));
+  shiftsL160 = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts160[i][j]));
+  shiftsR160 = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts160[i][j]));
+  Kl160 = /* @__PURE__ */ Uint32Array.from([
+    0,
+    1518500249,
+    1859775393,
+    2400959708,
+    2840853838
+  ]);
+  Kr160 = /* @__PURE__ */ Uint32Array.from([
+    1352829926,
+    1548603684,
+    1836072691,
+    2053994217,
+    0
+  ]);
+  BUF_160 = /* @__PURE__ */ new Uint32Array(16);
+  RIPEMD160 = class RIPEMD160 extends HashMD {
+    constructor() {
+      super(64, 20, 8, true);
+      this.h0 = 1732584193 | 0;
+      this.h1 = 4023233417 | 0;
+      this.h2 = 2562383102 | 0;
+      this.h3 = 271733878 | 0;
+      this.h4 = 3285377520 | 0;
+    }
+    get() {
+      const { h0, h1, h2, h3, h4 } = this;
+      return [h0, h1, h2, h3, h4];
+    }
+    set(h0, h1, h2, h3, h4) {
+      this.h0 = h0 | 0;
+      this.h1 = h1 | 0;
+      this.h2 = h2 | 0;
+      this.h3 = h3 | 0;
+      this.h4 = h4 | 0;
+    }
+    process(view, offset) {
+      for (let i = 0;i < 16; i++, offset += 4)
+        BUF_160[i] = view.getUint32(offset, true);
+      let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
+      for (let group = 0;group < 5; group++) {
+        const rGroup = 4 - group;
+        const hbl = Kl160[group], hbr = Kr160[group];
+        const rl = idxL[group], rr = idxR[group];
+        const sl = shiftsL160[group], sr = shiftsR160[group];
+        for (let i = 0;i < 16; i++) {
+          const tl = rotl(al + ripemd_f(group, bl, cl, dl) + BUF_160[rl[i]] + hbl, sl[i]) + el | 0;
+          al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
+        }
+        for (let i = 0;i < 16; i++) {
+          const tr = rotl(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i]] + hbr, sr[i]) + er | 0;
+          ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
+        }
+      }
+      this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
+    }
+    roundClean() {
+      clean(BUF_160);
+    }
+    destroy() {
+      this.destroyed = true;
+      clean(this.buffer);
+      this.set(0, 0, 0, 0, 0);
+    }
+  };
+  ripemd160 = /* @__PURE__ */ createHasher(() => new RIPEMD160);
+});
+
+// node_modules/@noble/hashes/esm/ripemd160.js
+var ripemd1602;
+var init_ripemd160 = __esm(() => {
+  init_legacy();
+  ripemd1602 = ripemd160;
+});
+
+// node_modules/@noble/hashes/esm/_u64.js
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0;i < len; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var U32_MASK64, _32n, rotlSH = (h, l, s) => h << s | l >>> 32 - s, rotlSL = (h, l, s) => l << s | h >>> 32 - s, rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s, rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+var init__u64 = __esm(() => {
+  U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+  _32n = /* @__PURE__ */ BigInt(32);
+});
+
+// node_modules/@noble/hashes/esm/sha3.js
+function keccakP(s, rounds = 24) {
+  const B = new Uint32Array(5 * 2);
+  for (let round = 24 - rounds;round < 24; round++) {
+    for (let x = 0;x < 10; x++)
+      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0;x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0;y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0;t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0;y < 50; y += 10) {
+      for (let x = 0;x < 10; x++)
+        B[x] = s[y + x];
+      for (let x = 0;x < 10; x++)
+        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
+  }
+  clean(B);
+}
+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_utils();
+  _0n = BigInt(0);
+  _1n = BigInt(1);
+  _2n = BigInt(2);
+  _7n = BigInt(7);
+  _256n = BigInt(256);
+  _0x71n = BigInt(113);
+  SHA3_PI = [];
+  SHA3_ROTL = [];
+  _SHA3_IOTA = [];
+  for (let round = 0, R = _1n, x = 1, y = 0;round < 24; round++) {
+    [x, y] = [y, (2 * x + 3 * y) % 5];
+    SHA3_PI.push(2 * (5 * y + x));
+    SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+    let t = _0n;
+    for (let j = 0;j < 7; j++) {
+      R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+      if (R & _2n)
+        t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+    }
+    _SHA3_IOTA.push(t);
+  }
+  IOTAS = split(_SHA3_IOTA, true);
+  SHA3_IOTA_H = IOTAS[0];
+  SHA3_IOTA_L = IOTAS[1];
+  Keccak = class Keccak extends Hash {
+    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+      super();
+      this.pos = 0;
+      this.posOut = 0;
+      this.finished = false;
+      this.destroyed = false;
+      this.enableXOF = false;
+      this.blockLen = blockLen;
+      this.suffix = suffix;
+      this.outputLen = outputLen;
+      this.enableXOF = enableXOF;
+      this.rounds = rounds;
+      anumber(outputLen);
+      if (!(0 < blockLen && blockLen < 200))
+        throw new Error("only keccak-f1600 function is supported");
+      this.state = new Uint8Array(200);
+      this.state32 = u32(this.state);
+    }
+    clone() {
+      return this._cloneInto();
+    }
+    keccak() {
+      swap32IfBE(this.state32);
+      keccakP(this.state32, this.rounds);
+      swap32IfBE(this.state32);
+      this.posOut = 0;
+      this.pos = 0;
+    }
+    update(data) {
+      aexists(this);
+      data = toBytes(data);
+      abytes(data);
+      const { blockLen, state } = this;
+      const len = data.length;
+      for (let pos = 0;pos < len; ) {
+        const take = Math.min(blockLen - this.pos, len - pos);
+        for (let i = 0;i < take; i++)
+          state[this.pos++] ^= data[pos++];
+        if (this.pos === blockLen)
+          this.keccak();
+      }
+      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();
+    }
+    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;
@@ -8231,9 +8999,9 @@ function fromNumber2(value, options2) {
   const hex = fromNumber(value, options2);
   return fromHex(hex);
 }
-function fromString(value, options2 = {}) {
+function fromString2(value, options2 = {}) {
   const { size: size3 } = options2;
-  const bytes = encoder.encode(value);
+  const bytes = encoder2.encode(value);
   if (typeof size3 === "number") {
     assertSize(bytes, size3);
     return padRight2(bytes, size3);
@@ -8314,15 +9082,15 @@ function validate3(value) {
     return false;
   }
 }
-var decoder, encoder, InvalidBytesBooleanError, InvalidBytesTypeError, SizeOverflowError, SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
+var decoder, encoder2, InvalidBytesBooleanError, InvalidBytesTypeError, SizeOverflowError, SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
 var init_Bytes = __esm(() => {
-  init_utils();
+  init_utils2();
   init_Errors();
   init_Hex();
   init_bytes();
   init_hex();
   decoder = /* @__PURE__ */ new TextDecoder;
-  encoder = /* @__PURE__ */ new TextEncoder;
+  encoder2 = /* @__PURE__ */ new TextEncoder;
   InvalidBytesBooleanError = class InvalidBytesBooleanError extends BaseError {
     constructor(bytes) {
       super(`Bytes value \`${bytes}\` is not a valid boolean.`, {
@@ -8358,41 +9126,469 @@ var init_Bytes = __esm(() => {
         enumerable: true,
         configurable: true,
         writable: true,
-        value: "Bytes.SizeOverflowError"
+        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"
       });
     }
   };
-  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}\`).`);
+  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: "Bytes.SliceOffsetOutOfBoundsError"
+        value: "AbiParameters.LengthMismatchError"
       });
     }
   };
-  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}\`).`);
+  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: "Bytes.SizeExceedsPaddingSizeError"
+        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: () => toBytes,
-  fromString: () => fromString2,
+  toBytes: () => toBytes2,
+  fromString: () => fromString3,
   fromHex: () => fromHex2,
   fromBytes: () => fromBytes2
 });
@@ -8420,14 +9616,14 @@ function fromBytes2(value, options2 = {}) {
 function fromHex2(value, options2 = {}) {
   return fromBytes2(fromHex(value), options2);
 }
-function fromString2(value, options2 = {}) {
-  return fromBytes2(fromString(value), options2);
+function fromString3(value, options2 = {}) {
+  return fromBytes2(fromString2(value), options2);
 }
-function toBytes(value) {
+function toBytes2(value) {
   const base64 = value.replace(/=+$/, "");
   const size3 = base64.length;
   const decoded = new Uint8Array(size3 + 3);
-  encoder2.encodeInto(base64 + "===", decoded);
+  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;
@@ -8438,16 +9634,16 @@ function toBytes(value) {
   return new Uint8Array(decoded.buffer, 0, decodedSize);
 }
 function toHex2(value) {
-  return fromBytes(toBytes(value));
+  return fromBytes(toBytes2(value));
 }
 function toString2(value) {
-  return toString(toBytes(value));
+  return toString(toBytes2(value));
 }
-var encoder2, decoder2, integerToCharacter, characterToInteger;
+var encoder3, decoder2, integerToCharacter, characterToInteger;
 var init_Base64 = __esm(() => {
   init_Bytes();
   init_Hex();
-  encoder2 = /* @__PURE__ */ new TextEncoder;
+  encoder3 = /* @__PURE__ */ new TextEncoder;
   decoder2 = /* @__PURE__ */ new TextDecoder;
   integerToCharacter = /* @__PURE__ */ Object.fromEntries(Array.from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").map((a, i) => [i, a.charCodeAt(0)]));
   characterToInteger = {
@@ -8458,831 +9654,1810 @@ var init_Base64 = __esm(() => {
   };
 });
 
-// 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;
-}
+// node_modules/mppx/node_modules/ox/_esm/core/Bech32m.js
+var init_Bech32m = () => {};
 
-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/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/@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);
+// 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"
+      });
     }
-    update(buf) {
-      aexists(this);
-      this.iHash.update(buf);
-      return this;
+  };
+  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"
+      });
     }
-    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();
+  };
+  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"
+      });
     }
-    digest() {
-      const out = new Uint8Array(this.oHash.outputLen);
-      this.digestInto(out);
-      return out;
+  };
+  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"
+      });
     }
-    _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;
+  };
+  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"
+      });
     }
-    clone() {
-      return this._cloneInto();
+  };
+  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"
+      });
     }
-    destroy() {
-      this.destroyed = true;
-      this.oHash.destroy();
-      this.iHash.destroy();
+  };
+  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"
+      });
     }
   };
-  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;
-}
-var HashMD, SHA256_IV;
-var init__md = __esm(() => {
-  init_utils2();
-  HashMD = class HashMD extends Hash {
-    constructor(blockLen, outputLen, padOffset, isLE2) {
-      super();
-      this.finished = false;
-      this.length = 0;
-      this.pos = 0;
-      this.destroyed = false;
-      this.blockLen = blockLen;
-      this.outputLen = outputLen;
-      this.padOffset = padOffset;
-      this.isLE = isLE2;
-      this.buffer = new Uint8Array(blockLen);
-      this.view = createView(this.buffer);
+  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"
+      });
     }
-    update(data) {
-      aexists(this);
-      data = toBytes2(data);
-      abytes(data);
-      const { view, buffer, blockLen } = this;
-      const len = data.length;
-      for (let pos = 0;pos < len; ) {
-        const take = Math.min(blockLen - this.pos, len - pos);
-        if (take === blockLen) {
-          const dataView = createView(data);
-          for (;blockLen <= len - pos; pos += blockLen)
-            this.process(dataView, pos);
-          continue;
+  };
+  (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;
         }
-        buffer.set(data.subarray(pos, pos + take), this.pos);
-        this.pos += take;
-        pos += take;
-        if (this.pos === blockLen) {
-          this.process(view, 0);
-          this.pos = 0;
+        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;
       }
-      this.length += data.length;
-      this.roundClean();
-      return this;
-    }
-    digestInto(out) {
-      aexists(this);
-      aoutput(out, this);
-      this.finished = true;
-      const { buffer, view, blockLen, isLE: isLE2 } = this;
-      let { pos } = this;
-      buffer[pos++] = 128;
-      clean(this.buffer.subarray(pos));
-      if (this.padOffset > blockLen - pos) {
-        this.process(view, 0);
-        pos = 0;
+      const length = readLength(cursor, additionalInfo);
+      const result = [];
+      for (let i = 0;i < length; i++) {
+        result.push(decodeCursor2(cursor));
       }
-      for (let i = pos;i < blockLen; i++)
-        buffer[i] = 0;
-      setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
-      this.process(view, 0);
-      const oview = createView(out);
-      const len = this.outputLen;
-      if (len % 4)
-        throw new Error("_sha2: outputLen should be aligned to 32bit");
-      const outLen = len / 4;
-      const state = this.get();
-      if (outLen > state.length)
-        throw new Error("_sha2: outputLen bigger than state");
-      for (let i = 0;i < outLen; i++)
-        oview.setUint32(4 * i, state[i], isLE2);
+      return result;
     }
-    digest() {
-      const { buffer, outputLen } = this;
-      this.digestInto(buffer);
-      const res = buffer.slice(0, outputLen);
-      this.destroy();
-      return res;
+    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;
     }
-    _cloneInto(to) {
-      to || (to = new this.constructor);
-      to.set(...this.get());
-      const { blockLen, buffer, length, finished, destroyed, pos } = this;
-      to.destroyed = destroyed;
-      to.finished = finished;
-      to.length = length;
-      to.pos = pos;
-      if (length % blockLen)
-        to.buffer.set(buffer);
-      return to;
+    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 });
     }
-    clone() {
-      return this._cloneInto();
+    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;
     }
-  };
-  SHA256_IV = /* @__PURE__ */ Uint32Array.from([
-    1779033703,
-    3144134277,
-    1013904242,
-    2773480762,
-    1359893119,
-    2600822924,
-    528734635,
-    1541459225
-  ]);
+  })(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/@noble/hashes/esm/legacy.js
-function ripemd_f(group, x, y, z) {
-  if (group === 0)
-    return x ^ y ^ z;
-  if (group === 1)
-    return x & y | ~x & z;
-  if (group === 2)
-    return (x | ~y) ^ z;
-  if (group === 3)
-    return x & z | y & ~z;
-  return 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();
-  Rho160 = /* @__PURE__ */ Uint8Array.from([
-    7,
-    4,
-    13,
-    1,
-    10,
-    6,
-    15,
-    3,
-    12,
-    0,
-    9,
-    5,
-    2,
-    14,
-    11,
-    8
-  ]);
-  Id160 = /* @__PURE__ */ (() => Uint8Array.from(new Array(16).fill(0).map((_, i) => i)))();
-  Pi160 = /* @__PURE__ */ (() => Id160.map((i) => (9 * i + 5) % 16))();
-  idxLR = /* @__PURE__ */ (() => {
-    const L = [Id160];
-    const R = [Pi160];
-    const res = [L, R];
-    for (let i = 0;i < 4; i++)
-      for (let j of res)
-        j.push(j[i].map((k) => Rho160[k]));
-    return res;
-  })();
-  idxL = /* @__PURE__ */ (() => idxLR[0])();
-  idxR = /* @__PURE__ */ (() => idxLR[1])();
-  shifts160 = /* @__PURE__ */ [
-    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
-    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
-    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
-    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
-    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
-  ].map((i) => Uint8Array.from(i));
-  shiftsL160 = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts160[i][j]));
-  shiftsR160 = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts160[i][j]));
-  Kl160 = /* @__PURE__ */ Uint32Array.from([
-    0,
-    1518500249,
-    1859775393,
-    2400959708,
-    2840853838
-  ]);
-  Kr160 = /* @__PURE__ */ Uint32Array.from([
-    1352829926,
-    1548603684,
-    1836072691,
-    2053994217,
-    0
-  ]);
-  BUF_160 = /* @__PURE__ */ new Uint32Array(16);
-  RIPEMD160 = class RIPEMD160 extends HashMD {
-    constructor() {
-      super(64, 20, 8, true);
-      this.h0 = 1732584193 | 0;
-      this.h1 = 4023233417 | 0;
-      this.h2 = 2562383102 | 0;
-      this.h3 = 271733878 | 0;
-      this.h4 = 3285377520 | 0;
+// 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");
     }
-    get() {
-      const { h0, h1, h2, h3, h4 } = this;
-      return [h0, h1, h2, h3, h4];
+    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);
     }
-    set(h0, h1, h2, h3, h4) {
-      this.h0 = h0 | 0;
-      this.h1 = h1 | 0;
-      this.h2 = h2 | 0;
-      this.h3 = h3 | 0;
-      this.h4 = h4 | 0;
+    if (Object.getOwnPropertySymbols) {
+      return names.concat(Object.getOwnPropertySymbols(events));
     }
-    process(view, offset) {
-      for (let i = 0;i < 16; i++, offset += 4)
-        BUF_160[i] = view.getUint32(offset, true);
-      let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
-      for (let group = 0;group < 5; group++) {
-        const rGroup = 4 - group;
-        const hbl = Kl160[group], hbr = Kr160[group];
-        const rl = idxL[group], rr = idxR[group];
-        const sl = shiftsL160[group], sr = shiftsR160[group];
-        for (let i = 0;i < 16; i++) {
-          const tl = rotl(al + ripemd_f(group, bl, cl, dl) + BUF_160[rl[i]] + hbl, sl[i]) + el | 0;
-          al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
-        }
-        for (let i = 0;i < 16; i++) {
-          const tr = rotl(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i]] + hbr, sr[i]) + er | 0;
-          ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
+    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);
         }
       }
-      this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
     }
-    roundClean() {
-      clean(BUF_160);
+    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;
     }
-    destroy() {
-      this.destroyed = true;
-      clean(this.buffer);
-      this.set(0, 0, 0, 0, 0);
+    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;
   };
-  ripemd160 = /* @__PURE__ */ createHasher(() => new RIPEMD160);
-});
-
-// node_modules/@noble/hashes/esm/ripemd160.js
-var ripemd1602;
-var init_ripemd160 = __esm(() => {
-  init_legacy();
-  ripemd1602 = ripemd160;
+  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/@noble/hashes/esm/_u64.js
-function fromBig(n, le = false) {
-  if (le)
-    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
-  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
-}
-function split(lst, le = false) {
-  const len = lst.length;
-  let Ah = new Uint32Array(len);
-  let Al = new Uint32Array(len);
-  for (let i = 0;i < len; i++) {
-    const { h, l } = fromBig(lst[i], le);
-    [Ah[i], Al[i]] = [h, l];
-  }
-  return [Ah, Al];
-}
-var U32_MASK64, _32n, rotlSH = (h, l, s) => h << s | l >>> 32 - s, rotlSL = (h, l, s) => l << s | h >>> 32 - s, rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s, rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
-var init__u64 = __esm(() => {
-  U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
-  _32n = /* @__PURE__ */ BigInt(32);
+// node_modules/eventemitter3/index.mjs
+var import__2;
+var init_eventemitter3 = __esm(() => {
+  import__2 = __toESM(require_eventemitter3(), 1);
 });
 
-// node_modules/@noble/hashes/esm/sha3.js
-function keccakP(s, rounds = 24) {
-  const B = new Uint32Array(5 * 2);
-  for (let round = 24 - rounds;round < 24; round++) {
-    for (let x = 0;x < 10; x++)
-      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
-    for (let x = 0;x < 10; x += 2) {
-      const idx1 = (x + 8) % 10;
-      const idx0 = (x + 2) % 10;
-      const B0 = B[idx0];
-      const B1 = B[idx0 + 1];
-      const Th = rotlH(B0, B1, 1) ^ B[idx1];
-      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
-      for (let y = 0;y < 50; y += 10) {
-        s[x + y] ^= Th;
-        s[x + y + 1] ^= Tl;
-      }
+// 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"
+      });
     }
-    let curH = s[2];
-    let curL = s[3];
-    for (let t = 0;t < 24; t++) {
-      const shift = SHA3_ROTL[t];
-      const Th = rotlH(curH, curL, shift);
-      const Tl = rotlL(curH, curL, shift);
-      const PI = SHA3_PI[t];
-      curH = s[PI];
-      curL = s[PI + 1];
-      s[PI] = Th;
-      s[PI + 1] = Tl;
+  };
+  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"
+      });
     }
-    for (let y = 0;y < 50; y += 10) {
-      for (let x = 0;x < 10; x++)
-        B[x] = s[y + x];
-      for (let x = 0;x < 10; x++)
-        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+  };
+  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"
+      });
     }
-    s[0] ^= SHA3_IOTA_H[round];
-    s[1] ^= SHA3_IOTA_L[round];
-  }
-  clean(B);
-}
-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();
-  _0n = BigInt(0);
-  _1n = BigInt(1);
-  _2n = BigInt(2);
-  _7n = BigInt(7);
-  _256n = BigInt(256);
-  _0x71n = BigInt(113);
-  SHA3_PI = [];
-  SHA3_ROTL = [];
-  _SHA3_IOTA = [];
-  for (let round = 0, R = _1n, x = 1, y = 0;round < 24; round++) {
-    [x, y] = [y, (2 * x + 3 * y) % 5];
-    SHA3_PI.push(2 * (5 * y + x));
-    SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
-    let t = _0n;
-    for (let j = 0;j < 7; j++) {
-      R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
-      if (R & _2n)
-        t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+  };
+  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"
+      });
     }
-    _SHA3_IOTA.push(t);
-  }
-  IOTAS = split(_SHA3_IOTA, true);
-  SHA3_IOTA_H = IOTAS[0];
-  SHA3_IOTA_L = IOTAS[1];
-  Keccak = class Keccak extends Hash {
-    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
-      super();
-      this.pos = 0;
-      this.posOut = 0;
-      this.finished = false;
-      this.destroyed = false;
-      this.enableXOF = false;
-      this.blockLen = blockLen;
-      this.suffix = suffix;
-      this.outputLen = outputLen;
-      this.enableXOF = enableXOF;
-      this.rounds = rounds;
-      anumber(outputLen);
-      if (!(0 < blockLen && blockLen < 200))
-        throw new Error("only keccak-f1600 function is supported");
-      this.state = new Uint8Array(200);
-      this.state32 = u32(this.state);
+  };
+  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"
+      });
     }
-    clone() {
-      return this._cloneInto();
+  };
+  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"
+      });
     }
-    keccak() {
-      swap32IfBE(this.state32);
-      keccakP(this.state32, this.rounds);
-      swap32IfBE(this.state32);
-      this.posOut = 0;
-      this.pos = 0;
+  };
+  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"
+      });
     }
-    update(data) {
-      aexists(this);
-      data = toBytes2(data);
-      abytes(data);
-      const { blockLen, state } = this;
-      const len = data.length;
-      for (let pos = 0;pos < len; ) {
-        const take = Math.min(blockLen - this.pos, len - pos);
-        for (let i = 0;i < take; i++)
-          state[this.pos++] ^= data[pos++];
-        if (this.pos === blockLen)
-          this.keccak();
-      }
-      return this;
+  };
+  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"
+      });
     }
-    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();
+  };
+  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"
+      });
+    }
+  };
+  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;
     }
-    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;
+  };
+  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"
+      });
     }
-    xofInto(out) {
-      if (!this.enableXOF)
-        throw new Error("XOF is not possible for this instance");
-      return this.writeInto(out);
+  };
+  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"
+      });
     }
-    xof(bytes) {
-      anumber(bytes);
-      return this.xofInto(new Uint8Array(bytes));
+  };
+  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"
+      });
     }
-    digestInto(out) {
-      aoutput(out, this);
-      if (this.finished)
-        throw new Error("digest() was already called");
-      this.writeInto(out);
-      this.destroy();
-      return out;
+  };
+  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"
+      });
     }
-    digest() {
-      return this.digestInto(new Uint8Array(this.outputLen));
+  };
+  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"
+      });
     }
-    destroy() {
-      this.destroyed = true;
-      clean(this.state);
+  };
+  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"
+      });
     }
-    _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(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"
+      });
     }
   };
-  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(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"
+      });
     }
-    get() {
-      const { A, B, C, D: D2, E, F, G, H } = this;
-      return [A, B, C, D2, E, F, G, H];
+  };
+  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"
+      });
     }
-    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(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"
+      });
     }
-    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(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"
+      });
     }
-    roundClean() {
-      clean(SHA256_W);
+  };
+  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"
+      });
     }
-    destroy() {
-      this.set(0, 0, 0, 0, 0, 0, 0, 0);
-      clean(this.buffer);
+  };
+  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"
+      });
     }
   };
-  sha256 = /* @__PURE__ */ createHasher(() => new SHA256);
+  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
@@ -28443,6 +30649,15 @@ function registerTwinCommand(program2) {
 // src/commands/drive.ts
 import { writeFile as writeFile2 } from "node:fs/promises";
 import { basename as basename2, resolve as resolvePath } from "node:path";
+function shareBase(auth) {
+  return (auth.platformUrl ?? "https://platform.heyamiko.com").replace(/\/$/, "");
+}
+function fileShareUrl(auth, slug) {
+  return `${shareBase(auth)}/d/${slug}`;
+}
+function folderShareUrl(auth, slug) {
+  return `${shareBase(auth)}/d/f/${slug}`;
+}
 function fmtBytes(n) {
   if (!n || n <= 0)
     return "-";
@@ -28486,6 +30701,7 @@ function renderDocTable(docs) {
       dim("TYPE"),
       dim("FOLDER"),
       dim("STATUS"),
+      dim("PUBLIC"),
       dim("CREATED")
     ],
     ...docs.map((doc2) => [
@@ -28494,6 +30710,7 @@ function renderDocTable(docs) {
       doc2.file_type || "-",
       doc2.folder_id || dim("root"),
       statusOf3(doc2),
+      doc2.is_public ? "yes" : dim("-"),
       doc2.created_at?.slice(0, 10) || "-"
     ])
   ];
@@ -28685,6 +30902,12 @@ Search hits filename, title, description, and parsed RAG content (once processed
         console.log(label("Status", statusOf3(d.doc)));
         if (d.doc.metadata?.error)
           console.log(label("Error", d.doc.metadata.error));
+        if (d.doc.is_public && d.doc.public_slug) {
+          console.log(label("Public", "yes"));
+          console.log(label("Share URL", fileShareUrl(auth, d.doc.public_slug)));
+        } else {
+          console.log(label("Public", "no"));
+        }
         console.log(label("Signed URL", d.signed_url));
         if (opts.content && d.doc.content) {
           console.log(heading(`
@@ -28746,6 +30969,40 @@ Parsed content available (${d.doc.content.length} chars). Pass --content to prin
       process.exit(1);
     }
   });
+  program2.command("share <docId>").description("Make a file public and print its share link").option("--twin <idOrName>", "Target twin id or name").option("--yes", "Skip confirmation").option("--json", "Output as JSON").action(async (docId, opts) => {
+    const { twinId, auth } = twinFromFlag(opts);
+    await confirmDestructive({
+      action: `Make file ${docId} PUBLIC`,
+      detail: "Anyone with the link can view and download it — no Amiko login required. The link stays stable across unshare/re-share.",
+      yes: opts.yes,
+      commandExample: `amiko drive share ${docId}`
+    });
+    try {
+      const result = await amikoWebFetch(auth, `/api/agents/${twinId}/docs/${docId}`, { method: "PATCH", body: { isPublic: true } });
+      renderOutput(result, (r) => {
+        console.log(success(`${r.doc.title || r.doc.filename} is now public`));
+        if (r.doc.public_slug)
+          console.log(label("Share URL", fileShareUrl(auth, r.doc.public_slug)));
+        console.log(dim("Revoke anytime: amiko drive unshare " + docId));
+      }, { json: opts.json });
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : String(e5)));
+      process.exit(1);
+    }
+  });
+  program2.command("unshare <docId>").description("Revoke a file's public share link").option("--twin <idOrName>", "Target twin id or name").option("--json", "Output as JSON").action(async (docId, opts) => {
+    const { twinId, auth } = twinFromFlag(opts);
+    try {
+      const result = await amikoWebFetch(auth, `/api/agents/${twinId}/docs/${docId}`, { method: "PATCH", body: { isPublic: false } });
+      renderOutput(result, (r) => {
+        console.log(success(`${r.doc.title || r.doc.filename} is private again`));
+        console.log(dim("The link no longer works. Re-sharing later restores the SAME link. Note: the file stays reachable if a parent folder is still shared."));
+      }, { json: opts.json });
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : String(e5)));
+      process.exit(1);
+    }
+  });
   program2.command("presign <name>").description("Get a presigned upload URL (browser-direct uploads; no upload performed)").option("--twin <idOrName>", "Target twin id or name").option("--json", "Output as JSON").action(async (name, opts) => {
     const { twinId, auth } = twinFromFlag(opts);
     try {
@@ -28787,11 +31044,12 @@ Parsed content available (${d.doc.content.length} chars). Pass --content to prin
         }
         console.log(heading(`Folders (${d.folders.length})`));
         const rows = [
-          [dim("ID"), dim("NAME"), dim("PARENT"), dim("CREATED")],
+          [dim("ID"), dim("NAME"), dim("PARENT"), dim("PUBLIC"), dim("CREATED")],
           ...d.folders.map((f) => [
             f.id,
             f.name,
             f.parent_id || dim("root"),
+            f.is_public ? "yes" : dim("-"),
             f.created_at?.slice(0, 10) || "-"
           ])
         ];
@@ -28840,6 +31098,40 @@ Parsed content available (${d.doc.content.length} chars). Pass --content to prin
       process.exit(1);
     }
   });
+  folder.command("share <folderId>").description("Make a folder public (shares its ENTIRE subtree) and print the link").option("--twin <idOrName>", "Target twin id or name").option("--yes", "Skip confirmation").option("--json", "Output as JSON").action(async (folderId, opts) => {
+    const { twinId, auth } = twinFromFlag(opts);
+    await confirmDestructive({
+      action: `Make folder ${folderId} PUBLIC`,
+      detail: "Anyone with the link can browse and download EVERY file and subfolder inside it — no Amiko login required. Files added later are exposed too.",
+      yes: opts.yes,
+      commandExample: `amiko drive folder share ${folderId}`
+    });
+    try {
+      const result = await amikoWebFetch(auth, `/api/agents/${twinId}/docs/folders/${folderId}`, { method: "PATCH", body: { isPublic: true } });
+      renderOutput(result, (r) => {
+        console.log(success(`Folder "${r.folder.name}" is now public`));
+        if (r.folder.public_slug)
+          console.log(label("Share URL", folderShareUrl(auth, r.folder.public_slug)));
+        console.log(dim("Revoke anytime: amiko drive folder unshare " + folderId));
+      }, { json: opts.json });
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : String(e5)));
+      process.exit(1);
+    }
+  });
+  folder.command("unshare <folderId>").description("Revoke a folder's public share link (instantly unshares the subtree)").option("--twin <idOrName>", "Target twin id or name").option("--json", "Output as JSON").action(async (folderId, opts) => {
+    const { twinId, auth } = twinFromFlag(opts);
+    try {
+      const result = await amikoWebFetch(auth, `/api/agents/${twinId}/docs/folders/${folderId}`, { method: "PATCH", body: { isPublic: false } });
+      renderOutput(result, (r) => {
+        console.log(success(`Folder "${r.folder.name}" is private again`));
+        console.log(dim("The link no longer works and the whole subtree is unshared (unless an ancestor folder or individual file is still public). Re-sharing restores the SAME link."));
+      }, { json: opts.json });
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : String(e5)));
+      process.exit(1);
+    }
+  });
   folder.command("delete <folderId>").description("Delete a folder (use --force to delete non-empty folders + their contents)").option("--twin <idOrName>", "Target twin id or name").option("--force", "Recursively delete subfolders and files in the subtree").option("--yes", "Skip confirmation").option("--json", "Output as JSON").action(async (folderId, opts) => {
     const { twinId, auth } = twinFromFlag(opts);
     await confirmDestructive({