@elizaos/project-tee-starter 1.6.5-alpha.8 → 1.6.5-beta.0

package/dist/index.js

@@ -720,6 +720,416 @@ var init_hmac = __esm(() => {
   hmac.create = (hash, key) => new HMAC(hash, key);
 });
 
+// ../../node_modules/viem/_esm/errors/version.js
+var version = "2.41.2";
+
+// ../../node_modules/viem/_esm/errors/base.js
+function walk(err, fn) {
+  if (fn?.(err))
+    return err;
+  if (err && typeof err === "object" && "cause" in err && err.cause !== undefined)
+    return walk(err.cause, fn);
+  return fn ? null : err;
+}
+var errorConfig, BaseError;
+var init_base = __esm(() => {
+  errorConfig = {
+    getDocsUrl: ({ docsBaseUrl, docsPath = "", docsSlug }) => docsPath ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath}${docsSlug ? `#${docsSlug}` : ""}` : undefined,
+    version: `viem@${version}`
+  };
+  BaseError = class BaseError extends Error {
+    constructor(shortMessage, args = {}) {
+      const details = (() => {
+        if (args.cause instanceof BaseError)
+          return args.cause.details;
+        if (args.cause?.message)
+          return args.cause.message;
+        return args.details;
+      })();
+      const docsPath = (() => {
+        if (args.cause instanceof BaseError)
+          return args.cause.docsPath || args.docsPath;
+        return args.docsPath;
+      })();
+      const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath });
+      const message = [
+        shortMessage || "An error occurred.",
+        "",
+        ...args.metaMessages ? [...args.metaMessages, ""] : [],
+        ...docsUrl ? [`Docs: ${docsUrl}`] : [],
+        ...details ? [`Details: ${details}`] : [],
+        ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
+      ].join(`
+`);
+      super(message, args.cause ? { cause: args.cause } : undefined);
+      Object.defineProperty(this, "details", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "docsPath", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "metaMessages", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "shortMessage", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "version", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "BaseError"
+      });
+      this.details = details;
+      this.docsPath = docsPath;
+      this.metaMessages = args.metaMessages;
+      this.name = args.name ?? this.name;
+      this.shortMessage = shortMessage;
+      this.version = version;
+    }
+    walk(fn) {
+      return walk(this, fn);
+    }
+  };
+});
+
+// ../../node_modules/viem/_esm/errors/encoding.js
+var IntegerOutOfRangeError, SizeOverflowError;
+var init_encoding = __esm(() => {
+  init_base();
+  IntegerOutOfRangeError = class IntegerOutOfRangeError extends BaseError {
+    constructor({ max, min, signed, size, value }) {
+      super(`Number "${value}" is not in safe ${size ? `${size * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
+    }
+  };
+  SizeOverflowError = class SizeOverflowError extends BaseError {
+    constructor({ givenSize, maxSize }) {
+      super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
+    }
+  };
+});
+
+// ../../node_modules/viem/_esm/utils/data/isHex.js
+function isHex(value, { strict = true } = {}) {
+  if (!value)
+    return false;
+  if (typeof value !== "string")
+    return false;
+  return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
+}
+
+// ../../node_modules/viem/_esm/utils/data/size.js
+function size(value) {
+  if (isHex(value, { strict: false }))
+    return Math.ceil((value.length - 2) / 2);
+  return value.length;
+}
+var init_size = () => {};
+
+// ../../node_modules/viem/_esm/utils/data/trim.js
+function trim(hexOrBytes, { dir = "left" } = {}) {
+  let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
+  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);
+  if (typeof hexOrBytes === "string") {
+    if (data.length === 1 && dir === "right")
+      data = `${data}0`;
+    return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
+  }
+  return data;
+}
+
+// ../../node_modules/viem/_esm/errors/data.js
+var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
+var init_data = __esm(() => {
+  init_base();
+  SliceOffsetOutOfBoundsError = class SliceOffsetOutOfBoundsError extends BaseError {
+    constructor({ offset, position, size: size2 }) {
+      super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size2}).`, { name: "SliceOffsetOutOfBoundsError" });
+    }
+  };
+  SizeExceedsPaddingSizeError = class SizeExceedsPaddingSizeError extends BaseError {
+    constructor({ size: size2, targetSize, type }) {
+      super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
+    }
+  };
+});
+
+// ../../node_modules/viem/_esm/utils/data/pad.js
+function pad(hexOrBytes, { dir, size: size2 = 32 } = {}) {
+  if (typeof hexOrBytes === "string")
+    return padHex(hexOrBytes, { dir, size: size2 });
+  return padBytes(hexOrBytes, { dir, size: size2 });
+}
+function padHex(hex_, { dir, size: size2 = 32 } = {}) {
+  if (size2 === null)
+    return hex_;
+  const hex = hex_.replace("0x", "");
+  if (hex.length > size2 * 2)
+    throw new SizeExceedsPaddingSizeError({
+      size: Math.ceil(hex.length / 2),
+      targetSize: size2,
+      type: "hex"
+    });
+  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size2 * 2, "0")}`;
+}
+function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
+  if (size2 === null)
+    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;
+}
+var init_pad = __esm(() => {
+  init_data();
+});
+
+// ../../node_modules/viem/_esm/utils/encoding/toHex.js
+function toHex(value, opts = {}) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToHex(value, opts);
+  if (typeof value === "string") {
+    return stringToHex(value, opts);
+  }
+  if (typeof value === "boolean")
+    return boolToHex(value, opts);
+  return bytesToHex(value, opts);
+}
+function boolToHex(value, opts = {}) {
+  const hex = `0x${Number(value)}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { size: opts.size });
+  }
+  return hex;
+}
+function bytesToHex(value, opts = {}) {
+  let string = "";
+  for (let i = 0;i < value.length; i++) {
+    string += hexes[value[i]];
+  }
+  const hex = `0x${string}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { dir: "right", size: opts.size });
+  }
+  return hex;
+}
+function numberToHex(value_, opts = {}) {
+  const { signed, size: size2 } = opts;
+  const value = BigInt(value_);
+  let maxValue;
+  if (size2) {
+    if (signed)
+      maxValue = (1n << BigInt(size2) * 8n - 1n) - 1n;
+    else
+      maxValue = 2n ** (BigInt(size2) * 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: size2,
+      value: `${value_}${suffix}`
+    });
+  }
+  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size2 * 8)) + BigInt(value) : value).toString(16)}`;
+  if (size2)
+    return pad(hex, { size: size2 });
+  return hex;
+}
+function stringToHex(value_, opts = {}) {
+  const value = encoder.encode(value_);
+  return bytesToHex(value, opts);
+}
+var hexes, encoder;
+var init_toHex = __esm(() => {
+  init_encoding();
+  init_pad();
+  init_fromHex();
+  hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+  encoder = /* @__PURE__ */ new TextEncoder;
+});
+
+// ../../node_modules/viem/_esm/utils/encoding/toBytes.js
+function toBytes2(value, opts = {}) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToBytes(value, opts);
+  if (typeof value === "boolean")
+    return boolToBytes(value, opts);
+  if (isHex(value))
+    return hexToBytes(value, opts);
+  return stringToBytes(value, opts);
+}
+function boolToBytes(value, opts = {}) {
+  const bytes = new Uint8Array(1);
+  bytes[0] = Number(value);
+  if (typeof opts.size === "number") {
+    assertSize(bytes, { size: opts.size });
+    return pad(bytes, { size: opts.size });
+  }
+  return bytes;
+}
+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 hexToBytes(hex_, opts = {}) {
+  let hex = hex_;
+  if (opts.size) {
+    assertSize(hex, { size: opts.size });
+    hex = pad(hex, { dir: "right", size: opts.size });
+  }
+  let hexString = hex.slice(2);
+  if (hexString.length % 2)
+    hexString = `0${hexString}`;
+  const length = hexString.length / 2;
+  const bytes = new Uint8Array(length);
+  for (let index = 0, j = 0;index < length; index++) {
+    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
+    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+    if (nibbleLeft === undefined || nibbleRight === undefined) {
+      throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+    }
+    bytes[index] = nibbleLeft * 16 + nibbleRight;
+  }
+  return bytes;
+}
+function numberToBytes(value, opts) {
+  const hex = numberToHex(value, opts);
+  return hexToBytes(hex);
+}
+function stringToBytes(value, opts = {}) {
+  const bytes = encoder2.encode(value);
+  if (typeof opts.size === "number") {
+    assertSize(bytes, { size: opts.size });
+    return pad(bytes, { dir: "right", size: opts.size });
+  }
+  return bytes;
+}
+var encoder2, charCodeMap;
+var init_toBytes = __esm(() => {
+  init_base();
+  init_pad();
+  init_fromHex();
+  init_toHex();
+  encoder2 = /* @__PURE__ */ new TextEncoder;
+  charCodeMap = {
+    zero: 48,
+    nine: 57,
+    A: 65,
+    F: 70,
+    a: 97,
+    f: 102
+  };
+});
+
+// ../../node_modules/viem/_esm/utils/encoding/fromHex.js
+function assertSize(hexOrBytes, { size: size2 }) {
+  if (size(hexOrBytes) > size2)
+    throw new SizeOverflowError({
+      givenSize: size(hexOrBytes),
+      maxSize: size2
+    });
+}
+function hexToBigInt(hex, opts = {}) {
+  const { signed } = opts;
+  if (opts.size)
+    assertSize(hex, { size: opts.size });
+  const value = BigInt(hex);
+  if (!signed)
+    return value;
+  const size2 = (hex.length - 2) / 2;
+  const max = (1n << BigInt(size2) * 8n - 1n) - 1n;
+  if (value <= max)
+    return value;
+  return value - BigInt(`0x${"f".padStart(size2 * 2, "f")}`) - 1n;
+}
+function hexToNumber(hex, opts = {}) {
+  return Number(hexToBigInt(hex, opts));
+}
+var init_fromHex = __esm(() => {
+  init_encoding();
+  init_size();
+});
+
+// ../../node_modules/viem/_esm/utils/lru.js
+var LruMap;
+var init_lru = __esm(() => {
+  LruMap = class LruMap extends Map {
+    constructor(size2) {
+      super();
+      Object.defineProperty(this, "maxSize", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      this.maxSize = size2;
+    }
+    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/viem/node_modules/@noble/curves/esm/abstract/utils.js
 function isBytes2(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
@@ -736,18 +1146,18 @@ function numberToHexUnpadded(num) {
   const hex = num.toString(16);
   return hex.length & 1 ? "0" + hex : hex;
 }
-function hexToNumber(hex) {
+function hexToNumber2(hex) {
   if (typeof hex !== "string")
     throw new Error("hex string expected, got " + typeof hex);
   return hex === "" ? _0n : BigInt("0x" + hex);
 }
-function bytesToHex(bytes) {
+function bytesToHex2(bytes) {
   abytes2(bytes);
   if (hasHexBuiltin)
     return bytes.toHex();
   let hex = "";
   for (let i = 0;i < bytes.length; i++) {
-    hex += hexes[bytes[i]];
+    hex += hexes2[bytes[i]];
   }
   return hex;
 }
@@ -760,7 +1170,7 @@ function asciiToBase16(ch) {
     return ch - (asciis.a - 10);
   return;
 }
-function hexToBytes(hex) {
+function hexToBytes2(hex) {
   if (typeof hex !== "string")
     throw new Error("hex string expected, got " + typeof hex);
   if (hasHexBuiltin)
@@ -782,14 +1192,14 @@ function hexToBytes(hex) {
   return array;
 }
 function bytesToNumberBE(bytes) {
-  return hexToNumber(bytesToHex(bytes));
+  return hexToNumber2(bytesToHex2(bytes));
 }
 function bytesToNumberLE(bytes) {
   abytes2(bytes);
-  return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
+  return hexToNumber2(bytesToHex2(Uint8Array.from(bytes).reverse()));
 }
 function numberToBytesBE(n, len) {
-  return hexToBytes(n.toString(16).padStart(len * 2, "0"));
+  return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
 }
 function numberToBytesLE(n, len) {
   return numberToBytesBE(n, len).reverse();
@@ -798,7 +1208,7 @@ function ensureBytes(title, hex, expectedLength) {
   let res;
   if (typeof hex === "string") {
     try {
-      res = hexToBytes(hex);
+      res = hexToBytes2(hex);
     } catch (e) {
       throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
     }
@@ -820,10 +1230,10 @@ function concatBytes2(...arrays) {
     sum += a.length;
   }
   const res = new Uint8Array(sum);
-  for (let i = 0, pad = 0;i < arrays.length; i++) {
+  for (let i = 0, pad2 = 0;i < arrays.length; i++) {
     const a = arrays[i];
-    res.set(a, pad);
-    pad += a.length;
+    res.set(a, pad2);
+    pad2 += a.length;
   }
   return res;
 }
@@ -917,13 +1327,13 @@ function memoized(fn) {
     return computed;
   };
 }
-var _0n, _1n, hasHexBuiltin, hexes, asciis, isPosBig = (n) => typeof n === "bigint" && _0n <= n, bitMask = (n) => (_1n << BigInt(n)) - _1n, u8n = (len) => new Uint8Array(len), u8fr = (arr) => Uint8Array.from(arr), validatorFns;
+var _0n, _1n, hasHexBuiltin, hexes2, asciis, isPosBig = (n) => typeof n === "bigint" && _0n <= n, bitMask = (n) => (_1n << BigInt(n)) - _1n, u8n = (len) => new Uint8Array(len), u8fr = (arr) => Uint8Array.from(arr), validatorFns;
 var init_utils2 = __esm(() => {
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   _0n = /* @__PURE__ */ BigInt(0);
   _1n = /* @__PURE__ */ BigInt(1);
   hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
-  hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+  hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
   asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
   validatorFns = {
     bigint: (val) => typeof val === "bigint",
@@ -1455,14 +1865,14 @@ function validatePointOpts(curve) {
   }
   return Object.freeze({ ...opts });
 }
-function numToSizedHex(num, size) {
-  return bytesToHex(numberToBytesBE(num, size));
+function numToSizedHex(num, size2) {
+  return bytesToHex2(numberToBytesBE(num, size2));
 }
 function weierstrassPoints(opts) {
   const CURVE = validatePointOpts(opts);
   const { Fp } = CURVE;
   const Fn = Field(CURVE.n, CURVE.nBitLength);
-  const toBytes2 = CURVE.toBytes || ((_c, point, _isCompressed) => {
+  const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
     const a = point.toAffine();
     return concatBytes2(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
   });
@@ -1496,7 +1906,7 @@ function weierstrassPoints(opts) {
     const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
     if (lengths && typeof key !== "bigint") {
       if (isBytes2(key))
-        key = bytesToHex(key);
+        key = bytesToHex2(key);
       if (typeof key !== "string" || !lengths.includes(key.length))
         throw new Error("invalid private key");
       key = key.padStart(nByteLength * 2, "0");
@@ -1790,11 +2200,11 @@ function weierstrassPoints(opts) {
     toRawBytes(isCompressed = true) {
       abool("isCompressed", isCompressed);
       this.assertValidity();
-      return toBytes2(Point, this, isCompressed);
+      return toBytes3(Point, this, isCompressed);
     }
     toHex(isCompressed = true) {
       abool("isCompressed", isCompressed);
-      return bytesToHex(this.toRawBytes(isCompressed));
+      return bytesToHex2(this.toRawBytes(isCompressed));
     }
   }
   Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
@@ -1936,13 +2346,13 @@ function weierstrass(curveDef) {
       return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;
     }
     toDERRawBytes() {
-      return hexToBytes(this.toDERHex());
+      return hexToBytes2(this.toDERHex());
     }
     toDERHex() {
       return DER.hexFromSig(this);
     }
     toCompactRawBytes() {
-      return hexToBytes(this.toCompactHex());
+      return hexToBytes2(this.toCompactHex());
     }
     toCompactHex() {
       const l = nByteLength;
@@ -2072,16 +2482,16 @@ function weierstrass(curveDef) {
       throw new Error("options.strict was renamed to lowS");
     if (format !== undefined && format !== "compact" && format !== "der")
       throw new Error("format must be compact or der");
-    const isHex = typeof sg === "string" || isBytes2(sg);
-    const isObj = !isHex && !format && typeof sg === "object" && sg !== null && typeof sg.r === "bigint" && typeof sg.s === "bigint";
-    if (!isHex && !isObj)
+    const isHex2 = typeof sg === "string" || isBytes2(sg);
+    const isObj = !isHex2 && !format && typeof sg === "object" && sg !== null && typeof sg.r === "bigint" && typeof sg.s === "bigint";
+    if (!isHex2 && !isObj)
       throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
     let _sig = undefined;
     let P;
     try {
       if (isObj)
         _sig = new Signature(sg.r, sg.s);
-      if (isHex) {
+      if (isHex2) {
         try {
           if (format !== "compact")
             _sig = Signature.fromDER(sg);
@@ -2326,382 +2736,6 @@ var init_secp256k1 = __esm(() => {
   }, sha256);
 });
 
-// ../../node_modules/viem/_esm/errors/version.js
-var version = "2.30.1";
-
-// ../../node_modules/viem/_esm/errors/base.js
-function walk(err, fn) {
-  if (fn?.(err))
-    return err;
-  if (err && typeof err === "object" && "cause" in err && err.cause !== undefined)
-    return walk(err.cause, fn);
-  return fn ? null : err;
-}
-var errorConfig, BaseError;
-var init_base = __esm(() => {
-  errorConfig = {
-    getDocsUrl: ({ docsBaseUrl, docsPath = "", docsSlug }) => docsPath ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath}${docsSlug ? `#${docsSlug}` : ""}` : undefined,
-    version: `viem@${version}`
-  };
-  BaseError = class BaseError extends Error {
-    constructor(shortMessage, args = {}) {
-      const details = (() => {
-        if (args.cause instanceof BaseError)
-          return args.cause.details;
-        if (args.cause?.message)
-          return args.cause.message;
-        return args.details;
-      })();
-      const docsPath = (() => {
-        if (args.cause instanceof BaseError)
-          return args.cause.docsPath || args.docsPath;
-        return args.docsPath;
-      })();
-      const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath });
-      const message = [
-        shortMessage || "An error occurred.",
-        "",
-        ...args.metaMessages ? [...args.metaMessages, ""] : [],
-        ...docsUrl ? [`Docs: ${docsUrl}`] : [],
-        ...details ? [`Details: ${details}`] : [],
-        ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
-      ].join(`
-`);
-      super(message, args.cause ? { cause: args.cause } : undefined);
-      Object.defineProperty(this, "details", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: undefined
-      });
-      Object.defineProperty(this, "docsPath", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: undefined
-      });
-      Object.defineProperty(this, "metaMessages", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: undefined
-      });
-      Object.defineProperty(this, "shortMessage", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: undefined
-      });
-      Object.defineProperty(this, "version", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: undefined
-      });
-      Object.defineProperty(this, "name", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: "BaseError"
-      });
-      this.details = details;
-      this.docsPath = docsPath;
-      this.metaMessages = args.metaMessages;
-      this.name = args.name ?? this.name;
-      this.shortMessage = shortMessage;
-      this.version = version;
-    }
-    walk(fn) {
-      return walk(this, fn);
-    }
-  };
-});
-
-// ../../node_modules/viem/_esm/errors/encoding.js
-var IntegerOutOfRangeError, SizeOverflowError;
-var init_encoding = __esm(() => {
-  init_base();
-  IntegerOutOfRangeError = class IntegerOutOfRangeError extends BaseError {
-    constructor({ max, min, signed, size, value }) {
-      super(`Number "${value}" is not in safe ${size ? `${size * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
-    }
-  };
-  SizeOverflowError = class SizeOverflowError extends BaseError {
-    constructor({ givenSize, maxSize }) {
-      super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
-    }
-  };
-});
-
-// ../../node_modules/viem/_esm/errors/data.js
-var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
-var init_data = __esm(() => {
-  init_base();
-  SliceOffsetOutOfBoundsError = class SliceOffsetOutOfBoundsError extends BaseError {
-    constructor({ offset, position, size }) {
-      super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size}).`, { name: "SliceOffsetOutOfBoundsError" });
-    }
-  };
-  SizeExceedsPaddingSizeError = class SizeExceedsPaddingSizeError extends BaseError {
-    constructor({ size, targetSize, type }) {
-      super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
-    }
-  };
-});
-
-// ../../node_modules/viem/_esm/utils/data/pad.js
-function pad(hexOrBytes, { dir, size = 32 } = {}) {
-  if (typeof hexOrBytes === "string")
-    return padHex(hexOrBytes, { dir, size });
-  return padBytes(hexOrBytes, { dir, size });
-}
-function padHex(hex_, { dir, size = 32 } = {}) {
-  if (size === null)
-    return hex_;
-  const hex = hex_.replace("0x", "");
-  if (hex.length > size * 2)
-    throw new SizeExceedsPaddingSizeError({
-      size: Math.ceil(hex.length / 2),
-      targetSize: size,
-      type: "hex"
-    });
-  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size * 2, "0")}`;
-}
-function padBytes(bytes, { dir, size = 32 } = {}) {
-  if (size === null)
-    return bytes;
-  if (bytes.length > size)
-    throw new SizeExceedsPaddingSizeError({
-      size: bytes.length,
-      targetSize: size,
-      type: "bytes"
-    });
-  const paddedBytes = new Uint8Array(size);
-  for (let i = 0;i < size; i++) {
-    const padEnd = dir === "right";
-    paddedBytes[padEnd ? i : size - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
-  }
-  return paddedBytes;
-}
-var init_pad = __esm(() => {
-  init_data();
-});
-
-// ../../node_modules/viem/_esm/utils/data/isHex.js
-function isHex(value, { strict = true } = {}) {
-  if (!value)
-    return false;
-  if (typeof value !== "string")
-    return false;
-  return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
-}
-
-// ../../node_modules/viem/_esm/utils/data/size.js
-function size(value) {
-  if (isHex(value, { strict: false }))
-    return Math.ceil((value.length - 2) / 2);
-  return value.length;
-}
-var init_size = () => {};
-
-// ../../node_modules/viem/_esm/utils/data/trim.js
-function trim(hexOrBytes, { dir = "left" } = {}) {
-  let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
-  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);
-  if (typeof hexOrBytes === "string") {
-    if (data.length === 1 && dir === "right")
-      data = `${data}0`;
-    return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
-  }
-  return data;
-}
-
-// ../../node_modules/viem/_esm/utils/encoding/toBytes.js
-function toBytes2(value, opts = {}) {
-  if (typeof value === "number" || typeof value === "bigint")
-    return numberToBytes(value, opts);
-  if (typeof value === "boolean")
-    return boolToBytes(value, opts);
-  if (isHex(value))
-    return hexToBytes2(value, opts);
-  return stringToBytes(value, opts);
-}
-function boolToBytes(value, opts = {}) {
-  const bytes = new Uint8Array(1);
-  bytes[0] = Number(value);
-  if (typeof opts.size === "number") {
-    assertSize(bytes, { size: opts.size });
-    return pad(bytes, { size: opts.size });
-  }
-  return bytes;
-}
-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 hexToBytes2(hex_, opts = {}) {
-  let hex = hex_;
-  if (opts.size) {
-    assertSize(hex, { size: opts.size });
-    hex = pad(hex, { dir: "right", size: opts.size });
-  }
-  let hexString = hex.slice(2);
-  if (hexString.length % 2)
-    hexString = `0${hexString}`;
-  const length = hexString.length / 2;
-  const bytes = new Uint8Array(length);
-  for (let index = 0, j = 0;index < length; index++) {
-    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
-    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
-    if (nibbleLeft === undefined || nibbleRight === undefined) {
-      throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
-    }
-    bytes[index] = nibbleLeft * 16 + nibbleRight;
-  }
-  return bytes;
-}
-function numberToBytes(value, opts) {
-  const hex = numberToHex(value, opts);
-  return hexToBytes2(hex);
-}
-function stringToBytes(value, opts = {}) {
-  const bytes = encoder.encode(value);
-  if (typeof opts.size === "number") {
-    assertSize(bytes, { size: opts.size });
-    return pad(bytes, { dir: "right", size: opts.size });
-  }
-  return bytes;
-}
-var encoder, charCodeMap;
-var init_toBytes = __esm(() => {
-  init_base();
-  init_pad();
-  init_fromHex();
-  init_toHex();
-  encoder = /* @__PURE__ */ new TextEncoder;
-  charCodeMap = {
-    zero: 48,
-    nine: 57,
-    A: 65,
-    F: 70,
-    a: 97,
-    f: 102
-  };
-});
-
-// ../../node_modules/viem/_esm/utils/encoding/fromHex.js
-function assertSize(hexOrBytes, { size: size2 }) {
-  if (size(hexOrBytes) > size2)
-    throw new SizeOverflowError({
-      givenSize: size(hexOrBytes),
-      maxSize: size2
-    });
-}
-function hexToBigInt(hex, opts = {}) {
-  const { signed } = opts;
-  if (opts.size)
-    assertSize(hex, { size: opts.size });
-  const value = BigInt(hex);
-  if (!signed)
-    return value;
-  const size2 = (hex.length - 2) / 2;
-  const max = (1n << BigInt(size2) * 8n - 1n) - 1n;
-  if (value <= max)
-    return value;
-  return value - BigInt(`0x${"f".padStart(size2 * 2, "f")}`) - 1n;
-}
-function hexToNumber2(hex, opts = {}) {
-  return Number(hexToBigInt(hex, opts));
-}
-var init_fromHex = __esm(() => {
-  init_encoding();
-  init_size();
-});
-
-// ../../node_modules/viem/_esm/utils/encoding/toHex.js
-function toHex(value, opts = {}) {
-  if (typeof value === "number" || typeof value === "bigint")
-    return numberToHex(value, opts);
-  if (typeof value === "string") {
-    return stringToHex(value, opts);
-  }
-  if (typeof value === "boolean")
-    return boolToHex(value, opts);
-  return bytesToHex2(value, opts);
-}
-function boolToHex(value, opts = {}) {
-  const hex = `0x${Number(value)}`;
-  if (typeof opts.size === "number") {
-    assertSize(hex, { size: opts.size });
-    return pad(hex, { size: opts.size });
-  }
-  return hex;
-}
-function bytesToHex2(value, opts = {}) {
-  let string = "";
-  for (let i = 0;i < value.length; i++) {
-    string += hexes2[value[i]];
-  }
-  const hex = `0x${string}`;
-  if (typeof opts.size === "number") {
-    assertSize(hex, { size: opts.size });
-    return pad(hex, { dir: "right", size: opts.size });
-  }
-  return hex;
-}
-function numberToHex(value_, opts = {}) {
-  const { signed, size: size2 } = opts;
-  const value = BigInt(value_);
-  let maxValue;
-  if (size2) {
-    if (signed)
-      maxValue = (1n << BigInt(size2) * 8n - 1n) - 1n;
-    else
-      maxValue = 2n ** (BigInt(size2) * 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: size2,
-      value: `${value_}${suffix}`
-    });
-  }
-  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size2 * 8)) + BigInt(value) : value).toString(16)}`;
-  if (size2)
-    return pad(hex, { size: size2 });
-  return hex;
-}
-function stringToHex(value_, opts = {}) {
-  const value = encoder2.encode(value_);
-  return bytesToHex2(value, opts);
-}
-var hexes2, encoder2;
-var init_toHex = __esm(() => {
-  init_encoding();
-  init_pad();
-  init_fromHex();
-  hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
-  encoder2 = /* @__PURE__ */ new TextEncoder;
-});
-
 // ../../node_modules/viem/_esm/errors/address.js
 var InvalidAddressError;
 var init_address = __esm(() => {
@@ -2719,40 +2753,6 @@ var init_address = __esm(() => {
   };
 });
 
-// ../../node_modules/viem/_esm/utils/lru.js
-var LruMap;
-var init_lru = __esm(() => {
-  LruMap = class LruMap extends Map {
-    constructor(size2) {
-      super();
-      Object.defineProperty(this, "maxSize", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: undefined
-      });
-      this.maxSize = size2;
-    }
-    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/@noble/hashes/esm/sha3.js
 function keccakP(s, rounds = 24) {
   const B = new Uint32Array(5 * 2);
@@ -3839,9 +3839,9 @@ function encodeBytes(value, { param }) {
       encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
     };
   }
-  if (bytesSize !== Number.parseInt(paramSize))
+  if (bytesSize !== Number.parseInt(paramSize, 10))
     throw new AbiEncodingBytesSizeMismatchError({
-      expectedSize: Number.parseInt(paramSize),
+      expectedSize: Number.parseInt(paramSize, 10),
       value
     });
   return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
@@ -30602,6 +30602,24 @@ var import_dstack_sdk = __toESM(require_dist(), 1);
 import { logger, Service } from "@elizaos/core";
 import { z } from "zod";
 
+// ../../node_modules/viem/_esm/utils/signature/serializeSignature.js
+init_secp256k1();
+init_fromHex();
+init_toBytes();
+function serializeSignature({ r, s, to = "hex", v, yParity }) {
+  const yParity_ = (() => {
+    if (yParity === 0 || yParity === 1)
+      return yParity;
+    if (v && (v === 27n || v === 28n || v >= 35n))
+      return v % 2n === 0n ? 1 : 0;
+    throw new Error("Invalid `v` or `yParity` value");
+  })();
+  const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
+  if (to === "hex")
+    return signature;
+  return hexToBytes(signature);
+}
+
 // ../../node_modules/viem/_esm/accounts/privateKeyToAccount.js
 init_secp256k1();
 init_toHex();
@@ -30643,30 +30661,14 @@ function publicKeyToAddress(publicKey) {
 
 // ../../node_modules/viem/_esm/accounts/utils/sign.js
 init_secp256k1();
-init_toHex();
-
-// ../../node_modules/viem/_esm/utils/signature/serializeSignature.js
-init_secp256k1();
-init_fromHex();
 init_toBytes();
-function serializeSignature({ r, s, to = "hex", v, yParity }) {
-  const yParity_ = (() => {
-    if (yParity === 0 || yParity === 1)
-      return yParity;
-    if (v && (v === 27n || v === 28n || v >= 35n))
-      return v % 2n === 0n ? 1 : 0;
-    throw new Error("Invalid `v` or `yParity` value");
-  })();
-  const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
-  if (to === "hex")
-    return signature;
-  return hexToBytes2(signature);
-}
-
-// ../../node_modules/viem/_esm/accounts/utils/sign.js
+init_toHex();
 var extraEntropy = false;
 async function sign({ hash, privateKey, to = "object" }) {
-  const { r, s, recovery } = secp256k1.sign(hash.slice(2), privateKey.slice(2), { lowS: true, extraEntropy });
+  const { r, s, recovery } = secp256k1.sign(hash.slice(2), privateKey.slice(2), {
+    lowS: true,
+    extraEntropy: isHex(extraEntropy, { strict: false }) ? hexToBytes(extraEntropy) : extraEntropy
+  });
   const signature = {
     r: numberToHex(r, { size: 32 }),
     s: numberToHex(s, { size: 32 }),
@@ -30694,7 +30696,7 @@ function toRlp(bytes, to = "hex") {
   const cursor = createCursor(new Uint8Array(encodable.length));
   encodable.encode(cursor);
   if (to === "hex")
-    return bytesToHex2(cursor.bytes);
+    return bytesToHex(cursor.bytes);
   return cursor.bytes;
 }
 function getEncodable(bytes) {
@@ -30733,7 +30735,7 @@ function getEncodableList(list) {
   };
 }
 function getEncodableBytes(bytesOrHex) {
-  const bytes = typeof bytesOrHex === "string" ? hexToBytes2(bytesOrHex) : bytesOrHex;
+  const bytes = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
   const sizeOfBytesLength = getSizeOfLength(bytes.length);
   const length = (() => {
     if (bytes.length === 1 && bytes[0] < 128)
@@ -30791,7 +30793,7 @@ function hashAuthorization(parameters) {
     ])
   ]));
   if (to === "bytes")
-    return hexToBytes2(hash);
+    return hexToBytes(hash);
   return hash;
 }
 
@@ -30830,7 +30832,7 @@ function toPrefixedMessage(message_) {
       return stringToHex(message_);
     if (typeof message_.raw === "string")
       return message_.raw;
-    return bytesToHex2(message_.raw);
+    return bytesToHex(message_.raw);
   })();
   const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);
   return concat([prefix, message]);
@@ -30877,11 +30879,11 @@ init_toHex();
 function blobsToCommitments(parameters) {
   const { kzg } = parameters;
   const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
-  const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes2(x)) : parameters.blobs;
+  const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
   const commitments = [];
   for (const blob of blobs)
     commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
-  return to === "bytes" ? commitments : commitments.map((x) => bytesToHex2(x));
+  return to === "bytes" ? commitments : commitments.map((x) => bytesToHex(x));
 }
 
 // ../../node_modules/viem/_esm/utils/blob/blobsToProofs.js
@@ -30890,15 +30892,15 @@ init_toHex();
 function blobsToProofs(parameters) {
   const { kzg } = parameters;
   const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
-  const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes2(x)) : parameters.blobs;
-  const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes2(x)) : parameters.commitments;
+  const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes(x)) : parameters.blobs;
+  const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes(x)) : parameters.commitments;
   const proofs = [];
   for (let i = 0;i < blobs.length; i++) {
     const blob = blobs[i];
     const commitment = commitments[i];
     proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
   }
-  return to === "bytes" ? proofs : proofs.map((x) => bytesToHex2(x));
+  return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
 }
 
 // ../../node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
@@ -30925,7 +30927,7 @@ function commitmentToVersionedHash(parameters) {
   const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
   const versionedHash = sha2563(commitment, "bytes");
   versionedHash.set([version2], 0);
-  return to === "bytes" ? versionedHash : bytesToHex2(versionedHash);
+  return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
 }
 
 // ../../node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
@@ -30999,7 +31001,7 @@ init_toBytes();
 init_toHex();
 function toBlobs(parameters) {
   const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
-  const data = typeof parameters.data === "string" ? hexToBytes2(parameters.data) : parameters.data;
+  const data = typeof parameters.data === "string" ? hexToBytes(parameters.data) : parameters.data;
   const size_ = size(data);
   if (!size_)
     throw new EmptyBlobError;
@@ -31028,7 +31030,7 @@ function toBlobs(parameters) {
     }
     blobs.push(blob);
   }
-  return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex2(x.bytes));
+  return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex(x.bytes));
 }
 
 // ../../node_modules/viem/_esm/utils/blob/toBlobSidecars.js
@@ -31081,7 +31083,7 @@ function assertTransactionEIP4844(transaction) {
       throw new EmptyBlobError;
     for (const hash of blobVersionedHashes) {
       const size_ = size(hash);
-      const version2 = hexToNumber2(slice(hash, 0, 1));
+      const version2 = hexToNumber(slice(hash, 0, 1));
       if (size_ !== 32)
         throw new InvalidVersionedHashSizeError({ hash, size: size_ });
       if (version2 !== versionedHashVersionKzg)
@@ -31191,13 +31193,13 @@ function serializeTransactionEIP7702(transaction, signature) {
   return concatHex([
     "0x04",
     toRlp([
-      toHex(chainId),
-      nonce ? toHex(nonce) : "0x",
-      maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
-      maxFeePerGas ? toHex(maxFeePerGas) : "0x",
-      gas ? toHex(gas) : "0x",
+      numberToHex(chainId),
+      nonce ? numberToHex(nonce) : "0x",
+      maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
+      maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
+      gas ? numberToHex(gas) : "0x",
       to ?? "0x",
-      value ? toHex(value) : "0x",
+      value ? numberToHex(value) : "0x",
       data ?? "0x",
       serializedAccessList,
       serializedAuthorizationList,
@@ -31211,7 +31213,7 @@ function serializeTransactionEIP4844(transaction, signature) {
   let blobVersionedHashes = transaction.blobVersionedHashes;
   let sidecars = transaction.sidecars;
   if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
-    const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex2(x));
+    const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex(x));
     const kzg = transaction.kzg;
     const commitments2 = blobsToCommitments({
       blobs: blobs2,
@@ -31228,16 +31230,16 @@ function serializeTransactionEIP4844(transaction, signature) {
   }
   const serializedAccessList = serializeAccessList(accessList);
   const serializedTransaction = [
-    toHex(chainId),
-    nonce ? toHex(nonce) : "0x",
-    maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
-    maxFeePerGas ? toHex(maxFeePerGas) : "0x",
-    gas ? toHex(gas) : "0x",
+    numberToHex(chainId),
+    nonce ? numberToHex(nonce) : "0x",
+    maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
+    maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
+    gas ? numberToHex(gas) : "0x",
     to ?? "0x",
-    value ? toHex(value) : "0x",
+    value ? numberToHex(value) : "0x",
     data ?? "0x",
     serializedAccessList,
-    maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : "0x",
+    maxFeePerBlobGas ? numberToHex(maxFeePerBlobGas) : "0x",
     blobVersionedHashes ?? [],
     ...toYParitySignatureArray(transaction, signature)
   ];
@@ -31261,13 +31263,13 @@ function serializeTransactionEIP1559(transaction, signature) {
   assertTransactionEIP1559(transaction);
   const serializedAccessList = serializeAccessList(accessList);
   const serializedTransaction = [
-    toHex(chainId),
-    nonce ? toHex(nonce) : "0x",
-    maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : "0x",
-    maxFeePerGas ? toHex(maxFeePerGas) : "0x",
-    gas ? toHex(gas) : "0x",
+    numberToHex(chainId),
+    nonce ? numberToHex(nonce) : "0x",
+    maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
+    maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
+    gas ? numberToHex(gas) : "0x",
     to ?? "0x",
-    value ? toHex(value) : "0x",
+    value ? numberToHex(value) : "0x",
     data ?? "0x",
     serializedAccessList,
     ...toYParitySignatureArray(transaction, signature)
@@ -31282,12 +31284,12 @@ function serializeTransactionEIP2930(transaction, signature) {
   assertTransactionEIP2930(transaction);
   const serializedAccessList = serializeAccessList(accessList);
   const serializedTransaction = [
-    toHex(chainId),
-    nonce ? toHex(nonce) : "0x",
-    gasPrice ? toHex(gasPrice) : "0x",
-    gas ? toHex(gas) : "0x",
+    numberToHex(chainId),
+    nonce ? numberToHex(nonce) : "0x",
+    gasPrice ? numberToHex(gasPrice) : "0x",
+    gas ? numberToHex(gas) : "0x",
     to ?? "0x",
-    value ? toHex(value) : "0x",
+    value ? numberToHex(value) : "0x",
     data ?? "0x",
     serializedAccessList,
     ...toYParitySignatureArray(transaction, signature)
@@ -31301,11 +31303,11 @@ function serializeTransactionLegacy(transaction, signature) {
   const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
   assertTransactionLegacy(transaction);
   let serializedTransaction = [
-    nonce ? toHex(nonce) : "0x",
-    gasPrice ? toHex(gasPrice) : "0x",
-    gas ? toHex(gas) : "0x",
+    nonce ? numberToHex(nonce) : "0x",
+    gasPrice ? numberToHex(gasPrice) : "0x",
+    gas ? numberToHex(gas) : "0x",
     to ?? "0x",
-    value ? toHex(value) : "0x",
+    value ? numberToHex(value) : "0x",
     data ?? "0x"
   ];
   if (signature) {
@@ -31327,14 +31329,14 @@ function serializeTransactionLegacy(transaction, signature) {
     const s = trim(signature.s);
     serializedTransaction = [
       ...serializedTransaction,
-      toHex(v),
+      numberToHex(v),
       r === "0x00" ? "0x" : r,
       s === "0x00" ? "0x" : s
     ];
   } else if (chainId > 0) {
     serializedTransaction = [
       ...serializedTransaction,
-      toHex(chainId),
+      numberToHex(chainId),
       "0x",
       "0x"
     ];
@@ -31354,12 +31356,12 @@ function toYParitySignatureArray(transaction, signature_) {
   const s = trim(signature.s);
   const yParity_ = (() => {
     if (typeof yParity === "number")
-      return yParity ? toHex(1) : "0x";
+      return yParity ? numberToHex(1) : "0x";
     if (v === 0n)
       return "0x";
     if (v === 1n)
-      return toHex(1);
-    return v === 27n ? "0x" : toHex(1);
+      return numberToHex(1);
+    return v === 27n ? "0x" : numberToHex(1);
   })();
   return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
 }
@@ -31376,10 +31378,10 @@ async function signTransaction(parameters) {
     return transaction;
   })();
   const signature = await sign({
-    hash: keccak256(serializer(signableTransaction)),
+    hash: keccak256(await serializer(signableTransaction)),
     privateKey
   });
-  return serializer(transaction, signature);
+  return await serializer(transaction, signature);
 }
 
 // ../../node_modules/viem/_esm/utils/signature/hashTypedData.js
@@ -31436,7 +31438,7 @@ function validateTypedData(parameters) {
         const [_type, base, size_] = integerMatch;
         numberToHex(value, {
           signed: base === "int",
-          size: Number.parseInt(size_) / 8
+          size: Number.parseInt(size_, 10) / 8
         });
       }
       if (type === "address" && typeof value === "string" && !isAddress(value))
@@ -31444,9 +31446,9 @@ function validateTypedData(parameters) {
       const bytesMatch = type.match(bytesRegex);
       if (bytesMatch) {
         const [_type, size_] = bytesMatch;
-        if (size_ && size(value) !== Number.parseInt(size_))
+        if (size_ && size(value) !== Number.parseInt(size_, 10))
           throw new BytesSizeMismatchError({
-            expectedSize: Number.parseInt(size_),
+            expectedSize: Number.parseInt(size_, 10),
             givenSize: size(value)
           });
       }
@@ -31579,11 +31581,8 @@ function encodeField({ types, name, type, value }) {
       keccak256(encodeData({ data: value, primaryType: type, types }))
     ];
   }
-  if (type === "bytes") {
-    const prepend = value.length % 2 ? "0" : "";
-    value = `0x${prepend + value.slice(2)}`;
+  if (type === "bytes")
     return [{ type: "bytes32" }, keccak256(value)];
-  }
   if (type === "string")
     return [{ type: "bytes32" }, keccak256(toHex(value))];
   if (type.lastIndexOf("]") === type.length - 1) {
@@ -33926,7 +33925,8 @@ var ConfirmedTransactionMetaResult = superstruct.type({
   preTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
   postTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
   loadedAddresses: superstruct.optional(LoadedAddressesResult),
-  computeUnitsConsumed: superstruct.optional(superstruct.number())
+  computeUnitsConsumed: superstruct.optional(superstruct.number()),
+  costUnits: superstruct.optional(superstruct.number())
 });
 var ParsedConfirmedTransactionMetaResult = superstruct.type({
   err: TransactionErrorResult,
@@ -33941,7 +33941,8 @@ var ParsedConfirmedTransactionMetaResult = superstruct.type({
   preTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
   postTokenBalances: superstruct.optional(superstruct.nullable(superstruct.array(TokenBalanceResult))),
   loadedAddresses: superstruct.optional(LoadedAddressesResult),
-  computeUnitsConsumed: superstruct.optional(superstruct.number())
+  computeUnitsConsumed: superstruct.optional(superstruct.number()),
+  costUnits: superstruct.optional(superstruct.number())
 });
 var TransactionVersionStruct = superstruct.union([superstruct.literal(0), superstruct.literal("legacy")]);
 var RewardsResult = superstruct.type({
@@ -35666,5 +35667,5 @@ export {
   StarterService
 };
 
-//# debugId=2092273E809F18B964756E2164756E21
+//# debugId=F087CF71CDF4560E64756E2164756E21
 //# sourceMappingURL=index.js.map