@heyamiko/amiko-cli 0.14.0-beta.14 → 0.14.0-beta.16

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);
@@ -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,401 +7788,1199 @@ var init_Errors = __esm(() => {
   })();
 });
 
-// node_modules/mppx/node_modules/ox/_esm/core/internal/bytes.js
-function assertSize(bytes, size_) {
-  if (size(bytes) > size_)
-    throw new SizeOverflowError({
-      givenSize: size(bytes),
-      maxSize: size_
-    });
+// node_modules/@noble/hashes/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
 }
-function assertStartOffset(value, start) {
-  if (typeof start === "number" && start > 0 && start > size(value) - 1)
-    throw new SliceOffsetOutOfBoundsError({
-      offset: start,
-      position: "start",
-      size: size(value)
-    });
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
 }
-function assertEndOffset(value, start, end) {
-  if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
-    throw new SliceOffsetOutOfBoundsError({
-      offset: end,
-      position: "end",
-      size: size(value)
-    });
-  }
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
 }
-function charCodeToBase16(char) {
-  if (char >= charCodeMap.zero && char <= charCodeMap.nine)
-    return char - charCodeMap.zero;
-  if (char >= charCodeMap.A && char <= charCodeMap.F)
-    return char - (charCodeMap.A - 10);
-  if (char >= charCodeMap.a && char <= charCodeMap.f)
-    return char - (charCodeMap.a - 10);
-  return;
+function ahash(h) {
+  if (typeof h !== "function" || typeof h.create !== "function")
+    throw new Error("Hash should be wrapped by utils.createHasher");
+  anumber(h.outputLen);
+  anumber(h.blockLen);
 }
-function pad2(bytes, options2 = {}) {
-  const { dir, size: size2 = 32 } = options2;
-  if (size2 === 0)
-    return bytes;
-  if (bytes.length > size2)
-    throw new SizeExceedsPaddingSizeError({
-      size: bytes.length,
-      targetSize: size2,
-      type: "Bytes"
-    });
-  const paddedBytes = new Uint8Array(size2);
-  for (let i = 0;i < size2; i++) {
-    const padEnd = dir === "right";
-    paddedBytes[padEnd ? i : size2 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
-  }
-  return paddedBytes;
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
 }
-function trim(value, options2 = {}) {
-  const { dir = "left" } = options2;
-  let data = value;
-  let sliceLength = 0;
-  for (let i = 0;i < data.length - 1; i++) {
-    if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
-      sliceLength++;
-    else
-      break;
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
   }
-  data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
-  return data;
-}
-var charCodeMap;
-var init_bytes = __esm(() => {
-  init_Bytes();
-  charCodeMap = {
-    zero: 48,
-    nine: 57,
-    A: 65,
-    F: 70,
-    a: 97,
-    f: 102
-  };
-});
-
-// node_modules/mppx/node_modules/ox/_esm/core/internal/hex.js
-function assertSize2(hex, size_) {
-  if (size2(hex) > size_)
-    throw new SizeOverflowError2({
-      givenSize: size2(hex),
-      maxSize: size_
-    });
 }
-function pad3(hex_, options2 = {}) {
-  const { dir, size: size3 = 32 } = options2;
-  if (size3 === 0)
-    return hex_;
-  const hex = hex_.replace("0x", "");
-  if (hex.length > size3 * 2)
-    throw new SizeExceedsPaddingSizeError2({
-      size: Math.ceil(hex.length / 2),
-      targetSize: size3,
-      type: "Hex"
-    });
-  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
 }
-var init_hex = __esm(() => {
-  init_Hex();
-});
-
-// node_modules/mppx/node_modules/ox/_esm/core/Json.js
-var exports_Json = {};
-__export(exports_Json, {
-  stringify: () => stringify2,
-  parse: () => parse,
-  canonicalize: () => canonicalize
-});
-function canonicalize(value) {
-  if (value === null || typeof value === "boolean" || typeof value === "string")
-    return JSON.stringify(value);
-  if (typeof value === "number") {
-    if (!Number.isFinite(value))
-      throw new TypeError("Cannot canonicalize non-finite number");
-    return Object.is(value, -0) ? "0" : JSON.stringify(value);
-  }
-  if (typeof value === "bigint")
-    throw new TypeError("Cannot canonicalize bigint");
-  if (Array.isArray(value))
-    return `[${value.map((item) => canonicalize(item)).join(",")}]`;
-  if (typeof value === "object") {
-    const entries = Object.keys(value).sort().reduce((acc, key) => {
-      const v = value[key];
-      if (v !== undefined)
-        acc.push(`${JSON.stringify(key)}:${canonicalize(v)}`);
-      return acc;
-    }, []);
-    return `{${entries.join(",")}}`;
+function clean(...arrays) {
+  for (let i = 0;i < arrays.length; i++) {
+    arrays[i].fill(0);
   }
-  return;
 }
-function parse(string, reviver) {
-  return JSON.parse(string, (key, value_) => {
-    const value = value_;
-    if (typeof value === "string" && value.endsWith(bigIntSuffix))
-      return BigInt(value.slice(0, -bigIntSuffix.length));
-    return typeof reviver === "function" ? reviver(key, value) : value;
-  });
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
-function stringify2(value, replacer, space) {
-  return JSON.stringify(value, (key, value2) => {
-    if (typeof replacer === "function")
-      return replacer(key, value2);
-    if (typeof value2 === "bigint")
-      return value2.toString() + bigIntSuffix;
-    return value2;
-  }, space);
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
 }
-var bigIntSuffix = "#__bigint";
-
-// node_modules/mppx/node_modules/ox/_esm/core/Hex.js
-function assert(value, options2 = {}) {
-  const { strict = false } = options2;
-  if (!value)
-    throw new InvalidHexTypeError(value);
-  if (typeof value !== "string")
-    throw new InvalidHexTypeError(value);
-  if (strict) {
-    if (!/^0x[0-9a-fA-F]*$/.test(value))
-      throw new InvalidHexValueError(value);
-  }
-  if (!value.startsWith("0x"))
-    throw new InvalidHexValueError(value);
+function rotl(word, shift) {
+  return word << shift | word >>> 32 - shift >>> 0;
 }
-function fromBytes(value, options2 = {}) {
-  let string = "";
-  for (let i = 0;i < value.length; i++)
-    string += hexes[value[i]];
-  const hex = `0x${string}`;
-  if (typeof options2.size === "number") {
-    assertSize2(hex, options2.size);
-    return padRight(hex, options2.size);
-  }
-  return hex;
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
 }
-function fromNumber(value, options2 = {}) {
-  const { signed, size: size3 } = options2;
-  const value_ = BigInt(value);
-  let maxValue;
-  if (size3) {
-    if (signed)
-      maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
-    else
-      maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
-  } else if (typeof value === "number") {
-    maxValue = BigInt(Number.MAX_SAFE_INTEGER);
-  }
-  const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
-  if (maxValue && value_ > maxValue || value_ < minValue) {
-    const suffix = typeof value === "bigint" ? "n" : "";
-    throw new IntegerOutOfRangeError({
-      max: maxValue ? `${maxValue}${suffix}` : undefined,
-      min: `${minValue}${suffix}`,
-      signed,
-      size: size3,
-      value: `${value}${suffix}`
-    });
+function byteSwap32(arr) {
+  for (let i = 0;i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
   }
-  const stringValue = (signed && value_ < 0 ? BigInt.asUintN(size3 * 8, BigInt(value_)) : value_).toString(16);
-  const hex = `0x${stringValue}`;
-  if (size3)
-    return padLeft(hex, size3);
-  return hex;
+  return arr;
 }
-function padLeft(value, size3) {
-  return pad3(value, { dir: "left", size: size3 });
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
 }
-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 toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
 }
-function toNumber(hex, options2 = {}) {
-  const { signed, size: size3 } = options2;
-  if (!signed && !size3)
-    return Number(hex);
-  return Number(toBigInt(hex, options2));
+
+class Hash {
 }
-function validate2(value, options2 = {}) {
-  const { strict = false } = options2;
-  try {
-    assert(value, { strict });
-    return true;
-  } catch {
-    return false;
-  }
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
 }
-var hexes, IntegerOutOfRangeError, InvalidHexTypeError, InvalidHexValueError, SizeOverflowError2, SizeExceedsPaddingSizeError2;
-var init_Hex = __esm(() => {
-  init_Errors();
-  init_hex();
-  hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
-  IntegerOutOfRangeError = class IntegerOutOfRangeError extends BaseError {
-    constructor({ max, min, signed, size: size3, value }) {
-      super(`Number \`${value}\` is not in safe${size3 ? ` ${size3 * 8}-bit` : ""}${signed ? " signed" : " unsigned"} integer range ${max ? `(\`${min}\` to \`${max}\`)` : `(above \`${min}\`)`}`);
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Hex.IntegerOutOfRangeError"
-      });
+var isLE, swap32IfBE;
+var init_utils = __esm(() => {
+  /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+  isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+  swap32IfBE = isLE ? (u) => u : byteSwap32;
+});
+
+// node_modules/@noble/hashes/esm/hmac.js
+var HMAC, hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+var init_hmac = __esm(() => {
+  init_utils();
+  HMAC = class HMAC extends Hash {
+    constructor(hash, _key) {
+      super();
+      this.finished = false;
+      this.destroyed = false;
+      ahash(hash);
+      const key = toBytes(_key);
+      this.iHash = hash.create();
+      if (typeof this.iHash.update !== "function")
+        throw new Error("Expected instance of class which extends utils.Hash");
+      this.blockLen = this.iHash.blockLen;
+      this.outputLen = this.iHash.outputLen;
+      const blockLen = this.blockLen;
+      const pad2 = new Uint8Array(blockLen);
+      pad2.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+      for (let i = 0;i < pad2.length; i++)
+        pad2[i] ^= 54;
+      this.iHash.update(pad2);
+      this.oHash = hash.create();
+      for (let i = 0;i < pad2.length; i++)
+        pad2[i] ^= 54 ^ 92;
+      this.oHash.update(pad2);
+      clean(pad2);
     }
-  };
-  InvalidHexTypeError = class InvalidHexTypeError extends BaseError {
-    constructor(value) {
-      super(`Value \`${typeof value === "object" ? stringify2(value) : value}\` of type \`${typeof value}\` is an invalid hex type.`, {
-        metaMessages: ['Hex types must be represented as `"0x${string}"`.']
-      });
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Hex.InvalidHexTypeError"
-      });
+    update(buf) {
+      aexists(this);
+      this.iHash.update(buf);
+      return this;
     }
-  };
-  InvalidHexValueError = class InvalidHexValueError extends BaseError {
-    constructor(value) {
-      super(`Value \`${value}\` is an invalid hex value.`, {
-        metaMessages: [
-          'Hex values must start with `"0x"` and contain only hexadecimal characters (0-9, a-f, A-F).'
-        ]
-      });
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Hex.InvalidHexValueError"
-      });
+    digestInto(out) {
+      aexists(this);
+      abytes(out, this.outputLen);
+      this.finished = true;
+      this.iHash.digestInto(out);
+      this.oHash.update(out);
+      this.oHash.digestInto(out);
+      this.destroy();
     }
-  };
-  SizeOverflowError2 = class SizeOverflowError2 extends BaseError {
-    constructor({ givenSize, maxSize }) {
-      super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Hex.SizeOverflowError"
-      });
+    digest() {
+      const out = new Uint8Array(this.oHash.outputLen);
+      this.digestInto(out);
+      return out;
     }
-  };
-  SizeExceedsPaddingSizeError2 = class SizeExceedsPaddingSizeError2 extends BaseError {
-    constructor({ size: size3, targetSize, type }) {
-      super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size3}\`) exceeds padding size (\`${targetSize}\`).`);
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "Hex.SizeExceedsPaddingSizeError"
-      });
+    _cloneInto(to) {
+      to || (to = Object.create(Object.getPrototypeOf(this), {}));
+      const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+      to = to;
+      to.finished = finished;
+      to.destroyed = destroyed;
+      to.blockLen = blockLen;
+      to.outputLen = outputLen;
+      to.oHash = oHash._cloneInto(to.oHash);
+      to.iHash = iHash._cloneInto(to.iHash);
+      return to;
+    }
+    clone() {
+      return this._cloneInto();
+    }
+    destroy() {
+      this.destroyed = true;
+      this.oHash.destroy();
+      this.iHash.destroy();
     }
   };
+  hmac.create = (hash, key) => new HMAC(hash, key);
 });
 
-// node_modules/mppx/node_modules/ox/_esm/core/Bytes.js
-var exports_Bytes = {};
-__export(exports_Bytes, {
-  validate: () => validate3,
-  trimRight: () => trimRight,
-  trimLeft: () => trimLeft,
-  toString: () => toString,
-  toNumber: () => toNumber2,
-  toHex: () => toHex,
-  toBoolean: () => toBoolean,
-  toBigInt: () => toBigInt2,
-  slice: () => slice,
-  size: () => size,
-  random: () => random,
-  padRight: () => padRight2,
-  padLeft: () => padLeft2,
-  isEqual: () => isEqual,
-  fromString: () => fromString,
-  fromNumber: () => fromNumber2,
-  fromHex: () => fromHex,
-  fromBoolean: () => fromBoolean,
-  fromArray: () => fromArray,
-  from: () => from,
-  concat: () => concat,
-  assert: () => assert2,
-  SliceOffsetOutOfBoundsError: () => SliceOffsetOutOfBoundsError,
-  SizeOverflowError: () => SizeOverflowError,
-  SizeExceedsPaddingSizeError: () => SizeExceedsPaddingSizeError,
-  InvalidBytesTypeError: () => InvalidBytesTypeError,
-  InvalidBytesBooleanError: () => InvalidBytesBooleanError
-});
-function assert2(value) {
-  if (value instanceof Uint8Array)
-    return;
-  if (!value)
-    throw new InvalidBytesTypeError(value);
-  if (typeof value !== "object")
-    throw new InvalidBytesTypeError(value);
-  if (!("BYTES_PER_ELEMENT" in value))
-    throw new InvalidBytesTypeError(value);
-  if (value.BYTES_PER_ELEMENT !== 1 || value.constructor.name !== "Uint8Array")
-    throw new InvalidBytesTypeError(value);
-}
-function concat(...values) {
-  let length = 0;
-  for (const arr of values) {
-    length += arr.length;
-  }
-  const result = new Uint8Array(length);
-  for (let i = 0, index = 0;i < values.length; i++) {
-    const arr = values[i];
-    result.set(arr, index);
-    index += arr.length;
-  }
-  return result;
-}
-function from(value) {
-  if (value instanceof Uint8Array)
-    return value;
-  if (typeof value === "string")
-    return fromHex(value);
-  return fromArray(value);
+// node_modules/@noble/hashes/esm/_md.js
+function setBigUint64(view, byteOffset, value, isLE2) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE2);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE2 ? 4 : 0;
+  const l = isLE2 ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE2);
+  view.setUint32(byteOffset + l, wl, isLE2);
 }
-function fromArray(value) {
-  return value instanceof Uint8Array ? value : new Uint8Array(value);
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
 }
-function fromBoolean(value, options2 = {}) {
-  const { size: size3 } = options2;
-  const bytes = new Uint8Array(1);
-  bytes[0] = Number(value);
-  if (typeof size3 === "number") {
-    assertSize(bytes, size3);
-    return padLeft2(bytes, size3);
-  }
-  return bytes;
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
 }
-function fromHex(value, options2 = {}) {
-  const { size: size3 } = options2;
-  let hex = value;
-  if (size3) {
-    assertSize2(value, size3);
-    hex = padRight(value, size3);
-  }
-  let hexString = hex.slice(2);
+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;
+  let hex = value;
+  if (size3) {
+    assertSize2(value, size3);
+    hex = padRight(value, size3);
+  }
+  let hexString = hex.slice(2);
   if (hexString.length % 2)
     hexString = `0${hexString}`;
   const length = hexString.length / 2;
@@ -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.`, {
@@ -8334,65 +9102,493 @@ var init_Bytes = __esm(() => {
         enumerable: true,
         configurable: true,
         writable: true,
-        value: "Bytes.InvalidBytesBooleanError"
+        value: "Bytes.InvalidBytesBooleanError"
+      });
+    }
+  };
+  InvalidBytesTypeError = class InvalidBytesTypeError extends BaseError {
+    constructor(value) {
+      super(`Value \`${typeof value === "object" ? stringify2(value) : value}\` of type \`${typeof value}\` is an invalid Bytes value.`, {
+        metaMessages: ["Bytes values must be of type `Bytes`."]
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Bytes.InvalidBytesTypeError"
+      });
+    }
+  };
+  SizeOverflowError = class SizeOverflowError extends BaseError {
+    constructor({ givenSize, maxSize }) {
+      super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Bytes.SizeOverflowError"
+      });
+    }
+  };
+  SliceOffsetOutOfBoundsError = class SliceOffsetOutOfBoundsError extends BaseError {
+    constructor({ offset, position, size: size3 }) {
+      super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size3}\`).`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Bytes.SliceOffsetOutOfBoundsError"
+      });
+    }
+  };
+  SizeExceedsPaddingSizeError = class SizeExceedsPaddingSizeError extends BaseError {
+    constructor({ size: size3, targetSize, type }) {
+      super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size3}\`) exceeds padding size (\`${targetSize}\`).`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Bytes.SizeExceedsPaddingSizeError"
+      });
+    }
+  };
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/Hash.js
+var exports_Hash = {};
+__export(exports_Hash, {
+  validate: () => validate4,
+  sha256: () => sha2563,
+  ripemd160: () => ripemd1603,
+  keccak256: () => keccak256,
+  hmac256: () => hmac256
+});
+function keccak256(value, options2 = {}) {
+  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
+  const bytes = keccak_256(from(value));
+  if (as === "Bytes")
+    return bytes;
+  return fromBytes(bytes);
+}
+function hmac256(key, value, options2 = {}) {
+  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
+  const bytes = hmac(sha2562, from(key), from(value));
+  if (as === "Bytes")
+    return bytes;
+  return fromBytes(bytes);
+}
+function ripemd1603(value, options2 = {}) {
+  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
+  const bytes = ripemd1602(from(value));
+  if (as === "Bytes")
+    return bytes;
+  return fromBytes(bytes);
+}
+function sha2563(value, options2 = {}) {
+  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
+  const bytes = sha2562(from(value));
+  if (as === "Bytes")
+    return bytes;
+  return fromBytes(bytes);
+}
+function validate4(value) {
+  return validate2(value) && size2(value) === 32;
+}
+var init_Hash = __esm(() => {
+  init_hmac();
+  init_ripemd160();
+  init_sha3();
+  init_sha256();
+  init_Bytes();
+  init_Hex();
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/internal/lru.js
+var LruMap;
+var init_lru = __esm(() => {
+  LruMap = class LruMap extends Map {
+    constructor(size3) {
+      super();
+      Object.defineProperty(this, "maxSize", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      this.maxSize = size3;
+    }
+    get(key) {
+      const value = super.get(key);
+      if (super.has(key) && value !== undefined) {
+        this.delete(key);
+        super.set(key, value);
+      }
+      return value;
+    }
+    set(key, value) {
+      super.set(key, value);
+      if (this.maxSize && this.size > this.maxSize) {
+        const firstKey = this.keys().next().value;
+        if (firstKey)
+          this.delete(firstKey);
+      }
+      return this;
+    }
+  };
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/Caches.js
+var caches, checksum;
+var init_Caches = __esm(() => {
+  init_lru();
+  caches = {
+    checksum: /* @__PURE__ */ new LruMap(8192)
+  };
+  checksum = caches.checksum;
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/PublicKey.js
+var init_PublicKey = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Address.js
+function assert3(value, options2 = {}) {
+  const { strict = true } = options2;
+  if (!addressRegex.test(value))
+    throw new InvalidAddressError({
+      address: value,
+      cause: new InvalidInputError
+    });
+  if (strict) {
+    if (value.toLowerCase() === value)
+      return;
+    if (checksum2(value) !== value)
+      throw new InvalidAddressError({
+        address: value,
+        cause: new InvalidChecksumError
+      });
+  }
+}
+function checksum2(address2) {
+  if (checksum.has(address2))
+    return checksum.get(address2);
+  assert3(address2, { strict: false });
+  const hexAddress = address2.substring(2).toLowerCase();
+  const hash = keccak256(fromString2(hexAddress), { as: "Bytes" });
+  const characters = hexAddress.split("");
+  for (let i = 0;i < 40; i += 2) {
+    if (hash[i >> 1] >> 4 >= 8 && characters[i]) {
+      characters[i] = characters[i].toUpperCase();
+    }
+    if ((hash[i >> 1] & 15) >= 8 && characters[i + 1]) {
+      characters[i + 1] = characters[i + 1].toUpperCase();
+    }
+  }
+  const result = `0x${characters.join("")}`;
+  checksum.set(address2, result);
+  return result;
+}
+var addressRegex, InvalidAddressError, InvalidInputError, InvalidChecksumError;
+var init_Address = __esm(() => {
+  init_Bytes();
+  init_Caches();
+  init_Errors();
+  init_Hash();
+  addressRegex = /^0x[a-fA-F0-9]{40}$/;
+  InvalidAddressError = class InvalidAddressError extends BaseError {
+    constructor({ address: address2, cause }) {
+      super(`Address "${address2}" is invalid.`, {
+        cause
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Address.InvalidAddressError"
       });
     }
   };
-  InvalidBytesTypeError = class InvalidBytesTypeError extends BaseError {
-    constructor(value) {
-      super(`Value \`${typeof value === "object" ? stringify2(value) : value}\` of type \`${typeof value}\` is an invalid Bytes value.`, {
-        metaMessages: ["Bytes values must be of type `Bytes`."]
+  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: "Bytes.InvalidBytesTypeError"
+        value: "Address.InvalidChecksumError"
       });
     }
   };
-  SizeOverflowError = class SizeOverflowError extends BaseError {
-    constructor({ givenSize, maxSize }) {
-      super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
+});
+
+// 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: "Bytes.SizeOverflowError"
+        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"
+      });
+    }
+  };
+  InvalidIndefiniteLengthChunkError = class InvalidIndefiniteLengthChunkError extends BaseError {
+    constructor({ type }) {
+      super(`Invalid chunk type in indefinite-length ${type}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.InvalidIndefiniteLengthChunkError"
+      });
+    }
+  };
+  InvalidSimpleValueError = class InvalidSimpleValueError extends BaseError {
+    constructor({ value }) {
+      super(`Invalid CBOR simple value: ${value}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.InvalidSimpleValueError"
+      });
+    }
+  };
+  UnsupportedBigIntError = class UnsupportedBigIntError extends BaseError {
+    constructor() {
+      super("BigInt values are not supported in CBOR encoding.");
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.UnsupportedBigIntError"
+      });
+    }
+  };
+  UnexpectedTokenError = class UnexpectedTokenError extends BaseError {
+    constructor({ token }) {
+      super(`Unexpected token: ${token}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.UnexpectedTokenError"
+      });
+    }
+  };
+  NumberTooLargeError = class NumberTooLargeError extends BaseError {
+    constructor({ number }) {
+      super(`Number exceeds maximum safe integer (${Number.MAX_SAFE_INTEGER}): ${number}`);
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Cbor.NumberTooLargeError"
+      });
     }
-    _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;
+  };
+  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"
+      });
     }
-    clone() {
-      return this._cloneInto();
+  };
+  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"
+      });
     }
-    destroy() {
-      this.destroyed = true;
-      this.oHash.destroy();
-      this.iHash.destroy();
+  };
+  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);
-    }
-    digest() {
-      const { buffer, outputLen } = this;
-      this.digestInto(buffer);
-      const res = buffer.slice(0, outputLen);
-      this.destroy();
-      return res;
+      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.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;
     }
-    clone() {
-      return this._cloneInto();
+    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 });
     }
-  };
-  SHA256_IV = /* @__PURE__ */ Uint32Array.from([
-    1779033703,
-    3144134277,
-    1013904242,
-    2773480762,
-    1359893119,
-    2600822924,
-    528734635,
-    1541459225
-  ]);
+    decodeCursor2.readSimpleOrFloat = readSimpleOrFloat;
+    function getFloat16(bits) {
+      const sign = bits >> 15 & 1;
+      const exponent = bits >> 10 & 31;
+      const fraction = bits & 1023;
+      if (exponent === 0) {
+        if (fraction === 0)
+          return sign ? -0 : 0;
+        const value2 = 2 ** -14 * (fraction / 1024);
+        return sign ? -value2 : value2;
+      }
+      if (exponent === 31) {
+        if (fraction === 0)
+          return sign ? -Infinity : Infinity;
+        return NaN;
+      }
+      const value = 2 ** (exponent - 15) * (1 + fraction / 1024);
+      return sign ? -value : value;
+    }
+  })(decodeCursor || (decodeCursor = {}));
 });
 
-// node_modules/@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/CompactSize.js
+var init_CompactSize = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/ContractAddress.js
+var init_ContractAddress = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/CoseKey.js
+var init_CoseKey = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Ed25519.js
+var init_Ed25519 = () => {};
+
+// node_modules/@adraffy/ens-normalize/dist/index.mjs
+var FENCED, S0 = 44032, L0 = 4352, V0 = 4449, T0 = 4519, L_COUNT = 19, V_COUNT = 21, T_COUNT = 28, N_COUNT, S_COUNT, S1, L1, V1, T1;
+var init_dist = __esm(() => {
+  FENCED = new Map([[8217, "apostrophe"], [8260, "fraction slash"], [12539, "middle dot"]]);
+  N_COUNT = V_COUNT * T_COUNT;
+  S_COUNT = L_COUNT * N_COUNT;
+  S1 = S0 + S_COUNT;
+  L1 = L0 + L_COUNT;
+  V1 = V0 + V_COUNT;
+  T1 = T0 + T_COUNT;
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/Ens.js
+var init_Ens = __esm(() => {
+  init_dist();
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/Fee.js
+var init_Fee = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Filter.js
+var init_Filter = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Secp256k1.js
+var init_Secp256k1 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/HdKey.js
+var init_HdKey = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Keystore.js
+var init_Keystore = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Log.js
+var init_Log = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Mnemonic.js
+var init_Mnemonic = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/P256.js
+var init_P256 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/PersonalMessage.js
+var init_PersonalMessage = () => {};
+
+// node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS((exports, module) => {
+  var has = Object.prototype.hasOwnProperty;
+  var prefix = "~";
+  function Events() {}
+  if (Object.create) {
+    Events.prototype = Object.create(null);
+    if (!new Events().__proto__)
+      prefix = false;
+  }
+  function EE(fn, context, once) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once || false;
+  }
+  function addListener(emitter, event, fn, context, once) {
+    if (typeof fn !== "function") {
+      throw new TypeError("The listener must be a function");
     }
-    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;
+    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);
         }
-        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 true;
+  };
+  EventEmitter.prototype.on = function on(event, fn, context) {
+    return addListener(this, event, fn, context, false);
+  };
+  EventEmitter.prototype.once = function once(event, fn, context) {
+    return addListener(this, event, fn, context, true);
+  };
+  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return this;
+    if (!fn) {
+      clearEvent(this, evt);
+      return this;
+    }
+    var listeners = this._events[evt];
+    if (listeners.fn) {
+      if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+        clearEvent(this, evt);
+      }
+    } else {
+      for (var i = 0, events = [], length = listeners.length;i < length; i++) {
+        if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+          events.push(listeners[i]);
         }
       }
-      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);
+      if (events.length)
+        this._events[evt] = events.length === 1 ? events[0] : events;
+      else
+        clearEvent(this, evt);
     }
-    roundClean() {
-      clean(BUF_160);
+    return this;
+  };
+  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+    var evt;
+    if (event) {
+      evt = prefix ? prefix + event : event;
+      if (this._events[evt])
+        clearEvent(this, evt);
+    } else {
+      this._events = new Events;
+      this._eventsCount = 0;
     }
-    destroy() {
-      this.destroyed = true;
-      clean(this.buffer);
-      this.set(0, 0, 0, 0, 0);
+    return this;
+  };
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+  EventEmitter.prefixed = prefix;
+  EventEmitter.EventEmitter = EventEmitter;
+  if (typeof module !== "undefined") {
+    module.exports = EventEmitter;
+  }
+});
+
+// node_modules/eventemitter3/index.mjs
+var import__2;
+var init_eventemitter3 = __esm(() => {
+  import__2 = __toESM(require_eventemitter3(), 1);
+});
+
+// node_modules/mppx/node_modules/ox/_esm/core/RpcResponse.js
+var BaseError2, InvalidInputError2, ResourceNotFoundError, ResourceUnavailableError, TransactionRejectedError, MethodNotSupportedError, LimitExceededError, VersionNotSupportedError, InvalidRequestError, MethodNotFoundError, InvalidParamsError, InternalError, ParseError;
+var init_RpcResponse = __esm(() => {
+  BaseError2 = class BaseError2 extends Error {
+    constructor(errorObject) {
+      const { cause, code, message, data, stack } = errorObject;
+      super(message, { cause });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.BaseError"
+      });
+      Object.defineProperty(this, "cause", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "stack", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "data", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      this.cause = cause;
+      this.code = code;
+      this.data = data;
+      this.stack = stack ?? "";
+    }
+  };
+  InvalidInputError2 = class InvalidInputError2 extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        code: InvalidInputError2.code,
+        data: parameters.data,
+        message: parameters.message ?? "Missing or invalid parameters."
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32000
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.InvalidInputError"
+      });
+    }
+  };
+  Object.defineProperty(InvalidInputError2, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: -32000
+  });
+  ResourceNotFoundError = class ResourceNotFoundError extends BaseError2 {
+    constructor(parameters = {}) {
+      super({
+        code: ResourceNotFoundError.code,
+        data: parameters.data,
+        message: parameters.message ?? "Requested resource not found."
+      });
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: -32001
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "RpcResponse.ResourceNotFoundError"
+      });
     }
   };
-  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;
+  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"
+      });
     }
-    writeInto(out) {
-      aexists(this, false);
-      abytes(out);
-      this.finish();
-      const bufferOut = this.state;
-      const { blockLen } = this;
-      for (let pos = 0, len = out.length;pos < len; ) {
-        if (this.posOut >= blockLen)
-          this.keccak();
-        const take = Math.min(blockLen - this.posOut, len - pos);
-        out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
-        this.posOut += take;
-        pos += take;
-      }
-      return out;
+  };
+  Object.defineProperty(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"
+      });
     }
-    xofInto(out) {
-      if (!this.enableXOF)
-        throw new Error("XOF is not possible for this instance");
-      return this.writeInto(out);
+  };
+  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"
+      });
     }
-    xof(bytes) {
-      anumber(bytes);
-      return this.xofInto(new Uint8Array(bytes));
+  };
+  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;
     }
-    digestInto(out) {
-      aoutput(out, this);
-      if (this.finished)
-        throw new Error("digest() was already called");
-      this.writeInto(out);
-      this.destroy();
-      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"
+      });
     }
-    digest() {
-      return this.digestInto(new Uint8Array(this.outputLen));
+  };
+  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"
+      });
     }
-    destroy() {
-      this.destroyed = true;
-      clean(this.state);
+  };
+  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"
+      });
     }
-    _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(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"
+      });
     }
   };
-  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(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"
+      });
+    }
+  };
+  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"
+      });
     }
-    get() {
-      const { A, B, C, D: D2, E, F, G, H } = this;
-      return [A, B, C, D2, E, F, G, H];
+  };
+  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"
+      });
     }
-    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(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"
+      });
     }
-    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(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"
+      });
     }
-    roundClean() {
-      clean(SHA256_W);
+  };
+  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"
+      });
     }
-    destroy() {
-      this.set(0, 0, 0, 0, 0, 0, 0, 0);
-      clean(this.buffer);
+  };
+  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"
+      });
     }
   };
-  sha256 = /* @__PURE__ */ createHasher(() => new SHA256);
+  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"
+      });
+    }
+  };
+  Object.defineProperty(AtomicReadyWalletRejectedUpgradeError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 5750
+  });
+  AtomicityNotSupportedError = class AtomicityNotSupportedError extends ProviderRpcError {
+    constructor({ message = "The wallet does not support atomic execution but the request requires it." } = {}) {
+      super(5760, message);
+      Object.defineProperty(this, "code", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: 5760
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "Provider.AtomicityNotSupportedError"
+      });
+    }
+  };
+  Object.defineProperty(AtomicityNotSupportedError, "code", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 5760
+  });
 });
 
-// node_modules/@noble/hashes/esm/sha256.js
-var sha2562;
-var init_sha256 = __esm(() => {
-  init_sha2();
-  sha2562 = sha256;
-});
+// node_modules/mppx/node_modules/ox/_esm/core/RpcTransport.js
+var init_RpcTransport = () => {};
 
-// node_modules/mppx/node_modules/ox/_esm/core/Hash.js
-var exports_Hash = {};
-__export(exports_Hash, {
-  validate: () => validate4,
-  sha256: () => sha2563,
-  ripemd160: () => ripemd1603,
-  keccak256: () => keccak256,
-  hmac256: () => hmac256
-});
-function keccak256(value, options2 = {}) {
-  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
-  const bytes = keccak_256(from(value));
-  if (as === "Bytes")
-    return bytes;
-  return fromBytes(bytes);
-}
-function hmac256(key, value, options2 = {}) {
-  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
-  const bytes = hmac(sha2562, from(key), from(value));
-  if (as === "Bytes")
-    return bytes;
-  return fromBytes(bytes);
-}
-function ripemd1603(value, options2 = {}) {
-  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
-  const bytes = ripemd1602(from(value));
-  if (as === "Bytes")
-    return bytes;
-  return fromBytes(bytes);
-}
-function sha2563(value, options2 = {}) {
-  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options2;
-  const bytes = sha2562(from(value));
-  if (as === "Bytes")
-    return bytes;
-  return fromBytes(bytes);
-}
-function validate4(value) {
-  return validate2(value) && size2(value) === 32;
-}
-var init_Hash = __esm(() => {
-  init_hmac();
-  init_ripemd160();
-  init_sha3();
-  init_sha256();
-  init_Bytes();
-  init_Hex();
-});
+// node_modules/mppx/node_modules/ox/_esm/core/Siwe.js
+var init_Siwe = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/StateOverrides.js
+var init_StateOverrides = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TransactionReceipt.js
+var init_TransactionReceipt = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TransactionRequest.js
+var init_TransactionRequest = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/Value.js
+var init_Value = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TxEnvelope.js
+var init_TxEnvelope = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TxEnvelopeEip1559.js
+var init_TxEnvelopeEip1559 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TxEnvelopeEip2930.js
+var init_TxEnvelopeEip2930 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TxEnvelopeEip4844.js
+var init_TxEnvelopeEip4844 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TxEnvelopeEip7702.js
+var init_TxEnvelopeEip7702 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TxEnvelopeLegacy.js
+var init_TxEnvelopeLegacy = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/TypedData.js
+var init_TypedData = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/ValidatorData.js
+var init_ValidatorData = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/WebAuthnP256.js
+var init_WebAuthnP256 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/WebCryptoP256.js
+var init_WebCryptoP256 = () => {};
+
+// node_modules/mppx/node_modules/ox/_esm/core/X25519.js
+var init_X25519 = () => {};
 
 // node_modules/mppx/node_modules/ox/_esm/index.js
 var init__esm = __esm(() => {
+  init_Abi();
+  init_AbiConstructor();
+  init_AbiError();
+  init_AbiEvent();
+  init_AbiFunction();
+  init_AbiItem();
+  init_AbiParameters();
+  init_AccessList();
+  init_AccountProof();
+  init_Address();
+  init_AesGcm();
+  init_Authorization();
+  init_Base32();
+  init_Base58();
   init_Base64();
+  init_Bech32m();
+  init_BinaryStateTree();
+  init_Blobs();
+  init_Block();
+  init_BlockOverrides();
+  init_Bloom();
+  init_Bls();
+  init_BlsPoint();
   init_Bytes();
+  init_Caches();
+  init_Cbor();
+  init_CompactSize();
+  init_ContractAddress();
+  init_CoseKey();
+  init_Ed25519();
+  init_Ens();
+  init_Errors();
+  init_Fee();
+  init_Filter();
   init_Hash();
+  init_HdKey();
   init_Hex();
+  init_Keystore();
+  init_Log();
+  init_Mnemonic();
+  init_P256();
+  init_PersonalMessage();
+  init_Provider();
+  init_PublicKey();
+  init_Rlp();
+  init_RpcResponse();
+  init_RpcTransport();
+  init_Secp256k1();
+  init_Signature();
+  init_Siwe();
+  init_Solidity();
+  init_StateOverrides();
+  init_Transaction();
+  init_TransactionReceipt();
+  init_TransactionRequest();
+  init_TxEnvelope();
+  init_TxEnvelopeEip1559();
+  init_TxEnvelopeEip2930();
+  init_TxEnvelopeEip4844();
+  init_TxEnvelopeEip7702();
+  init_TxEnvelopeLegacy();
+  init_TypedData();
+  init_ValidatorData();
+  init_Value();
+  init_WebAuthnP256();
+  init_WebCryptoP256();
+  init_Withdrawal();
+  init_X25519();
 });
 
+// node_modules/mppx/dist/BodyDigest.js
+var init_BodyDigest = () => {};
+
 // node_modules/mppx/dist/PaymentRequest.js
 function deserialize(encoded) {
   const json = exports_Base64.toString(encoded);
@@ -9433,7 +11608,7 @@ __export(exports_util, {
   assertNever: () => assertNever,
   assertIs: () => assertIs,
   assertEqual: () => assertEqual,
-  assert: () => assert3,
+  assert: () => assert4,
   allowsEval: () => allowsEval,
   aborted: () => aborted,
   NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
@@ -9450,7 +11625,7 @@ function assertIs(_arg) {}
 function assertNever(_x) {
   throw new Error("Unexpected value in exhaustive check");
 }
-function assert3(_) {}
+function assert4(_) {}
 function getEnumValues(entries) {
   const numericValues = Object.values(entries).filter((v) => typeof v === "number");
   const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
@@ -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
@@ -26531,6 +28737,9 @@ function printCompleted(final, title, deliveredToThisSession = false) {
   } else {
     console.log(dim("Not charged (settlement pending or waived)."));
   }
+  if (final.driveDocId) {
+    console.log(label("Saved to drive", final.driveDocId) + dim("  (amiko drive get " + final.driveDocId + ")"));
+  }
   console.log(dim("View in your media space: https://platform.heyamiko.com/media"));
 }
 async function submitCreateJob(opts) {
@@ -26541,7 +28750,7 @@ async function submitCreateJob(opts) {
     console.error(error(e5 instanceof Error ? e5.message : "auth failed"));
     process.exit(1);
   }
-  const payMethod = (opts.pay ?? "wallet").toLowerCase();
+  const payMethod = (opts.pay ?? "credits").toLowerCase();
   if (payMethod !== "wallet" && payMethod !== "credits") {
     console.error(error(`Unknown --pay "${opts.pay}". Allowed: wallet, credits.`));
     process.exit(1);
@@ -26569,15 +28778,16 @@ async function submitCreateJob(opts) {
   } catch {}
   const preferredToken = typeof opts.jobBody.preferredToken === "string" ? opts.jobBody.preferredToken.toUpperCase() : undefined;
   const chargeIsAmiko = !payCredits && (preferredToken === undefined || preferredToken === "AMIKO");
+  const autoApprovable = payCredits || chargeIsAmiko;
   const effectiveChargeToken = preferredToken ?? "AMIKO";
   let yes = opts.yes;
   let autoApproved = false;
   if (!yes) {
     const limit = autoApproveLimit();
-    if (limit !== undefined && quotedCostAmiko !== undefined && quotedCostAmiko > 0 && chargeIsAmiko && quotedCostAmiko <= limit) {
+    if (limit !== undefined && quotedCostAmiko !== undefined && quotedCostAmiko > 0 && autoApprovable && quotedCostAmiko <= limit) {
       yes = true;
       autoApproved = true;
-      console.log(dim(`Auto-approved (cost ${quotedCostAmiko} ≤ limit ${limit} AMIKO)`));
+      console.log(dim(`Auto-approved (cost ${quotedCostAmiko} ≤ limit ${limit} AMIKO${payCredits ? ", charged as account credits" : ""})`));
     }
   }
   await requireApproval({
@@ -26601,7 +28811,7 @@ async function submitCreateJob(opts) {
       body: {
         ...opts.jobBody,
         twinId: auth.twinId,
-        ...autoApproved ? { preferredToken: effectiveChargeToken, strictToken: true } : {},
+        ...autoApproved && !payCredits ? { preferredToken: effectiveChargeToken, strictToken: true } : {},
         ...payCredits ? {
           paymentMethod: { kind: "account_credits" },
           requestId: randomUUID()
@@ -26663,7 +28873,7 @@ async function submitCreateJob(opts) {
   }
 }
 function registerCreateCommand(create2) {
-  create2.command("image <prompt>").description("Generate an image (Create Studio)").option("--model <model>", "Image model: nano-banana-2 (default), nano-banana[-pro|-lite] (Google), gpt-image-2/-1.5/-1/-1-mini (OpenAI), grok-imagine-image-quality (xAI), image-01 (MiniMax)", "nano-banana-2").option("--aspect <ratio>", "Aspect ratio: 1:1, 16:9, 9:16, 4:3, 3:4", "1:1").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--pay <method>", "Payment method: wallet (twin wallet, default) or credits (Amiko account credits — unified accounts only)", "wallet").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (prompt, opts) => {
+  create2.command("image <prompt>").description("Generate an image (Create Studio)").option("--model <model>", "Image model: nano-banana-2 (default), nano-banana[-pro|-lite] (Google), gpt-image-2/-1.5/-1/-1-mini (OpenAI), grok-imagine-image-quality (xAI), image-01 (MiniMax)", "nano-banana-2").option("--aspect <ratio>", "Aspect ratio: 1:1, 16:9, 9:16, 4:3, 3:4", "1:1").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--pay <method>", "Payment method: credits (Amiko account credits, default) or wallet (twin wallet)", "credits").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (prompt, opts) => {
     await submitCreateJob({
       mode: "IMAGE",
       summary: `Create image: ${prompt.slice(0, 80)}${prompt.length > 80 ? "…" : ""}`,
@@ -26680,7 +28890,7 @@ function registerCreateCommand(create2) {
       }
     });
   });
-  create2.command("video <prompt>").description("Generate a video (Create Studio)").option("--model <model>", "Video model: MiniMax-Hailuo-02 (default for prompt-only; T2V+I2V), MiniMax-Hailuo-2.3-Fast (default with --first-frame; I2V only), MiniMax-Hailuo-2.3 (T2V+I2V), veo-3.1[-fast|-lite]-generate-preview (Google; durations clamp to 4/6/8s), grok-imagine-video (xAI), dreamina-seedance-* (BytePlus). ONLY these — kling and other ids are not supported").option("--resolution <res>", "512P, 720P, 768P, 1080P", "768P").option("--seconds <n>", "Clip length: 6 or 10", "6").option("--aspect <ratio>", "Aspect ratio (provider-dependent)").option("--first-frame <url>", "Image-to-video: first frame URL/data URI").option("--last-frame <url>", "First-and-last-frame video: ending frame URL/data URI").option("--reference-image <url>", "Seedance multimodal: reference image URL (repeatable, max 9)", collectOption, []).option("--reference-video <url>", "Seedance multimodal: reference video URL (repeatable, max 3)", collectOption, []).option("--reference-audio <url>", "Seedance multimodal: reference audio URL (repeatable, max 3)", collectOption, []).option("--subject-reference <url>", "MiniMax S2V: subject/character reference image URL").option("--generate-audio", "Seedance: generate audio in the output video").option("--no-generate-audio", "Seedance: output silent video").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--pay <method>", "Payment method: wallet (twin wallet, default) or credits (Amiko account credits — unified accounts only)", "wallet").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (prompt, opts) => {
+  create2.command("video <prompt>").description("Generate a video (Create Studio)").option("--model <model>", "Video model: MiniMax-Hailuo-02 (default for prompt-only; T2V+I2V), MiniMax-Hailuo-2.3-Fast (default with --first-frame; I2V only), MiniMax-Hailuo-2.3 (T2V+I2V), veo-3.1[-fast|-lite]-generate-preview (Google; durations clamp to 4/6/8s), grok-imagine-video (xAI), dreamina-seedance-* (BytePlus). ONLY these — kling and other ids are not supported").option("--resolution <res>", "512P, 720P, 768P, 1080P", "768P").option("--seconds <n>", "Clip length: 6 or 10", "6").option("--aspect <ratio>", "Aspect ratio (provider-dependent)").option("--first-frame <url>", "Image-to-video: first frame URL/data URI").option("--last-frame <url>", "First-and-last-frame video: ending frame URL/data URI").option("--reference-image <url>", "Seedance multimodal: reference image URL (repeatable, max 9)", collectOption, []).option("--reference-video <url>", "Seedance multimodal: reference video URL (repeatable, max 3)", collectOption, []).option("--reference-audio <url>", "Seedance multimodal: reference audio URL (repeatable, max 3)", collectOption, []).option("--subject-reference <url>", "MiniMax S2V: subject/character reference image URL").option("--generate-audio", "Seedance: generate audio in the output video").option("--no-generate-audio", "Seedance: output silent video").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--pay <method>", "Payment method: credits (Amiko account credits, default) or wallet (twin wallet)", "credits").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (prompt, opts) => {
     const seconds = Number(opts.seconds);
     if (seconds !== 6 && seconds !== 10) {
       console.error(error("--seconds must be 6 or 10."));
@@ -26742,7 +28952,7 @@ function registerCreateCommand(create2) {
     "speech-2.6-turbo",
     "speech-2.6-hd"
   ]);
-  create2.command("tts <text>").description("Generate speech from text (Create Studio)").option("--provider <name>", "TTS provider: minimax | elevenlabs (sets defaults when --model/--voice omitted)").option("--model <model>", `TTS model id (MiniMax: speech-2.8-turbo|hd, speech-2.6-turbo|hd; ElevenLabs: eleven_*)`).option("--voice <voiceId>", "Voice id (MiniMax system e.g. English_expressive_narrator, or a cloned voice_id; ElevenLabs voice hash)").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--pay <method>", "Payment method: wallet (twin wallet, default) or credits (Amiko account credits — unified accounts only)", "wallet").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (text, opts) => {
+  create2.command("tts <text>").description("Generate speech from text (Create Studio)").option("--provider <name>", "TTS provider: minimax | elevenlabs (sets defaults when --model/--voice omitted)").option("--model <model>", `TTS model id (MiniMax: speech-2.8-turbo|hd, speech-2.6-turbo|hd; ElevenLabs: eleven_*)`).option("--voice <voiceId>", "Voice id (MiniMax system e.g. English_expressive_narrator, or a cloned voice_id; ElevenLabs voice hash)").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--pay <method>", "Payment method: credits (Amiko account credits, default) or wallet (twin wallet)", "credits").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (text, opts) => {
     const providerRaw = typeof opts.provider === "string" ? opts.provider.trim().toLowerCase() : "";
     if (providerRaw && providerRaw !== "minimax" && providerRaw !== "elevenlabs") {
       console.error(error("--provider must be minimax or elevenlabs"));
@@ -26784,7 +28994,7 @@ function registerCreateCommand(create2) {
       }
     });
   });
-  create2.command("music [prompt]").description("Generate music (Create Studio)").option("--model <model>", "music_v1, music-2.6[-free], music-cover[-free]", "music-2.6").option("--lyrics <lyrics>", "Lyrics (optional)").option("--duration <ms>", "Length in ms").option("--instrumental", "Instrumental (no vocals)").option("--lyrics-optimizer", "Auto-write lyrics from the prompt (music_v1 only; on by default when no --lyrics/--instrumental)").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--pay <method>", "Payment method: wallet (twin wallet, default) or credits (Amiko account credits — unified accounts only)", "wallet").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (prompt, opts) => {
+  create2.command("music [prompt]").description("Generate music (Create Studio)").option("--model <model>", "music_v1, music-2.6[-free], music-cover[-free]", "music-2.6").option("--lyrics <lyrics>", "Lyrics (optional)").option("--duration <ms>", "Length in ms").option("--instrumental", "Instrumental (no vocals)").option("--lyrics-optimizer", "Auto-write lyrics from the prompt (music_v1 only; on by default when no --lyrics/--instrumental)").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--pay <method>", "Payment method: credits (Amiko account credits, default) or wallet (twin wallet)", "credits").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (prompt, opts) => {
     if (!prompt && !opts.lyrics) {
       console.error(error("Provide a prompt or --lyrics."));
       process.exit(1);
@@ -26808,7 +29018,7 @@ function registerCreateCommand(create2) {
       }
     });
   });
-  create2.command("sfx <text>").description("Generate a sound effect (Create Studio)").option("--duration <seconds>", "Clip length in seconds").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--pay <method>", "Payment method: wallet (twin wallet, default) or credits (Amiko account credits — unified accounts only)", "wallet").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (text, opts) => {
+  create2.command("sfx <text>").description("Generate a sound effect (Create Studio)").option("--duration <seconds>", "Clip length in seconds").option("--token <symbol>", "Preferred charge token: AMIKO, USDC, USDT, SOL").option("--pay <method>", "Payment method: credits (Amiko account credits, default) or wallet (twin wallet)", "credits").option("--raw", "Output raw JSON").option("--yes", "Skip the pre-spend confirmation (required in non-interactive shells)").action(async (text, opts) => {
     await submitCreateJob({
       mode: "SFX",
       summary: `Create SFX: ${text.slice(0, 80)}${text.length > 80 ? "…" : ""}`,
@@ -30466,12 +32676,15 @@ function registerPostCommand(program2) {
       }
       const data = await amikoWebFetch(auth, "/api/posts", { method: "POST", body });
       spinner?.stop();
-      renderOutput(data, (d) => {
+      const postUrl = data.post?.id ? `https://platform.heyamiko.com/post/${data.post.id}` : null;
+      renderOutput(postUrl ? { ...data, post_url: postUrl } : data, (d) => {
         console.log(success("Post published"));
         const post = d.post;
         if (post) {
           if (post.id)
             console.log(label("Post ID", String(post.id)));
+          if (postUrl)
+            console.log(label("URL", postUrl));
           console.log(label("Visibility", visibility));
         }
       }, { json: opts.json });