opencrowd 0.2.1 → 0.3.0

package/bundle/opencrowd.js

@@ -31,11 +31,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from14, except, desc) => {
-  if (from14 && typeof from14 === "object" || typeof from14 === "function") {
-    for (let key of __getOwnPropNames(from14))
+var __copyProps = (to, from16, except, desc) => {
+  if (from16 && typeof from16 === "object" || typeof from16 === "function") {
+    for (let key of __getOwnPropNames(from16))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from14[key], enumerable: !(desc = __getOwnPropDesc(from14, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from16[key], enumerable: !(desc = __getOwnPropDesc(from16, key)) || desc.enumerable });
   }
   return to;
 };
@@ -1683,10 +1683,10 @@ var init_gateway = __esm({
         if (this.options.approvalMode === "off") {
           return { ok: false, error: "financial actions are disabled (approval mode `off`)" };
         }
-        const from14 = stringArg(args.from);
+        const from16 = stringArg(args.from);
         const to = stringArg(args.to);
         const amountUsd = numberArg(args.amount_usd);
-        if (!from14 || !to || amountUsd === void 0 || amountUsd <= 0) {
+        if (!from16 || !to || amountUsd === void 0 || amountUsd <= 0) {
           return { ok: false, error: "bridge_usdc requires from, to, and a positive amount_usd" };
         }
         if (this.options.approvalMode === "ask") {
@@ -1694,7 +1694,7 @@ var init_gateway = __esm({
             return { ok: false, error: "bridging requires interactive approval and no prompt is available in this run mode" };
           }
           const answer = await this.options.approvalHandler({
-            endpoint: `bridge ${from14} -> ${to}`,
+            endpoint: `bridge ${from16} -> ${to}`,
             origin: "agentcash-bridge",
             method: "BRIDGE",
             quotedCostCents: Math.round(amountUsd * 100)
@@ -1703,11 +1703,11 @@ var init_gateway = __esm({
             return { ok: false, error: "the user declined the bridge" };
           }
         }
-        const result = await this.options.agentcash.bridge({ from: from14, to, amountUsd });
+        const result = await this.options.agentcash.bridge({ from: from16, to, amountUsd });
         await appendLedgerEntry(this.options.session.ledgerPath, {
           session_id: this.options.session.sessionId,
           type: "service_call",
-          resource_url: `agentcash:bridge:${from14}->${to}`,
+          resource_url: `agentcash:bridge:${from16}->${to}`,
           method: "BRIDGE",
           quoted_cost_cents: Math.round(amountUsd * 100),
           charged_cost_cents: 0,
@@ -3417,10 +3417,10 @@ var init_chunk_K4TZLEOT = __esm({
   }
 });
 
-// ../../node_modules/zod/v3/helpers/util.js
+// ../../node_modules/x402/node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType;
 var init_util = __esm({
-  "../../node_modules/zod/v3/helpers/util.js"() {
+  "../../node_modules/x402/node_modules/zod/v3/helpers/util.js"() {
     (function(util2) {
       util2.assertEqual = (_) => {
       };
@@ -3554,10 +3554,10 @@ var init_util = __esm({
   }
 });
 
-// ../../node_modules/zod/v3/ZodError.js
+// ../../node_modules/x402/node_modules/zod/v3/ZodError.js
 var ZodIssueCode, quotelessJson, ZodError;
 var init_ZodError = __esm({
-  "../../node_modules/zod/v3/ZodError.js"() {
+  "../../node_modules/x402/node_modules/zod/v3/ZodError.js"() {
     init_util();
     ZodIssueCode = util.arrayToEnum([
       "invalid_type",
@@ -3678,10 +3678,10 @@ var init_ZodError = __esm({
   }
 });
 
-// ../../node_modules/zod/v3/locales/en.js
+// ../../node_modules/x402/node_modules/zod/v3/locales/en.js
 var errorMap, en_default;
 var init_en = __esm({
-  "../../node_modules/zod/v3/locales/en.js"() {
+  "../../node_modules/x402/node_modules/zod/v3/locales/en.js"() {
     init_ZodError();
     init_util();
     errorMap = (issue, _ctx) => {
@@ -3788,7 +3788,7 @@ var init_en = __esm({
   }
 });
 
-// ../../node_modules/zod/v3/errors.js
+// ../../node_modules/x402/node_modules/zod/v3/errors.js
 function setErrorMap(map) {
   overrideErrorMap = map;
 }
@@ -3797,13 +3797,13 @@ function getErrorMap() {
 }
 var overrideErrorMap;
 var init_errors = __esm({
-  "../../node_modules/zod/v3/errors.js"() {
+  "../../node_modules/x402/node_modules/zod/v3/errors.js"() {
     init_en();
     overrideErrorMap = en_default;
   }
 });
 
-// ../../node_modules/zod/v3/helpers/parseUtil.js
+// ../../node_modules/x402/node_modules/zod/v3/helpers/parseUtil.js
 function addIssueToContext(ctx, issueData) {
   const overrideMap = getErrorMap();
   const issue = makeIssue({
@@ -3825,7 +3825,7 @@ function addIssueToContext(ctx, issueData) {
 }
 var makeIssue, EMPTY_PATH, ParseStatus, INVALID, DIRTY, OK, isAborted, isDirty, isValid, isAsync;
 var init_parseUtil = __esm({
-  "../../node_modules/zod/v3/helpers/parseUtil.js"() {
+  "../../node_modules/x402/node_modules/zod/v3/helpers/parseUtil.js"() {
     init_errors();
     init_en();
     makeIssue = (params) => {
@@ -3920,16 +3920,16 @@ var init_parseUtil = __esm({
   }
 });
 
-// ../../node_modules/zod/v3/helpers/typeAliases.js
+// ../../node_modules/x402/node_modules/zod/v3/helpers/typeAliases.js
 var init_typeAliases = __esm({
-  "../../node_modules/zod/v3/helpers/typeAliases.js"() {
+  "../../node_modules/x402/node_modules/zod/v3/helpers/typeAliases.js"() {
   }
 });
 
-// ../../node_modules/zod/v3/helpers/errorUtil.js
+// ../../node_modules/x402/node_modules/zod/v3/helpers/errorUtil.js
 var errorUtil;
 var init_errorUtil = __esm({
-  "../../node_modules/zod/v3/helpers/errorUtil.js"() {
+  "../../node_modules/x402/node_modules/zod/v3/helpers/errorUtil.js"() {
     (function(errorUtil2) {
       errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
       errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
@@ -3937,7 +3937,7 @@ var init_errorUtil = __esm({
   }
 });
 
-// ../../node_modules/zod/v3/types.js
+// ../../node_modules/x402/node_modules/zod/v3/types.js
 function processCreateParams(params) {
   if (!params)
     return {};
@@ -4131,7 +4131,7 @@ function custom(check, _params = {}, fatal) {
 }
 var ParseInputLazyPath, handleResult, ZodType, cuidRegex, cuid2Regex, ulidRegex, uuidRegex, nanoidRegex, jwtRegex, durationRegex, emailRegex, _emojiRegex, emojiRegex, ipv4Regex, ipv4CidrRegex, ipv6Regex, ipv6CidrRegex, base64Regex, base64urlRegex, dateRegexSource, dateRegex, ZodString, ZodNumber, ZodBigInt, ZodBoolean, ZodDate, ZodSymbol, ZodUndefined, ZodNull, ZodAny, ZodUnknown, ZodNever, ZodVoid, ZodArray, ZodObject, ZodUnion, getDiscriminator, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodMap, ZodSet, ZodFunction, ZodLazy, ZodLiteral, ZodEnum, ZodNativeEnum, ZodPromise, ZodEffects, ZodOptional, ZodNullable, ZodDefault, ZodCatch, ZodNaN, BRAND, ZodBranded, ZodPipeline, ZodReadonly, late, ZodFirstPartyTypeKind, instanceOfType, stringType, numberType, nanType, bigIntType, booleanType, dateType, symbolType, undefinedType, nullType, anyType, unknownType, neverType, voidType, arrayType, objectType, strictObjectType, unionType, discriminatedUnionType, intersectionType, tupleType, recordType, mapType, setType, functionType, lazyType, literalType, enumType, nativeEnumType, promiseType, effectsType, optionalType, nullableType, preprocessType, pipelineType, ostring, onumber, oboolean, coerce, NEVER;
 var init_types2 = __esm({
-  "../../node_modules/zod/v3/types.js"() {
+  "../../node_modules/x402/node_modules/zod/v3/types.js"() {
     init_ZodError();
     init_errors();
     init_errorUtil();
@@ -7393,7 +7393,7 @@ var init_types2 = __esm({
   }
 });
 
-// ../../node_modules/zod/v3/external.js
+// ../../node_modules/x402/node_modules/zod/v3/external.js
 var external_exports = {};
 __export(external_exports, {
   BRAND: () => BRAND,
@@ -7505,7 +7505,7 @@ __export(external_exports, {
   void: () => voidType
 });
 var init_external = __esm({
-  "../../node_modules/zod/v3/external.js"() {
+  "../../node_modules/x402/node_modules/zod/v3/external.js"() {
     init_errors();
     init_parseUtil();
     init_typeAliases();
@@ -7515,9 +7515,9 @@ var init_external = __esm({
   }
 });
 
-// ../../node_modules/zod/index.js
+// ../../node_modules/x402/node_modules/zod/index.js
 var init_zod = __esm({
-  "../../node_modules/zod/index.js"() {
+  "../../node_modules/x402/node_modules/zod/index.js"() {
     init_external();
     init_external();
   }
@@ -8517,7 +8517,7 @@ var init_size = __esm({
 var version2;
 var init_version2 = __esm({
   "../../node_modules/viem/_esm/errors/version.js"() {
-    version2 = "2.51.3";
+    version2 = "2.55.19";
   }
 });
 
@@ -9930,10 +9930,7 @@ function encodeAbiParameters(params, values) {
     params,
     values
   });
-  const data = encodeParams(preparedParams);
-  if (data.length === 0)
-    return "0x";
-  return data;
+  return encodeParams(preparedParams);
 }
 function prepareParams({ params, values }) {
   const preparedParams = [];
@@ -9999,7 +9996,7 @@ function encodeParams(preparedParams) {
       staticParams.push(encoded);
     }
   }
-  return concat([...staticParams, ...dynamicParams]);
+  return concatHex([...staticParams, ...dynamicParams]);
 }
 function encodeAddress(value) {
   if (!isAddress(value))
@@ -10016,7 +10013,7 @@ function encodeArray(value, { length, param }) {
       givenLength: value.length,
       type: `${param.type}[${length}]`
     });
-  let dynamicChild = false;
+  let dynamicChild = value.length === 0 && isDynamicType(param);
   const preparedParams = [];
   for (let i = 0; i < value.length; i++) {
     const preparedParam = prepareParam({ param, value: value[i] });
@@ -10030,7 +10027,7 @@ function encodeArray(value, { length, param }) {
       const length2 = numberToHex(preparedParams.length, { size: 32 });
       return {
         dynamic: true,
-        encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
+        encoded: concatHex([length2, data])
       };
     }
     if (dynamicChild)
@@ -10038,7 +10035,7 @@ function encodeArray(value, { length, param }) {
   }
   return {
     dynamic: false,
-    encoded: concat(preparedParams.map(({ encoded }) => encoded))
+    encoded: concatHex(preparedParams.map(({ encoded }) => encoded))
   };
 }
 function encodeBytes(value, { param }) {
@@ -10053,7 +10050,10 @@ function encodeBytes(value, { param }) {
       });
     return {
       dynamic: true,
-      encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
+      encoded: concatHex([
+        padHex(numberToHex(bytesSize, { size: 32 })),
+        value_
+      ])
     };
   }
   if (bytesSize !== Number.parseInt(paramSize, 10))
@@ -10100,7 +10100,7 @@ function encodeString(value) {
   }
   return {
     dynamic: true,
-    encoded: concat([
+    encoded: concatHex([
       padHex(numberToHex(size(hexValue), { size: 32 })),
       ...parts
     ])
@@ -10122,7 +10122,7 @@ function encodeTuple(value, { param }) {
   }
   return {
     dynamic,
-    encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
+    encoded: dynamic ? encodeParams(preparedParams) : concatHex(preparedParams.map(({ encoded }) => encoded))
   };
 }
 function getArrayComponents(type) {
@@ -10132,6 +10132,21 @@ function getArrayComponents(type) {
     [matches[2] ? Number(matches[2]) : null, matches[1]]
   ) : void 0;
 }
+function isDynamicType(param) {
+  const { type } = param;
+  if (type === "string")
+    return true;
+  if (type === "bytes")
+    return true;
+  if (type.endsWith("[]"))
+    return true;
+  if (type === "tuple")
+    return param.components.some(isDynamicType);
+  const arrayComponents = getArrayComponents(type);
+  if (arrayComponents)
+    return isDynamicType({ ...param, type: arrayComponents[1] });
+  return false;
+}
 var init_encodeAbiParameters = __esm({
   "../../node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
     init_abi();
@@ -10692,7 +10707,7 @@ var init_cursor2 = __esm({
 function bytesToBigInt(bytes, opts = {}) {
   if (typeof opts.size !== "undefined")
     assertSize(bytes, { size: opts.size });
-  const hex = bytesToHex(bytes, opts);
+  const hex = bytesToHex(bytes);
   return hexToBigInt(hex, opts);
 }
 function bytesToBool(bytes_, opts = {}) {
@@ -10708,7 +10723,7 @@ function bytesToBool(bytes_, opts = {}) {
 function bytesToNumber(bytes, opts = {}) {
   if (typeof opts.size !== "undefined")
     assertSize(bytes, { size: opts.size });
-  const hex = bytesToHex(bytes, opts);
+  const hex = bytesToHex(bytes);
   return hexToNumber(hex, opts);
 }
 function bytesToString(bytes_, opts = {}) {
@@ -10744,7 +10759,8 @@ function decodeAbiParameters(params, data) {
   const values = [];
   for (let i = 0; i < params.length; ++i) {
     const param = params[i];
-    cursor.setPosition(consumed);
+    if (consumed < bytes.length)
+      cursor.setPosition(consumed);
     const [data2, consumed_] = decodeParameter(cursor, param, {
       staticPosition: 0
     });
@@ -10780,7 +10796,7 @@ function decodeAddress(cursor) {
   return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
 }
 function decodeArray(cursor, param, { length, staticPosition }) {
-  if (!length) {
+  if (length === null) {
     const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
     const start = staticPosition + offset;
     const startOfData = start + sizeOfLength;
@@ -10796,6 +10812,10 @@ function decodeArray(cursor, param, { length, staticPosition }) {
       });
       consumed2 += consumed_;
       value2.push(data);
+      if (consumed_ === 0) {
+        cursor.assertReadLimit();
+        cursor._touch();
+      }
     }
     cursor.setPosition(staticPosition + 32);
     return [value2, 32];
@@ -10822,6 +10842,10 @@ function decodeArray(cursor, param, { length, staticPosition }) {
     });
     consumed += consumed_;
     value.push(data);
+    if (consumed_ === 0) {
+      cursor.assertReadLimit();
+      cursor._touch();
+    }
   }
   return [value, consumed];
 }
@@ -10893,7 +10917,7 @@ function decodeString(cursor, { staticPosition }) {
     return ["", 32];
   }
   const data = cursor.readBytes(length, 32);
-  const value = bytesToString(trim(data));
+  const value = bytesToString(data);
   cursor.setPosition(staticPosition + 32);
   return [value, 32];
 }
@@ -10920,7 +10944,6 @@ var init_decodeAbiParameters = __esm({
     init_cursor2();
     init_size();
     init_slice();
-    init_trim();
     init_fromBytes();
     init_toBytes();
     init_toHex();
@@ -10987,23 +11010,10 @@ var init_formatAbiItemWithArgs = __esm({
   }
 });
 
-// ../../node_modules/viem/_esm/constants/unit.js
-var etherUnits, gweiUnits;
-var init_unit = __esm({
-  "../../node_modules/viem/_esm/constants/unit.js"() {
-    etherUnits = {
-      gwei: 9,
-      wei: 18
-    };
-    gweiUnits = {
-      ether: -9,
-      wei: 9
-    };
-  }
-});
-
-// ../../node_modules/viem/_esm/utils/unit/formatUnits.js
-function formatUnits(value, decimals) {
+// ../../node_modules/viem/_esm/utils/unit/Value.js
+function format(value, decimals = 0) {
+  if (!Number.isInteger(decimals) || decimals < 0)
+    throw new InvalidDecimalsError({ decimals });
   let display = value.toString();
   const negative = display.startsWith("-");
   if (negative)
@@ -11016,30 +11026,113 @@ function formatUnits(value, decimals) {
   fraction = fraction.replace(/(0+)$/, "");
   return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
 }
-var init_formatUnits = __esm({
-  "../../node_modules/viem/_esm/utils/unit/formatUnits.js"() {
+function formatEther(wei, unit = "wei") {
+  return format(wei, exponents.ether - exponents[unit]);
+}
+function formatGwei(wei, unit = "wei") {
+  return format(wei, exponents.gwei - exponents[unit]);
+}
+function from(value, decimals = 0) {
+  if (!Number.isInteger(decimals) || decimals < 0)
+    throw new InvalidDecimalsError({ decimals });
+  if (!/^-?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)$/.test(value))
+    throw new InvalidDecimalNumberError({ value });
+  let [integer = "", fraction = "0"] = value.split(".");
+  const negative = integer.startsWith("-");
+  if (negative)
+    integer = integer.slice(1);
+  if (integer === "")
+    integer = "0";
+  fraction = fraction.replace(/(0+)$/, "");
+  if (decimals === 0) {
+    if (fraction.length > 0 && Number.parseInt(fraction[0], 10) >= 5)
+      integer = `${BigInt(integer) + 1n}`;
+    fraction = "";
+  } else if (fraction.length > decimals) {
+    const left = fraction.slice(0, decimals);
+    const roundDigit = Number.parseInt(fraction.slice(decimals, decimals + 1), 10);
+    if (roundDigit >= 5) {
+      const carried = carry(left);
+      if (carried.length > decimals) {
+        fraction = carried.slice(1);
+        integer = `${BigInt(integer) + 1n}`;
+      } else {
+        fraction = carried;
+      }
+    } else {
+      fraction = left;
+    }
+  } else {
+    fraction = fraction.padEnd(decimals, "0");
+  }
+  return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
+}
+function carry(digits) {
+  const out = digits.split("");
+  let i = out.length - 1;
+  while (i >= 0) {
+    const d = Number.parseInt(out[i], 10) + 1;
+    if (d < 10) {
+      out[i] = String(d);
+      return out.join("");
+    }
+    out[i] = "0";
+    i--;
+  }
+  return `1${out.join("")}`;
+}
+var exponents, InvalidDecimalNumberError, InvalidDecimalsError;
+var init_Value = __esm({
+  "../../node_modules/viem/_esm/utils/unit/Value.js"() {
+    exponents = {
+      wei: 0,
+      gwei: 9,
+      szabo: 12,
+      finney: 15,
+      ether: 18
+    };
+    InvalidDecimalNumberError = class extends Error {
+      constructor({ value }) {
+        super(`Value \`${value}\` is not a valid decimal number.`);
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "Value.InvalidDecimalNumberError"
+        });
+      }
+    };
+    InvalidDecimalsError = class extends Error {
+      constructor({ decimals }) {
+        super(`\`decimals\` must be a non-negative integer. Got \`${decimals}\`.`);
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "Value.InvalidDecimalsError"
+        });
+      }
+    };
   }
 });
 
 // ../../node_modules/viem/_esm/utils/unit/formatEther.js
-function formatEther(wei, unit = "wei") {
-  return formatUnits(wei, etherUnits[unit]);
+function formatEther2(wei, unit = "wei") {
+  return formatEther(wei, unit);
 }
 var init_formatEther = __esm({
   "../../node_modules/viem/_esm/utils/unit/formatEther.js"() {
-    init_unit();
-    init_formatUnits();
+    init_Value();
   }
 });
 
 // ../../node_modules/viem/_esm/utils/unit/formatGwei.js
-function formatGwei(wei, unit = "wei") {
-  return formatUnits(wei, gweiUnits[unit]);
+function formatGwei2(wei, unit = "wei") {
+  return formatGwei(wei, unit);
 }
 var init_formatGwei = __esm({
   "../../node_modules/viem/_esm/utils/unit/formatGwei.js"() {
-    init_unit();
-    init_formatUnits();
+    init_Value();
   }
 });
 
@@ -11105,12 +11198,23 @@ function prettyPrint(args) {
   const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
   return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
 }
-var InvalidLegacyVError, InvalidSerializableTransactionError, InvalidStorageKeySizeError, TransactionExecutionError, TransactionNotFoundError, TransactionReceiptNotFoundError, TransactionReceiptRevertedError, WaitForTransactionReceiptTimeoutError;
+var FeePayerNonceMismatchError, InvalidLegacyVError, InvalidSerializableTransactionError, InvalidStorageKeySizeError, TransactionExecutionError, TransactionNotFoundError, TransactionReceiptNotFoundError, TransactionReceiptRevertedError, WaitForTransactionReceiptTimeoutError;
 var init_transaction = __esm({
   "../../node_modules/viem/_esm/errors/transaction.js"() {
     init_formatEther();
     init_formatGwei();
     init_base();
+    FeePayerNonceMismatchError = class extends BaseError2 {
+      constructor({ filledNonce, requestedNonce }) {
+        super("The filled transaction nonce does not match the requested nonce.", {
+          metaMessages: [
+            `Requested Nonce: ${requestedNonce}`,
+            `Filled Nonce: ${filledNonce}`
+          ],
+          name: "FeePayerNonceMismatchError"
+        });
+      }
+    };
     InvalidLegacyVError = class extends BaseError2 {
       constructor({ v }) {
         super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
@@ -11150,12 +11254,12 @@ var init_transaction = __esm({
           chain: chain2 && `${chain2?.name} (id: ${chain2?.id})`,
           from: account?.address,
           to,
-          value: typeof value !== "undefined" && `${formatEther(value)} ${chain2?.nativeCurrency?.symbol || "ETH"}`,
+          value: typeof value !== "undefined" && `${formatEther2(value)} ${chain2?.nativeCurrency?.symbol || "ETH"}`,
           data,
           gas,
-          gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
-          maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
-          maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
+          gasPrice: typeof gasPrice !== "undefined" && `${formatGwei2(gasPrice)} gwei`,
+          maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei2(maxFeePerGas)} gwei`,
+          maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei2(maxPriorityFeePerGas)} gwei`,
           nonce
         });
         super(cause.shortMessage, {
@@ -11284,12 +11388,12 @@ var init_contract = __esm({
         let prettyArgs = prettyPrint({
           from: account?.address,
           to,
-          value: typeof value !== "undefined" && `${formatEther(value)} ${chain2?.nativeCurrency?.symbol || "ETH"}`,
+          value: typeof value !== "undefined" && `${formatEther2(value)} ${chain2?.nativeCurrency?.symbol || "ETH"}`,
           data,
           gas,
-          gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
-          maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
-          maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
+          gasPrice: typeof gasPrice !== "undefined" && `${formatGwei2(gasPrice)} gwei`,
+          maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei2(maxFeePerGas)} gwei`,
+          maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei2(maxPriorityFeePerGas)} gwei`,
           nonce
         });
         if (stateOverride) {
@@ -11519,7 +11623,7 @@ ${prettyStateOverride(stateOverride)}`;
 });
 
 // ../../node_modules/viem/_esm/errors/request.js
-var HttpRequestError, RpcRequestError, TimeoutError;
+var HttpRequestError, ResponseBodyTooLargeError, RpcRequestError, TimeoutError;
 var init_request = __esm({
   "../../node_modules/viem/_esm/errors/request.js"() {
     init_stringify();
@@ -11567,6 +11671,28 @@ var init_request = __esm({
         this.url = url;
       }
     };
+    ResponseBodyTooLargeError = class extends BaseError2 {
+      constructor({ maxSize, size: size5 }) {
+        super("HTTP response body exceeded the size limit.", {
+          metaMessages: [`Max: ${maxSize} bytes`, `Received: ${size5} bytes`],
+          name: "ResponseBodyTooLargeError"
+        });
+        Object.defineProperty(this, "maxSize", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "size", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        this.maxSize = maxSize;
+        this.size = size5;
+      }
+    };
     RpcRequestError = class extends BaseError2 {
       constructor({ body, error, url }) {
         super("RPC Request failed.", {
@@ -13730,7 +13856,7 @@ function weierstrass(curveDef) {
   function normalizeS(s3) {
     return isBiggerThanHalfOrder(s3) ? modN2(-s3) : s3;
   }
-  const slcNum = (b, from14, to) => bytesToNumberBE(b.slice(from14, to));
+  const slcNum = (b, from16, to) => bytesToNumberBE(b.slice(from16, to));
   class Signature {
     constructor(r, s3, recovery) {
       aInRange("r", r, _1n5, CURVE_ORDER);
@@ -13933,14 +14059,14 @@ function weierstrass(curveDef) {
     const sg = signature;
     msgHash = ensureBytes("msgHash", msgHash);
     publicKey = ensureBytes("publicKey", publicKey);
-    const { lowS, prehash, format } = opts;
+    const { lowS, prehash, format: format2 } = opts;
     validateSigVerOpts(opts);
     if ("strict" in opts)
       throw new Error("options.strict was renamed to lowS");
-    if (format !== void 0 && format !== "compact" && format !== "der")
+    if (format2 !== void 0 && format2 !== "compact" && format2 !== "der")
       throw new Error("format must be compact or der");
     const isHex2 = typeof sg === "string" || isBytes2(sg);
-    const isObj = !isHex2 && !format && typeof sg === "object" && sg !== null && typeof sg.r === "bigint" && typeof sg.s === "bigint";
+    const isObj = !isHex2 && !format2 && 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 = void 0;
@@ -13950,13 +14076,13 @@ function weierstrass(curveDef) {
         _sig = new Signature(sg.r, sg.s);
       if (isHex2) {
         try {
-          if (format !== "compact")
+          if (format2 !== "compact")
             _sig = Signature.fromDER(sg);
         } catch (derError) {
           if (!(derError instanceof DER.Err))
             throw derError;
         }
-        if (!_sig && format !== "der")
+        if (!_sig && format2 !== "der")
           _sig = Signature.fromCompact(sg);
       }
       P2 = Point2.fromHex(publicKey);
@@ -14817,12 +14943,12 @@ var init_estimateGas = __esm({
         const prettyArgs = prettyPrint({
           from: account?.address,
           to,
-          value: typeof value !== "undefined" && `${formatEther(value)} ${chain2?.nativeCurrency?.symbol || "ETH"}`,
+          value: typeof value !== "undefined" && `${formatEther2(value)} ${chain2?.nativeCurrency?.symbol || "ETH"}`,
           data,
           gas,
-          gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
-          maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
-          maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
+          gasPrice: typeof gasPrice !== "undefined" && `${formatGwei2(gasPrice)} gwei`,
+          maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei2(maxFeePerGas)} gwei`,
+          maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei2(maxPriorityFeePerGas)} gwei`,
           nonce
         });
         super(cause.shortMessage, {
@@ -14876,7 +15002,7 @@ var init_node = __esm({
     });
     FeeCapTooHighError = class extends BaseError2 {
       constructor({ cause, maxFeePerGas } = {}) {
-        super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
+        super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei2(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
           cause,
           name: "FeeCapTooHighError"
         });
@@ -14890,7 +15016,7 @@ var init_node = __esm({
     });
     FeeCapTooLowError = class extends BaseError2 {
       constructor({ cause, maxFeePerGas } = {}) {
-        super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
+        super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei2(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
           cause,
           name: "FeeCapTooLowError"
         });
@@ -15009,7 +15135,7 @@ var init_node = __esm({
     TipAboveFeeCapError = class extends BaseError2 {
       constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
         super([
-          `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
+          `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei2(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei2(maxFeePerGas)} gwei` : ""}).`
         ].join("\n"), {
           cause,
           name: "TipAboveFeeCapError"
@@ -15110,8 +15236,8 @@ var init_getEstimateGasError = __esm({
 });
 
 // ../../node_modules/viem/_esm/utils/formatters/extract.js
-function extract(value_, { format }) {
-  if (!format)
+function extract(value_, { format: format2 }) {
+  if (!format2)
     return {};
   const value = {};
   function extract_(formatted2) {
@@ -15123,7 +15249,7 @@ function extract(value_, { format }) {
         extract_(formatted2[key]);
     }
   }
-  const formatted = format(value_ || {});
+  const formatted = format2(value_ || {});
   extract_(formatted);
   return value;
 }
@@ -15133,12 +15259,12 @@ var init_extract = __esm({
 });
 
 // ../../node_modules/viem/_esm/utils/formatters/formatter.js
-function defineFormatter(type, format) {
+function defineFormatter(type, format2) {
   return ({ exclude, format: overrides }) => {
     return {
       exclude,
       format: (args, action) => {
-        const formatted = format(args, action);
+        const formatted = format2(args, action);
         if (exclude) {
           for (const key of exclude) {
             delete formatted[key];
@@ -15436,7 +15562,7 @@ var init_fee = __esm({
     };
     MaxFeePerGasTooLowError = class extends BaseError2 {
       constructor({ maxPriorityFeePerGas }) {
-        super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
+        super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei2(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
       }
     };
   }
@@ -15592,8 +15718,8 @@ async function getBlock(client, { blockHash, blockNumber, blockTag = client.expe
   }
   if (!block)
     throw new BlockNotFoundError({ blockHash, blockNumber });
-  const format = client.chain?.formatters?.block?.format || formatBlock;
-  return format(block, "getBlock");
+  const format2 = client.chain?.formatters?.block?.format || formatBlock;
+  return format2(block, "getBlock");
 }
 var init_getBlock = __esm({
   "../../node_modules/viem/_esm/actions/public/getBlock.js"() {
@@ -15682,7 +15808,7 @@ async function internal_estimateFeesPerGas(client, args) {
     throw new BaseFeeScalarError();
   const decimals = baseFeeMultiplier.toString().split(".")[1]?.length ?? 0;
   const denominator = 10 ** decimals;
-  const multiply = (base2) => base2 * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
+  const multiply = (base2) => base2 * BigInt(Math.round(baseFeeMultiplier * denominator)) / BigInt(denominator);
   const block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
   if (typeof chain2?.fees?.estimateFeesPerGas === "function") {
     const fees = await chain2.fees.estimateFeesPerGas({
@@ -16074,8 +16200,8 @@ async function fillTransaction(client, parameters) {
   })();
   assertRequest(parameters);
   const chainFormat = chain2?.formatters?.transactionRequest?.format;
-  const format = chainFormat || formatTransactionRequest;
-  const request = format({
+  const format2 = chainFormat || formatTransactionRequest;
+  const request = format2({
     // Pick out extra data that might exist on the chain's transaction request type.
     ...extract(rest, { format: chainFormat }),
     account: account ? parseAccount(account) : void 0,
@@ -16099,8 +16225,8 @@ async function fillTransaction(client, parameters) {
       method: "eth_fillTransaction",
       params: [request]
     });
-    const format2 = chain2?.formatters?.transaction?.format || formatTransaction;
-    const transaction = format2(response.tx);
+    const format3 = chain2?.formatters?.transaction?.format || formatTransaction;
+    const transaction = format3(response.tx);
     delete transaction.blockHash;
     delete transaction.blockNumber;
     delete transaction.r;
@@ -16109,35 +16235,41 @@ async function fillTransaction(client, parameters) {
     delete transaction.v;
     delete transaction.yParity;
     transaction.data = transaction.input;
-    if (transaction.gas)
-      transaction.gas = parameters.gas ?? transaction.gas;
-    if (transaction.gasPrice)
-      transaction.gasPrice = parameters.gasPrice ?? transaction.gasPrice;
-    if (transaction.maxFeePerBlobGas)
-      transaction.maxFeePerBlobGas = parameters.maxFeePerBlobGas ?? transaction.maxFeePerBlobGas;
-    if (transaction.maxFeePerGas)
-      transaction.maxFeePerGas = parameters.maxFeePerGas ?? transaction.maxFeePerGas;
-    if (transaction.maxPriorityFeePerGas)
-      transaction.maxPriorityFeePerGas = parameters.maxPriorityFeePerGas ?? transaction.maxPriorityFeePerGas;
-    if (typeof transaction.nonce !== "undefined")
-      transaction.nonce = parameters.nonce ?? transaction.nonce;
-    const feeMultiplier = await (async () => {
-      if (typeof chain2?.fees?.baseFeeMultiplier === "function") {
-        const block = await getAction(client, getBlock, "getBlock")({});
-        return chain2.fees.baseFeeMultiplier({
-          block,
-          client,
-          request: parameters
-        });
-      }
-      return chain2?.fees?.baseFeeMultiplier ?? 1.2;
-    })();
-    if (feeMultiplier < 1)
-      throw new BaseFeeScalarError();
-    const decimals = feeMultiplier.toString().split(".")[1]?.length ?? 0;
-    const denominator = 10 ** decimals;
-    const multiplyFee = (base2) => base2 * BigInt(Math.ceil(feeMultiplier * denominator)) / BigInt(denominator);
-    if (!transaction.feePayerSignature) {
+    const hasFeePayerSignature = typeof transaction.feePayerSignature !== "undefined" && transaction.feePayerSignature !== null;
+    if (hasFeePayerSignature && typeof nonce !== "undefined" && transaction.nonce !== nonce)
+      throw new FeePayerNonceMismatchError({
+        filledNonce: transaction.nonce,
+        requestedNonce: nonce
+      });
+    if (!hasFeePayerSignature) {
+      if (transaction.gas)
+        transaction.gas = parameters.gas ?? transaction.gas;
+      if (transaction.gasPrice)
+        transaction.gasPrice = parameters.gasPrice ?? transaction.gasPrice;
+      if (transaction.maxFeePerBlobGas)
+        transaction.maxFeePerBlobGas = parameters.maxFeePerBlobGas ?? transaction.maxFeePerBlobGas;
+      if (transaction.maxFeePerGas)
+        transaction.maxFeePerGas = parameters.maxFeePerGas ?? transaction.maxFeePerGas;
+      if (transaction.maxPriorityFeePerGas)
+        transaction.maxPriorityFeePerGas = parameters.maxPriorityFeePerGas ?? transaction.maxPriorityFeePerGas;
+      if (typeof transaction.nonce !== "undefined")
+        transaction.nonce = parameters.nonce ?? transaction.nonce;
+      const feeMultiplier = await (async () => {
+        if (typeof chain2?.fees?.baseFeeMultiplier === "function") {
+          const block = await getAction(client, getBlock, "getBlock")({});
+          return chain2.fees.baseFeeMultiplier({
+            block,
+            client,
+            request: parameters
+          });
+        }
+        return chain2?.fees?.baseFeeMultiplier ?? 1.2;
+      })();
+      if (feeMultiplier < 1)
+        throw new BaseFeeScalarError();
+      const decimals = feeMultiplier.toString().split(".")[1]?.length ?? 0;
+      const denominator = 10 ** decimals;
+      const multiplyFee = (base2) => base2 * BigInt(Math.round(feeMultiplier * denominator)) / BigInt(denominator);
       if (transaction.maxFeePerGas && !parameters.maxFeePerGas)
         transaction.maxFeePerGas = multiplyFee(transaction.maxFeePerGas);
       if (transaction.gasPrice && !parameters.gasPrice)
@@ -16162,6 +16294,7 @@ var init_fillTransaction = __esm({
   "../../node_modules/viem/_esm/actions/public/fillTransaction.js"() {
     init_parseAccount();
     init_fee();
+    init_transaction();
     init_getTransactionError();
     init_extract();
     init_transaction2();
@@ -16204,8 +16337,17 @@ async function prepareTransactionRequest(client, args) {
     chainId = chainId_;
     return chainId;
   }
-  const account = account_ ? parseAccount(account_) : account_;
+  let account = account_ ? parseAccount(account_) : account_;
   let nonce = request.nonce;
+  if (prepareTransactionRequest2?.fn && prepareTransactionRequest2.runAt?.includes("beforeFillTransaction")) {
+    request = await prepareTransactionRequest2.fn({ ...request, chain: chain2 }, {
+      client,
+      phase: "beforeFillTransaction"
+    });
+    nonce ??= request.nonce;
+    const sender = request.account ?? request.from;
+    account = sender ? parseAccount(sender) : void 0;
+  }
   if (parameters.includes("nonce") && typeof nonce === "undefined" && account && nonceManager) {
     const chainId2 = await getChainId2();
     nonce = await nonceManager.consume({
@@ -16214,16 +16356,11 @@ async function prepareTransactionRequest(client, args) {
       client
     });
   }
-  if (prepareTransactionRequest2?.fn && prepareTransactionRequest2.runAt?.includes("beforeFillTransaction")) {
-    request = await prepareTransactionRequest2.fn({ ...request, chain: chain2 }, {
-      client,
-      phase: "beforeFillTransaction"
-    });
-    nonce ??= request.nonce;
-  }
   const attemptFill = (() => {
     if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && request.kzg && request.blobs)
       return false;
+    if (parameters.length > 0 && "feePayer" in request && request.feePayer && !("feePayerSignature" in request && request.feePayerSignature))
+      return true;
     if (supportsFillTransaction.get(client.uid) === false)
       return false;
     const shouldAttempt = ["fees", "gas"].some((parameter) => parameters.includes(parameter));
@@ -16240,11 +16377,14 @@ async function prepareTransactionRequest(client, args) {
     return false;
   })();
   const fillResult = attemptFill ? await getAction(client, fillTransaction, "fillTransaction")({ ...request, nonce }).then((result) => {
-    const { chainId: chainId2, from: from14, gas: gas2, gasPrice, nonce: nonce2, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, type: type2, ...rest } = result.transaction;
+    const { chainId: chainId2, from: from16, gas: gas2, gasPrice, nonce: nonce2, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, type: type2, ...rest } = result.transaction;
+    const feeToken = "feeToken" in rest ? rest.feeToken : void 0;
+    const hasFilledFeePayerSignature = "feePayerSignature" in rest && rest.feePayerSignature !== null && typeof rest.feePayerSignature !== "undefined";
+    const shouldUseFilledFeeToken = typeof feeToken !== "undefined" && feeToken !== null && (!("feeToken" in request) || hasFilledFeePayerSignature);
     supportsFillTransaction.set(client.uid, true);
     return {
       ...request,
-      ...from14 ? { from: from14 } : {},
+      ...from16 ? { from: from16 } : {},
       ...type2 && !request.type ? { type: type2 } : {},
       ...typeof chainId2 !== "undefined" ? { chainId: chainId2 } : {},
       ...typeof gas2 !== "undefined" ? { gas: gas2 } : {},
@@ -16256,13 +16396,16 @@ async function prepareTransactionRequest(client, args) {
       ..."nonceKey" in rest && typeof rest.nonceKey !== "undefined" ? { nonceKey: rest.nonceKey } : {},
       ..."keyAuthorization" in rest && typeof rest.keyAuthorization !== "undefined" && rest.keyAuthorization !== null && !("keyAuthorization" in request) ? { keyAuthorization: rest.keyAuthorization } : {},
       ..."feePayerSignature" in rest && typeof rest.feePayerSignature !== "undefined" && rest.feePayerSignature !== null ? { feePayerSignature: rest.feePayerSignature } : {},
-      ..."feeToken" in rest && typeof rest.feeToken !== "undefined" && rest.feeToken !== null && !("feeToken" in request) ? { feeToken: rest.feeToken } : {},
+      ...shouldUseFilledFeeToken ? { feeToken } : {},
       ...result.capabilities ? { _capabilities: result.capabilities } : {}
     };
   }).catch((e6) => {
     const error = e6;
     if (error.name !== "TransactionExecutionError")
       return request;
+    const nonceMismatch = error.walk?.((error2) => error2 instanceof FeePayerNonceMismatchError);
+    if (nonceMismatch)
+      throw e6;
     const executionReverted = error.walk?.((e7) => {
       const error2 = e7;
       return error2.name === "ExecutionRevertedError";
@@ -16392,6 +16535,7 @@ var init_prepareTransactionRequest = __esm({
     init_getBlock();
     init_getTransactionCount();
     init_fee();
+    init_transaction();
     init_blobsToCommitments();
     init_blobsToProofs();
     init_commitmentsToVersionedHashes();
@@ -16450,8 +16594,8 @@ async function estimateGas(client, args) {
     const rpcStateOverride = serializeStateOverride(stateOverride);
     assertRequest(args);
     const chainFormat = client.chain?.formatters?.transactionRequest?.format;
-    const format = chainFormat || formatTransactionRequest;
-    const request = format({
+    const format2 = chainFormat || formatTransactionRequest;
+    const request = format2({
       // Pick out extra data that might exist on the chain's transaction request type.
       ...extract(rest, { format: chainFormat }),
       account,
@@ -17437,7 +17581,7 @@ function assert(value) {
   if (value.BYTES_PER_ELEMENT !== 1 || value.constructor.name !== "Uint8Array")
     throw new InvalidBytesTypeError(value);
 }
-function from(value) {
+function from2(value) {
   if (value instanceof Uint8Array)
     return value;
   if (typeof value === "string")
@@ -17631,7 +17775,7 @@ function assert2(value, options = {}) {
 function concat2(...values) {
   return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
 }
-function from2(value) {
+function from3(value) {
   if (value instanceof Uint8Array)
     return fromBytes(value);
   if (Array.isArray(value))
@@ -17873,7 +18017,7 @@ var init_BlockOverrides = __esm({
 });
 
 // ../../node_modules/viem/_esm/constants/abis.js
-var multicall3Abi, batchGatewayAbi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, erc1271Abi, erc6492SignatureValidatorAbi;
+var multicall3Abi, batchGatewayAbi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, erc1271Abi, erc6492SignatureValidatorAbi, erc20Abi;
 var init_abis = __esm({
   "../../node_modules/viem/_esm/constants/abis.js"() {
     multicall3Abi = [
@@ -18227,6 +18371,194 @@ var init_abis = __esm({
         name: "isValidSig"
       }
     ];
+    erc20Abi = [
+      {
+        type: "event",
+        name: "Approval",
+        inputs: [
+          {
+            indexed: true,
+            name: "owner",
+            type: "address"
+          },
+          {
+            indexed: true,
+            name: "spender",
+            type: "address"
+          },
+          {
+            indexed: false,
+            name: "value",
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "event",
+        name: "Transfer",
+        inputs: [
+          {
+            indexed: true,
+            name: "from",
+            type: "address"
+          },
+          {
+            indexed: true,
+            name: "to",
+            type: "address"
+          },
+          {
+            indexed: false,
+            name: "value",
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "allowance",
+        stateMutability: "view",
+        inputs: [
+          {
+            name: "owner",
+            type: "address"
+          },
+          {
+            name: "spender",
+            type: "address"
+          }
+        ],
+        outputs: [
+          {
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "approve",
+        stateMutability: "nonpayable",
+        inputs: [
+          {
+            name: "spender",
+            type: "address"
+          },
+          {
+            name: "amount",
+            type: "uint256"
+          }
+        ],
+        outputs: [
+          {
+            type: "bool"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "balanceOf",
+        stateMutability: "view",
+        inputs: [
+          {
+            name: "account",
+            type: "address"
+          }
+        ],
+        outputs: [
+          {
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "decimals",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+          {
+            type: "uint8"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "name",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+          {
+            type: "string"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "symbol",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+          {
+            type: "string"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "totalSupply",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+          {
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "transfer",
+        stateMutability: "nonpayable",
+        inputs: [
+          {
+            name: "recipient",
+            type: "address"
+          },
+          {
+            name: "amount",
+            type: "uint256"
+          }
+        ],
+        outputs: [
+          {
+            type: "bool"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "transferFrom",
+        stateMutability: "nonpayable",
+        inputs: [
+          {
+            name: "sender",
+            type: "address"
+          },
+          {
+            name: "recipient",
+            type: "address"
+          },
+          {
+            name: "amount",
+            type: "uint256"
+          }
+        ],
+        outputs: [
+          {
+            type: "bool"
+          }
+        ]
+      }
+    ];
   }
 });
 
@@ -18820,8 +19152,8 @@ async function call(client, args) {
     const rpcBlockOverrides = blockOverrides ? toRpc2(blockOverrides) : void 0;
     const rpcStateOverride = serializeStateOverride(stateOverride);
     const chainFormat = client.chain?.formatters?.transactionRequest?.format;
-    const format = chainFormat || formatTransactionRequest;
-    const request = format({
+    const format2 = chainFormat || formatTransactionRequest;
+    const request = format2({
       // Pick out extra data that might exist on the chain's transaction request type.
       ...extract(rest, { format: chainFormat }),
       accessList,
@@ -19640,8 +19972,8 @@ async function sendTransaction(client, parameters) {
           });
       }
       const chainFormat = client.chain?.formatters?.transactionRequest?.format;
-      const format = chainFormat || formatTransactionRequest;
-      const request = format({
+      const format2 = chainFormat || formatTransactionRequest;
+      const request = format2({
         // Pick out extra data that might exist on the chain's transaction request type.
         ...extract(rest, { format: chainFormat }),
         accessList,
@@ -19691,17 +20023,29 @@ async function sendTransaction(client, parameters) {
       }
     }
     if (account?.type === "local") {
-      if (account.nonceManager && typeof nonce === "undefined") {
-        const requestChainId = rest.chainId;
-        const chainId = await (async () => {
-          if (typeof requestChainId === "number")
-            return requestChainId;
-          if (chain2)
-            return chain2.id;
-          return getAction(client, getChainId, "getChainId")({});
-        })();
-        nonceManagerParameters = { address: account.address, chainId };
-      }
+      const nonceManager = (() => {
+        if (!account.nonceManager || typeof nonce !== "undefined")
+          return account.nonceManager;
+        const nonceManager2 = account.nonceManager;
+        return {
+          consume(parameters2) {
+            nonceManagerParameters = {
+              address: parameters2.address,
+              chainId: parameters2.chainId
+            };
+            return nonceManager2.consume(parameters2);
+          },
+          get(parameters2) {
+            return nonceManager2.get(parameters2);
+          },
+          increment(parameters2) {
+            return nonceManager2.increment(parameters2);
+          },
+          reset(parameters2) {
+            return nonceManager2.reset(parameters2);
+          }
+        };
+      })();
       const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
         account,
         accessList,
@@ -19715,7 +20059,7 @@ async function sendTransaction(client, parameters) {
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce,
-        nonceManager: account.nonceManager,
+        nonceManager,
         parameters: [...defaultParameters, "sidecars"],
         type,
         value,
@@ -19864,7 +20208,7 @@ function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shoul
             return;
           }
         }
-        attemptRetry({ count: count + 1 });
+        return attemptRetry({ count: count + 1 });
       };
       try {
         const data = await fn();
@@ -19883,7 +20227,7 @@ function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shoul
         reject(err);
       }
     };
-    attemptRetry();
+    void attemptRetry().catch(reject);
   });
 }
 var init_withRetry = __esm({
@@ -20225,7 +20569,7 @@ var init_uid = __esm({
 
 // ../../node_modules/viem/_esm/clients/createClient.js
 function createClient(parameters) {
-  const { batch, chain: chain2, ccipRead, dataSuffix, key = "base", name = "Base Client", type = "base" } = parameters;
+  const { batch, chain: chain2, ccipRead, dataSuffix, key = "base", name = "Base Client", tokens, type = "base" } = parameters;
   const experimental_blockTag = parameters.experimental_blockTag ?? (typeof chain2?.experimental_preconfirmationTime === "number" ? "pending" : void 0);
   const blockTime = chain2?.blockTime ?? 12e3;
   const defaultPollingInterval = Math.min(Math.max(Math.floor(blockTime / 2), 500), 4e3);
@@ -20249,6 +20593,7 @@ function createClient(parameters) {
     name,
     pollingInterval,
     request,
+    tokens,
     transport,
     type,
     uid: uid(),
@@ -20260,11 +20605,48 @@ function createClient(parameters) {
       for (const key2 in client)
         delete extended[key2];
       const combined = { ...base2, ...extended };
+      for (const key2 in extended) {
+        const a = base2[key2];
+        const b = extended[key2];
+        if (isPlainObject(a) && isPlainObject(b))
+          combined[key2] = { ...a, ...b };
+      }
       return Object.assign(combined, { extend: extend(combined) });
     };
   }
   return Object.assign(client, { extend: extend(client) });
 }
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function bindActionDecorators(client, action) {
+  const wrapped = (parameters = {}) => action(client, parameters);
+  for (const key of [
+    "call",
+    "calls",
+    "callWithPeriod",
+    "estimateGas",
+    "prepare",
+    "prepareRecipient",
+    "predict",
+    "simulate"
+  ])
+    if (Object.hasOwn(action, key)) {
+      const helper = action[key];
+      wrapped[key] = (args = {}) => {
+        if (helper.length === 1)
+          return helper(args);
+        return helper(client, args);
+      };
+    }
+  for (const key of ["extractEvent", "extractEvents"])
+    if (Object.hasOwn(action, key))
+      wrapped[key] = action[key];
+  return wrapped;
+}
 var init_createClient = __esm({
   "../../node_modules/viem/_esm/clients/createClient.js"() {
     init_parseAccount();
@@ -20944,8 +21326,8 @@ async function createAccessList(client, args) {
     const blockNumberHex = typeof blockNumber === "bigint" ? numberToHex(blockNumber) : void 0;
     const block = blockNumberHex || blockTag;
     const chainFormat = client.chain?.formatters?.transactionRequest?.format;
-    const format = chainFormat || formatTransactionRequest;
-    const request = format({
+    const format2 = chainFormat || formatTransactionRequest;
+    const request = format2({
       // Pick out extra data that might exist on the chain's transaction request type.
       ...extract(rest, { format: chainFormat }),
       account,
@@ -21137,8 +21519,8 @@ async function getBlockReceipts(client, { blockHash, blockNumber, blockTag = cli
   }, { dedupe: Boolean(blockHash || blockNumberHex) });
   if (!receipts)
     throw new BlockNotFoundError({ blockHash, blockNumber });
-  const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
-  return receipts.map((receipt) => format(receipt, "getBlockReceipts"));
+  const format2 = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
+  return receipts.map((receipt) => format2(receipt, "getBlockReceipts"));
 }
 var init_getBlockReceipts = __esm({
   "../../node_modules/viem/_esm/actions/public/getBlockReceipts.js"() {
@@ -22017,7 +22399,7 @@ function getHttpRpcClient(url_, options = {}) {
   const { url, headers: headers_url } = parseUrl(url_);
   return {
     async request(params) {
-      const { body, fetchFn = options.fetchFn ?? fetch, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
+      const { body, fetchFn = options.fetchFn ?? fetch, maxResponseBodySize = options.maxResponseBodySize ?? defaultMaxResponseBodySize, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
       const fetchOptions = {
         ...options.fetchOptions ?? {},
         ...params.fetchOptions ?? {}
@@ -22056,10 +22438,13 @@ function getHttpRpcClient(url_, options = {}) {
         if (onResponse)
           await onResponse(response);
         let data;
+        const responseBody = await readResponseBody(response, {
+          maxResponseBodySize
+        });
         if (response.headers.get("Content-Type")?.startsWith("application/json"))
-          data = await response.json();
+          data = JSON.parse(responseBody);
         else {
-          data = await response.text();
+          data = responseBody;
           try {
             data = JSON.parse(data || "{}");
           } catch (err) {
@@ -22087,6 +22472,8 @@ function getHttpRpcClient(url_, options = {}) {
           throw err;
         if (err instanceof HttpRequestError)
           throw err;
+        if (err instanceof ResponseBodyTooLargeError)
+          throw err;
         if (err instanceof TimeoutError)
           throw err;
         throw new HttpRequestError({
@@ -22098,6 +22485,53 @@ function getHttpRpcClient(url_, options = {}) {
     }
   };
 }
+async function readResponseBody(response, { maxResponseBodySize }) {
+  if (maxResponseBodySize === false)
+    return response.text();
+  const contentLength = response.headers.get("Content-Length");
+  if (contentLength) {
+    const size6 = Number(contentLength);
+    if (size6 > maxResponseBodySize)
+      throw new ResponseBodyTooLargeError({
+        maxSize: maxResponseBodySize,
+        size: size6
+      });
+  }
+  if (!response.body) {
+    const body2 = await response.text();
+    const size6 = new TextEncoder().encode(body2).length;
+    if (size6 > maxResponseBodySize)
+      throw new ResponseBodyTooLargeError({
+        maxSize: maxResponseBodySize,
+        size: size6
+      });
+    return body2;
+  }
+  const reader = response.body.getReader();
+  const decoder2 = new TextDecoder();
+  let body = "";
+  let size5 = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      size5 += value.byteLength;
+      if (size5 > maxResponseBodySize) {
+        await reader.cancel();
+        throw new ResponseBodyTooLargeError({
+          maxSize: maxResponseBodySize,
+          size: size5
+        });
+      }
+      body += decoder2.decode(value, { stream: true });
+    }
+    body += decoder2.decode();
+    return body;
+  } finally {
+    reader.releaseLock();
+  }
+}
 function parseUrl(url_) {
   try {
     const url = new URL(url_);
@@ -22118,6 +22552,7 @@ function parseUrl(url_) {
     return { url: url_ };
   }
 }
+var defaultMaxResponseBodySize;
 var init_http = __esm({
   "../../node_modules/viem/_esm/utils/rpc/http.js"() {
     init_request();
@@ -22125,6 +22560,7 @@ var init_http = __esm({
     init_withTimeout();
     init_stringify();
     init_id();
+    defaultMaxResponseBodySize = 10485760;
   }
 });
 
@@ -22169,7 +22605,7 @@ var init_hashMessage = __esm({
 });
 
 // ../../node_modules/viem/_esm/errors/typedData.js
-var InvalidDomainError, InvalidPrimaryTypeError, InvalidStructTypeError;
+var InvalidDomainError, InvalidPrimaryTypeError, InvalidStructTypeError, InvalidTypedDataTypeError;
 var init_typedData = __esm({
   "../../node_modules/viem/_esm/errors/typedData.js"() {
     init_stringify();
@@ -22197,6 +22633,15 @@ var init_typedData = __esm({
         });
       }
     };
+    InvalidTypedDataTypeError = class extends BaseError2 {
+      constructor({ type }) {
+        const canonicalType = type.replace(/^(u?int)/, "$&256");
+        super(`Type "${type}" is not a valid EIP-712 type.`, {
+          metaMessages: [`Use "${canonicalType}" instead.`],
+          name: "InvalidTypedDataTypeError"
+        });
+      }
+    };
   }
 });
 
@@ -22232,6 +22677,9 @@ function validateTypedData(parameters) {
     for (const param of struct) {
       const { name, type } = param;
       const value = data[name];
+      const baseType = type.replace(/(\[[0-9]*\])+$/, "");
+      if (baseType === "int" || baseType === "uint")
+        throw new InvalidTypedDataTypeError({ type });
       const integerMatch = type.match(integerRegex2);
       if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
         const [_type, base2, size_] = integerMatch;
@@ -23162,7 +23610,7 @@ var init_sha22 = __esm({
 // ../../node_modules/ox/_esm/core/Hash.js
 function keccak2562(value, options = {}) {
   const { as = typeof value === "string" ? "Hex" : "Bytes" } = options;
-  const bytes = keccak_2562(from(value));
+  const bytes = keccak_2562(from2(value));
   if (as === "Bytes")
     return bytes;
   return fromBytes(bytes);
@@ -23197,7 +23645,7 @@ function assert3(publicKey, options = {}) {
   }
   throw new InvalidError({ publicKey });
 }
-function from3(value) {
+function from4(value) {
   const publicKey = (() => {
     if (validate2(value))
       return fromHex2(value);
@@ -23319,7 +23767,7 @@ var init_PublicKey = __esm({
         super(`Value \`${publicKey}\` is an invalid public key size.`, {
           metaMessages: [
             "Expected: 33 bytes (compressed + prefix), 64 bytes (uncompressed) or 65 bytes (uncompressed + prefix).",
-            `Received ${size3(from2(publicKey))} bytes.`
+            `Received ${size3(from3(publicKey))} bytes.`
           ]
         });
         Object.defineProperty(this, "name", {
@@ -23370,7 +23818,7 @@ function checksum2(address2) {
   checksum.set(address2, result);
   return result;
 }
-function from4(address2, options = {}) {
+function from5(address2, options = {}) {
   const { checksum: checksumVal = false } = options;
   assert4(address2);
   if (checksumVal)
@@ -23379,7 +23827,7 @@ function from4(address2, options = {}) {
 }
 function fromPublicKey(publicKey, options = {}) {
   const address2 = keccak2562(`0x${toHex2(publicKey).slice(4)}`).substring(26);
-  return from4(`0x${address2}`, options);
+  return from5(`0x${address2}`, options);
 }
 function validate3(address2, options = {}) {
   const { strict = true } = options ?? {};
@@ -23576,7 +24024,7 @@ function decodeAddress3(cursor, options = {}) {
 }
 function decodeArray2(cursor, param, options) {
   const { checksumAddress: checksumAddress2, length, staticPosition } = options;
-  if (!length) {
+  if (length === null) {
     const offset = toNumber2(cursor.readBytes(sizeOfOffset2));
     const start = staticPosition + offset;
     const startOfData = start + sizeOfLength2;
@@ -23593,6 +24041,10 @@ function decodeArray2(cursor, param, options) {
       });
       consumed2 += consumed_;
       value2.push(data);
+      if (consumed_ === 0) {
+        cursor.assertReadLimit();
+        cursor._touch();
+      }
     }
     cursor.setPosition(staticPosition + 32);
     return [value2, 32];
@@ -23621,6 +24073,10 @@ function decodeArray2(cursor, param, options) {
     });
     consumed += consumed_;
     value.push(data);
+    if (consumed_ === 0) {
+      cursor.assertReadLimit();
+      cursor._touch();
+    }
   }
   return [value, consumed];
 }
@@ -23797,7 +24253,7 @@ function encodeArray2(value, options) {
       givenLength: value.length,
       type: `${parameter.type}[${length}]`
     });
-  let dynamicChild = false;
+  let dynamicChild = value.length === 0 && hasDynamicChild2(parameter);
   const preparedParameters = [];
   for (let i = 0; i < value.length; i++) {
     const preparedParam = prepareParameter({
@@ -24168,7 +24624,8 @@ function decode(parameters, data, options = {}) {
   const values = as === "Array" ? [] : {};
   for (let i = 0; i < parameters.length; ++i) {
     const param = parameters[i];
-    cursor.setPosition(consumed);
+    if (consumed < bytes.length)
+      cursor.setPosition(consumed);
     const [data2, consumed_] = decodeParameter2(cursor, param, {
       checksumAddress: checksumAddress2,
       staticPosition: 0
@@ -24212,7 +24669,7 @@ function encodePacked(types, values) {
   }
   return concat2(...data);
 }
-function from5(parameters) {
+function from6(parameters) {
   if (Array.isArray(parameters) && typeof parameters[0] === "string")
     return parseAbiParameters(parameters);
   if (typeof parameters === "string")
@@ -24367,7 +24824,7 @@ var init_AbiParameters = __esm({
 });
 
 // ../../node_modules/ox/_esm/core/Rlp.js
-function from6(value, options) {
+function from7(value, options) {
   const { as } = options;
   const encodable = getEncodable2(value);
   const cursor = create(new Uint8Array(encodable.length));
@@ -24378,7 +24835,7 @@ function from6(value, options) {
 }
 function fromHex3(hex, options = {}) {
   const { as = "Hex" } = options;
-  return from6(hex, { as });
+  return from7(hex, { as });
 }
 function getEncodable2(bytes) {
   if (Array.isArray(bytes))
@@ -25504,7 +25961,7 @@ function weierstrass2(curveDef) {
   function normalizeS(s3) {
     return isBiggerThanHalfOrder(s3) ? modN2(-s3) : s3;
   }
-  const slcNum = (b, from14, to) => bytesToNumberBE2(b.slice(from14, to));
+  const slcNum = (b, from16, to) => bytesToNumberBE2(b.slice(from16, to));
   class Signature {
     constructor(r, s3, recovery) {
       aInRange2("r", r, _1n11, CURVE_ORDER);
@@ -25707,14 +26164,14 @@ function weierstrass2(curveDef) {
     const sg = signature;
     msgHash = ensureBytes2("msgHash", msgHash);
     publicKey = ensureBytes2("publicKey", publicKey);
-    const { lowS, prehash, format } = opts;
+    const { lowS, prehash, format: format2 } = opts;
     validateSigVerOpts2(opts);
     if ("strict" in opts)
       throw new Error("options.strict was renamed to lowS");
-    if (format !== void 0 && format !== "compact" && format !== "der")
+    if (format2 !== void 0 && format2 !== "compact" && format2 !== "der")
       throw new Error("format must be compact or der");
     const isHex2 = typeof sg === "string" || isBytes3(sg);
-    const isObj = !isHex2 && !format && typeof sg === "object" && sg !== null && typeof sg.r === "bigint" && typeof sg.s === "bigint";
+    const isObj = !isHex2 && !format2 && 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 = void 0;
@@ -25724,13 +26181,13 @@ function weierstrass2(curveDef) {
         _sig = new Signature(sg.r, sg.s);
       if (isHex2) {
         try {
-          if (format !== "compact")
+          if (format2 !== "compact")
             _sig = Signature.fromDER(sg);
         } catch (derError) {
           if (!(derError instanceof DER2.Err))
             throw derError;
         }
-        if (!_sig && format !== "der")
+        if (!_sig && format2 !== "der")
           _sig = Signature.fromCompact(sg);
       }
       P2 = Point2.fromHex(publicKey);
@@ -26030,9 +26487,9 @@ function extract2(value) {
     return void 0;
   if (typeof value.s === "undefined")
     return void 0;
-  return from7(value);
+  return from8(value);
 }
-function from7(signature) {
+function from8(signature) {
   const signature_ = (() => {
     if (typeof signature === "string")
       return fromHex4(signature);
@@ -26103,7 +26560,7 @@ var init_Signature = __esm({
         super(`Value \`${signature}\` is an invalid signature size.`, {
           metaMessages: [
             "Expected: 64 bytes or 65 bytes.",
-            `Received ${size3(from2(signature))} bytes.`
+            `Received ${size3(from3(signature))} bytes.`
           ]
         });
         Object.defineProperty(this, "name", {
@@ -26173,7 +26630,7 @@ var init_Signature = __esm({
 });
 
 // ../../node_modules/ox/_esm/core/Authorization.js
-function from8(authorization, options = {}) {
+function from9(authorization, options = {}) {
   if (typeof authorization.chainId === "string")
     return fromRpc3(authorization);
   return { ...authorization, ...options.signature };
@@ -26226,8 +26683,8 @@ function recoverPublicKey2(options) {
   const { payload, signature } = options;
   const { r, s: s3, yParity } = signature;
   const signature_ = new secp256k12.Signature(BigInt(r), BigInt(s3)).addRecoveryBit(yParity);
-  const point = signature_.recoverPublicKey(from2(payload).substring(2));
-  return from3(point);
+  const point = signature_.recoverPublicKey(from3(payload).substring(2));
+  return from4(point);
 }
 var init_Secp256k1 = __esm({
   "../../node_modules/ox/_esm/core/Secp256k1.js"() {
@@ -26243,7 +26700,7 @@ var SignatureErc8010_exports = {};
 __export(SignatureErc8010_exports, {
   InvalidWrappedSignatureError: () => InvalidWrappedSignatureError,
   assert: () => assert6,
-  from: () => from9,
+  from: () => from10,
   magicBytes: () => magicBytes,
   suffixParameters: () => suffixParameters,
   unwrap: () => unwrap,
@@ -26257,7 +26714,7 @@ function assert6(value) {
   } else
     assert5(value.authorization);
 }
-function from9(value) {
+function from10(value) {
   if (typeof value === "string")
     return unwrap(value);
   return value;
@@ -26268,7 +26725,7 @@ function unwrap(wrapped) {
   const suffix = slice3(wrapped, -suffixLength - 64, -64);
   const signature = slice3(wrapped, 0, -suffixLength - 64);
   const [auth, to, data] = decode(suffixParameters, suffix);
-  const authorization = from8({
+  const authorization = from9({
     address: auth.delegation,
     chainId: Number(auth.chainId),
     nonce: auth.nonce,
@@ -26287,7 +26744,7 @@ function wrap(value) {
   assert6(value);
   const self = recoverAddress2({
     payload: getSignPayload(value.authorization),
-    signature: from7(value.authorization)
+    signature: from8(value.authorization)
   });
   const suffix = encode2(suffixParameters, [
     {
@@ -26319,7 +26776,7 @@ var init_SignatureErc8010 = __esm({
     init_Secp256k1();
     init_Signature();
     magicBytes = "0x8010801080108010801080108010801080108010801080108010801080108010";
-    suffixParameters = from5("(uint256 chainId, address delegation, uint256 nonce, uint8 yParity, uint256 r, uint256 s), address to, bytes data");
+    suffixParameters = from6("(uint256 chainId, address delegation, uint256 nonce, uint8 yParity, uint256 r, uint256 s), address to, bytes data");
     InvalidWrappedSignatureError = class extends BaseError3 {
       constructor(wrapped) {
         super(`Value \`${wrapped}\` is an invalid ERC-8010 wrapped signature.`);
@@ -26341,9 +26798,30 @@ var init_erc8010 = __esm({
   }
 });
 
+// ../../node_modules/viem/_esm/utils/unit/formatUnits.js
+function formatUnits(value, decimals) {
+  return format(value, decimals);
+}
+var init_formatUnits = __esm({
+  "../../node_modules/viem/_esm/utils/unit/formatUnits.js"() {
+    init_Value();
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/unit/parseUnits.js
+function parseUnits(value, decimals) {
+  return from(value, decimals);
+}
+var init_parseUnits = __esm({
+  "../../node_modules/viem/_esm/utils/unit/parseUnits.js"() {
+    init_Value();
+  }
+});
+
 // ../../node_modules/viem/_esm/utils/index.js
 var init_utils8 = __esm({
   "../../node_modules/viem/_esm/utils/index.js"() {
+    init_encodeFunctionData();
     init_fromHex();
   }
 });
@@ -26390,6 +26868,22 @@ var init_getProof = __esm({
   }
 });
 
+// ../../node_modules/viem/_esm/actions/public/getRawTransaction.js
+async function getRawTransaction(client, { hash: hash3 }) {
+  const rawTransaction = await client.request({
+    method: "eth_getRawTransactionByHash",
+    params: [hash3]
+  }, { dedupe: true });
+  if (!rawTransaction)
+    throw new TransactionNotFoundError({ hash: hash3 });
+  return rawTransaction;
+}
+var init_getRawTransaction = __esm({
+  "../../node_modules/viem/_esm/actions/public/getRawTransaction.js"() {
+    init_transaction();
+  }
+});
+
 // ../../node_modules/viem/_esm/actions/public/getStorageAt.js
 async function getStorageAt(client, { address: address2, blockHash, blockNumber, blockTag = "latest", requireCanonical, slot }) {
   const block = formatBlockParameter({
@@ -26444,8 +26938,8 @@ async function getTransaction(client, { blockHash, blockNumber, blockTag: blockT
       hash: hash3,
       index: index2
     });
-  const format = client.chain?.formatters?.transaction?.format || formatTransaction;
-  return format(transaction, "getTransaction");
+  const format2 = client.chain?.formatters?.transaction?.format || formatTransaction;
+  return format2(transaction, "getTransaction");
 }
 var init_getTransaction = __esm({
   "../../node_modules/viem/_esm/actions/public/getTransaction.js"() {
@@ -26482,8 +26976,8 @@ async function getTransactionReceipt(client, { hash: hash3 }) {
   }, { dedupe: true });
   if (!receipt)
     throw new TransactionReceiptNotFoundError({ hash: hash3 });
-  const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
-  return format(receipt, "getTransactionReceipt");
+  const format2 = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
+  return format2(receipt, "getTransactionReceipt");
 }
 var init_getTransactionReceipt = __esm({
   "../../node_modules/viem/_esm/actions/public/getTransactionReceipt.js"() {
@@ -26496,7 +26990,9 @@ var init_getTransactionReceipt = __esm({
 async function multicall(client, parameters) {
   const { account, authorizationList, allowFailure = true, blockHash, blockNumber, blockOverrides, blockTag, requireCanonical, stateOverride } = parameters;
   const contracts2 = parameters.contracts;
-  const { batchSize = parameters.batchSize ?? 1024, deployless = parameters.deployless ?? false } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
+  const batch = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
+  const batchSize = parameters.batchSize ?? batch.batchSize ?? 1024;
+  const deployless = parameters.deployless ?? batch.deployless ?? false;
   const multicallAddress = (() => {
     if (parameters.multicallAddress)
       return parameters.multicallAddress;
@@ -26558,27 +27054,45 @@ async function multicall(client, parameters) {
       ];
     }
   }
-  const aggregate3Results = await Promise.allSettled(chunkedCalls.map((calls) => getAction(client, readContract, "readContract")({
-    ...multicallAddress === null ? { code: multicall3Bytecode } : { address: multicallAddress },
-    abi: multicall3Abi,
-    account,
-    args: [calls],
-    authorizationList,
-    blockHash,
-    blockNumber,
-    blockOverrides,
-    blockTag,
-    functionName: "aggregate3",
-    requireCanonical,
-    stateOverride
-  })));
+  const batching = Boolean(client.batch?.multicall);
+  const batches = batching ? chunkedCalls.flatMap((calls) => calls.map((call2) => [call2])) : chunkedCalls;
+  const aggregate3Results = await Promise.allSettled(batches.map((calls) => {
+    if (batching)
+      return scheduleMulticall2(client, {
+        account,
+        authorizationList,
+        batchSize,
+        blockHash,
+        blockNumber,
+        blockOverrides,
+        blockTag,
+        call: calls[0],
+        multicallAddress,
+        requireCanonical,
+        stateOverride
+      }).then((result) => [result]);
+    return getAction(client, readContract, "readContract")({
+      ...multicallAddress === null ? { code: multicall3Bytecode } : { address: multicallAddress },
+      abi: multicall3Abi,
+      account,
+      args: [calls],
+      authorizationList,
+      blockHash,
+      blockNumber,
+      blockOverrides,
+      blockTag,
+      functionName: "aggregate3",
+      requireCanonical,
+      stateOverride
+    });
+  }));
   const results = [];
   for (let i = 0; i < aggregate3Results.length; i++) {
     const result = aggregate3Results[i];
     if (result.status === "rejected") {
       if (!allowFailure)
         throw result.reason;
-      for (let j = 0; j < chunkedCalls[i].length; j++) {
+      for (let j = 0; j < batches[i].length; j++) {
         results.push({
           status: "failure",
           error: result.reason,
@@ -26590,7 +27104,7 @@ async function multicall(client, parameters) {
     const aggregate3Result = result.value;
     for (let j = 0; j < aggregate3Result.length; j++) {
       const { returnData, success } = aggregate3Result[j];
-      const { callData } = chunkedCalls[i][j];
+      const { callData } = batches[i][j];
       const { abi: abi2, address: address2, functionName, args } = contracts2[results.length];
       try {
         if (callData === "0x")
@@ -26622,6 +27136,29 @@ async function multicall(client, parameters) {
     throw new BaseError2("multicall results mismatch");
   return results;
 }
+async function scheduleMulticall2(client, parameters) {
+  const { batchSize, call: call2, multicallAddress, ...rest } = parameters;
+  const { wait: wait2 = 0 } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
+  const { schedule } = createBatchScheduler({
+    id: stringify(["multicall", client.uid, batchSize, multicallAddress, rest]),
+    wait: wait2,
+    shouldSplitBatch(calls) {
+      if (batchSize === 0)
+        return false;
+      const size5 = calls.reduce((size6, { callData }) => size6 + (callData.length - 2) / 2, 0);
+      return size5 > batchSize;
+    },
+    fn: (calls) => getAction(client, readContract, "readContract")({
+      ...multicallAddress === null ? { code: multicall3Bytecode } : { address: multicallAddress },
+      ...rest,
+      abi: multicall3Abi,
+      args: [calls],
+      functionName: "aggregate3"
+    })
+  });
+  const [result] = await schedule(call2);
+  return result;
+}
 var init_multicall = __esm({
   "../../node_modules/viem/_esm/actions/public/multicall.js"() {
     init_abis();
@@ -26634,6 +27171,8 @@ var init_multicall = __esm({
     init_getChainContractAddress();
     init_getContractError();
     init_getAction();
+    init_createBatchScheduler();
+    init_stringify();
     init_readContract();
   }
 });
@@ -26854,7 +27393,7 @@ var init_abiItem2 = __esm({
 });
 
 // ../../node_modules/ox/_esm/core/AbiItem.js
-function from10(abiItem, options = {}) {
+function from11(abiItem, options = {}) {
   const { prepare = true } = options;
   const item = (() => {
     if (Array.isArray(abiItem))
@@ -27038,8 +27577,8 @@ function encode3(...parameters) {
   const { bytecode, args } = options;
   return concat2(bytecode, abiConstructor.inputs?.length && args?.length ? encode2(abiConstructor.inputs, args) : "0x");
 }
-function from11(abiConstructor) {
-  return from10(abiConstructor);
+function from12(abiConstructor) {
+  return from11(abiConstructor);
 }
 function fromAbi2(abi2) {
   const item = abi2.find((item2) => item2.type === "constructor");
@@ -27055,7 +27594,38 @@ var init_AbiConstructor = __esm({
   }
 });
 
+// ../../node_modules/ox/_esm/core/AbiEvent.js
+function from13(abiEvent, options = {}) {
+  return from11(abiEvent, options);
+}
+function getSelector2(abiItem) {
+  return getSignatureHash(abiItem);
+}
+var init_AbiEvent = __esm({
+  "../../node_modules/ox/_esm/core/AbiEvent.js"() {
+    init_AbiItem();
+  }
+});
+
 // ../../node_modules/ox/_esm/core/AbiFunction.js
+function decodeResult(...parameters) {
+  const [abiFunction, data, options = {}] = (() => {
+    if (Array.isArray(parameters[0])) {
+      const [abi2, name, data2, options2] = parameters;
+      return [fromAbi3(abi2, name), data2, options2];
+    }
+    return parameters;
+  })();
+  const values = decode(abiFunction.outputs, data, options);
+  if (values && Object.keys(values).length === 0)
+    return void 0;
+  if (values && Object.keys(values).length === 1) {
+    if (Array.isArray(values))
+      return values[0];
+    return Object.values(values)[0];
+  }
+  return values;
+}
 function encodeData2(...parameters) {
   const [abiFunction, args = []] = (() => {
     if (Array.isArray(parameters[0])) {
@@ -27069,12 +27639,12 @@ function encodeData2(...parameters) {
   const item = overloads ? fromAbi3([abiFunction, ...overloads], abiFunction.name, {
     args
   }) : abiFunction;
-  const selector = getSelector2(item);
+  const selector = getSelector3(item);
   const data = args.length > 0 ? encode2(item.inputs, args) : void 0;
   return data ? concat2(selector, data) : selector;
 }
-function from12(abiFunction, options = {}) {
-  return from10(abiFunction, options);
+function from14(abiFunction, options = {}) {
+  return from11(abiFunction, options);
 }
 function fromAbi3(abi2, name, options) {
   const item = fromAbi(abi2, name, options);
@@ -27082,7 +27652,7 @@ function fromAbi3(abi2, name, options) {
     throw new NotFoundError({ name, type: "function" });
   return item;
 }
-function getSelector2(abiItem) {
+function getSelector3(abiItem) {
   return getSelector(abiItem);
 }
 var init_AbiFunction = __esm({
@@ -27108,158 +27678,148 @@ async function simulateCalls(client, parameters) {
   const account = parameters.account ? parseAccount(parameters.account) : void 0;
   if (traceAssetChanges && !account)
     throw new BaseError2("`account` is required when `traceAssetChanges` is true");
-  const getBalanceData = account ? encode3(from11("constructor(bytes, bytes)"), {
+  const getBalanceData = account ? encode3(from12("constructor(bytes, bytes)"), {
     bytecode: deploylessCallViaBytecodeBytecode,
     args: [
       getBalanceCode,
-      encodeData2(from12("function getBalance(address)"), [account.address])
+      encodeData2(from14("function getBalance(address)"), [account.address])
     ]
   }) : void 0;
-  const assetAddresses = traceAssetChanges ? await Promise.all(parameters.calls.map(async (call2) => {
-    if (!call2.data && !call2.abi)
-      return;
-    const { accessList } = await createAccessList(client, {
-      account: account.address,
-      ...call2,
-      data: call2.abi ? encodeFunctionData(call2) : call2.data
-    });
-    return accessList.map(({ address: address2, storageKeys }) => storageKeys.length > 0 ? address2 : null);
-  })).then((x) => x.flat().filter(Boolean)) : [];
-  const blocks = await simulateBlocks(client, {
-    blockNumber,
-    blockTag,
+  const blockTag_ = blockTag ?? client.experimental_blockTag ?? "latest";
+  let baseBlockNumber = blockNumber;
+  if (traceAssetChanges && typeof baseBlockNumber !== "bigint" && blockTag_ !== "earliest" && blockTag_ !== "pending") {
+    if (blockTag_ === "latest")
+      baseBlockNumber = await getBlockNumber(client, { cacheTime: 0 });
+    else {
+      const block2 = await getBlock(client, { blockTag: blockTag_ });
+      if (typeof block2.number !== "bigint")
+        throw new BaseError2(`Block tag \`${blockTag_}\` did not resolve to a number.`);
+      baseBlockNumber = block2.number;
+    }
+  }
+  const block_ = typeof baseBlockNumber === "bigint" ? { blockNumber: baseBlockNumber } : { blockTag: blockTag_ };
+  const discovery = traceAssetChanges ? await simulateBlocks(client, {
+    ...block_,
     blocks: [
-      ...traceAssetChanges ? [
-        // ETH pre balances
-        {
-          calls: [{ data: getBalanceData }],
-          stateOverrides
-        },
-        // Asset pre balances
-        {
-          calls: assetAddresses.map((address2, i) => ({
-            abi: [
-              from12("function balanceOf(address) returns (uint256)")
-            ],
-            functionName: "balanceOf",
-            args: [account.address],
-            to: address2,
-            from: zeroAddress,
-            nonce: i
-          })),
-          stateOverrides: [
-            {
-              address: zeroAddress,
-              nonce: 0
-            }
-          ]
-        }
-      ] : [],
       {
-        calls: [...calls, { to: zeroAddress }].map((call2) => ({
+        calls: calls.map((call2) => ({
           ...call2,
-          from: account?.address
+          from: account.address
         })),
         stateOverrides
-      },
-      ...traceAssetChanges ? [
-        // ETH post balances
-        {
-          calls: [{ data: getBalanceData }]
-        },
-        // Asset post balances
-        {
-          calls: assetAddresses.map((address2, i) => ({
-            abi: [
-              from12("function balanceOf(address) returns (uint256)")
-            ],
-            functionName: "balanceOf",
-            args: [account.address],
-            to: address2,
-            from: zeroAddress,
-            nonce: i
-          })),
-          stateOverrides: [
-            {
-              address: zeroAddress,
-              nonce: 0
-            }
-          ]
-        },
-        // Decimals
-        {
-          calls: assetAddresses.map((address2, i) => ({
-            to: address2,
-            abi: [
-              from12("function decimals() returns (uint256)")
-            ],
-            functionName: "decimals",
-            from: zeroAddress,
-            nonce: i
-          })),
-          stateOverrides: [
-            {
-              address: zeroAddress,
-              nonce: 0
-            }
-          ]
-        },
-        // Token URI
-        {
-          calls: assetAddresses.map((address2, i) => ({
-            to: address2,
-            abi: [
-              from12("function tokenURI(uint256) returns (string)")
-            ],
-            functionName: "tokenURI",
-            args: [0n],
-            from: zeroAddress,
-            nonce: i
-          })),
-          stateOverrides: [
-            {
-              address: zeroAddress,
-              nonce: 0
-            }
-          ]
-        },
-        // Symbols
-        {
-          calls: assetAddresses.map((address2, i) => ({
-            to: address2,
-            abi: [from12("function symbol() returns (string)")],
-            functionName: "symbol",
-            from: zeroAddress,
-            nonce: i
-          })),
-          stateOverrides: [
-            {
-              address: zeroAddress,
-              nonce: 0
-            }
-          ]
-        }
-      ] : []
+      }
     ],
     traceTransfers,
     validation
-  });
-  const block_results = traceAssetChanges ? blocks[2] : blocks[0];
-  const [block_ethPre, block_assetsPre, , block_ethPost, block_assetsPost, block_decimals, block_tokenURI, block_symbols] = traceAssetChanges ? blocks : [];
+  }) : void 0;
+  const assetAddresses = discovery ? [
+    .../* @__PURE__ */ new Set([
+      ...tokensFromLogs(discovery[0].calls.flatMap((call2) => call2.logs ?? []), account.address),
+      // Included even for calls without data: contracts that mint on receiving
+      // native value (WETH) emit `Deposit`, not a `Transfer` the logs would catch.
+      // Candidates without code fall out at `isBalance`.
+      ...parameters.calls.map((call2) => call2.to?.toLowerCase())
+    ])
+  ].filter((address2) => Boolean(address2) && address2 !== ethAddress && address2 !== zeroAddress) : [];
+  const staticCallAddress = getStaticCallAddress([
+    ...account ? [account.address] : [],
+    ...assetAddresses,
+    ...stateOverrides?.map(({ address: address2 }) => address2) ?? []
+  ]);
+  const staticCallStateOverrides = [
+    { address: staticCallAddress, code: staticCallCode }
+  ];
+  const [balanceCallsPre, blocks] = await Promise.all([
+    traceAssetChanges ? Promise.all([
+      readBalance(client, {
+        account: account.address,
+        ...block_,
+        data: getBalanceData,
+        stateOverride: stateOverrides
+      }),
+      ...assetAddresses.map((address2) => readBalance(client, {
+        account: account.address,
+        address: address2,
+        ...block_,
+        data: encodeData2(balanceOfFunction, [
+          account.address
+        ]),
+        staticCallAddress,
+        stateOverride: stateOverrides
+      }))
+    ]) : [],
+    simulateBlocks(client, {
+      ...block_,
+      blocks: [
+        {
+          calls: [...calls, { to: zeroAddress }].map((call2) => ({
+            ...call2,
+            from: account?.address
+          })),
+          stateOverrides
+        },
+        ...traceAssetChanges ? [
+          // ETH post balances
+          {
+            calls: [{ data: getBalanceData }]
+          },
+          // Asset post balances
+          {
+            calls: assetAddresses.map((address2) => ({
+              to: staticCallAddress,
+              data: encodeStaticCall(address2, encodeData2(balanceOfFunction, [
+                account.address
+              ]))
+            })),
+            stateOverrides: staticCallStateOverrides
+          },
+          // Decimals
+          {
+            calls: assetAddresses.map((address2) => ({
+              to: staticCallAddress,
+              data: encodeStaticCall(address2, encodeData2(decimalsFunction))
+            })),
+            stateOverrides: staticCallStateOverrides
+          },
+          // Token URI
+          {
+            calls: assetAddresses.map((address2) => ({
+              to: staticCallAddress,
+              data: encodeStaticCall(address2, encodeData2(tokenUriFunction, [0n]))
+            })),
+            stateOverrides: staticCallStateOverrides
+          },
+          // Symbols
+          {
+            calls: assetAddresses.map((address2) => ({
+              to: staticCallAddress,
+              data: encodeStaticCall(address2, encodeData2(symbolFunction))
+            })),
+            stateOverrides: staticCallStateOverrides
+          }
+        ] : []
+      ],
+      traceTransfers,
+      validation
+    })
+  ]);
+  const block_results = blocks[0];
+  const [block_ethPost, block_assetsPost, block_decimals, block_tokenURI, block_symbols] = traceAssetChanges ? blocks.slice(1) : [];
   const { calls: block_calls, ...block } = block_results;
-  const results = block_calls.slice(0, -1) ?? [];
-  const ethPre = block_ethPre?.calls ?? [];
-  const assetsPre = block_assetsPre?.calls ?? [];
-  const balancesPre = [...ethPre, ...assetsPre].map((call2) => call2.status === "success" ? hexToBigInt(call2.data) : null);
+  const results = block_calls.slice(0, -1);
+  const balancesPre = balanceCallsPre.map((call2) => isBalance(call2) ? hexToBigInt(call2.data) : null);
   const ethPost = block_ethPost?.calls ?? [];
   const assetsPost = block_assetsPost?.calls ?? [];
-  const balancesPost = [...ethPost, ...assetsPost].map((call2) => call2.status === "success" ? hexToBigInt(call2.data) : null);
-  const decimals = (block_decimals?.calls ?? []).map((x) => x.status === "success" ? x.result : null);
-  const symbols = (block_symbols?.calls ?? []).map((x) => x.status === "success" ? x.result : null);
-  const tokenURI = (block_tokenURI?.calls ?? []).map((x) => x.status === "success" ? x.result : null);
+  const balanceCallsPost = [...ethPost, ...assetsPost];
+  const balancesPost = balanceCallsPost.map((call2) => isBalance(call2) ? hexToBigInt(call2.data) : null);
+  const decimals = (block_decimals?.calls ?? []).map((call2) => decodeAssetResult(call2, decimalsFunction));
+  const symbols = (block_symbols?.calls ?? []).map((call2) => decodeAssetResult(call2, symbolFunction));
+  const tokenURI = (block_tokenURI?.calls ?? []).map((call2) => decodeAssetResult(call2, tokenUriFunction));
   const changes = [];
   for (const [i, balancePost] of balancesPost.entries()) {
-    const balancePre = balancesPre[i];
+    const balancePre_ = balancesPre[i];
+    const preCall = balanceCallsPre[i];
+    const balancePre = typeof balancePre_ === "bigint" ? balancePre_ : i > 0 && preCall?.status === "success" && preCall.data === "0x" ? 0n : null;
     if (typeof balancePost !== "bigint")
       continue;
     if (typeof balancePre !== "bigint")
@@ -27280,8 +27840,6 @@ async function simulateCalls(client, parameters) {
         symbol: symbol_ ?? void 0
       };
     })();
-    if (changes.some((change) => change.token.address === token.address))
-      continue;
     changes.push({
       token,
       value: {
@@ -27297,20 +27855,85 @@ async function simulateCalls(client, parameters) {
     results
   };
 }
-var getBalanceCode;
+function encodeStaticCall(address2, data) {
+  return encodeData2(staticCallFunction, [address2, data]);
+}
+function tokensFromLogs(logs, account) {
+  const account_ = pad(account.toLowerCase(), { size: 32 });
+  return logs.filter((log) => {
+    if (log.topics[0]?.toLowerCase() !== transferEventSelector)
+      return false;
+    if (log.address.toLowerCase() === ethAddress)
+      return false;
+    return log.topics[1]?.toLowerCase() === account_ || log.topics[2]?.toLowerCase() === account_;
+  }).map((log) => log.address.toLowerCase());
+}
+function isBalance(call2) {
+  return call2.status === "success" && /^0x[\da-f]{64}$/i.test(call2.data);
+}
+function decodeAssetResult(call2, abiFunction) {
+  if (call2.status === "failure" || call2.data === "0x")
+    return null;
+  try {
+    return decodeResult(abiFunction, call2.data);
+  } catch {
+    return null;
+  }
+}
+async function readBalance(client, parameters) {
+  const { account, address: address2, blockNumber, blockTag, data, staticCallAddress, stateOverride } = parameters;
+  try {
+    const result = await call({ ...client, ccipRead: false }, {
+      account: address2 ? zeroAddress : account,
+      data: address2 ? encodeStaticCall(address2, data) : data,
+      stateOverride: address2 && staticCallAddress ? [
+        ...stateOverride ?? [],
+        { address: staticCallAddress, code: staticCallCode }
+      ] : stateOverride,
+      ...address2 ? { to: staticCallAddress } : {},
+      ...typeof blockNumber === "bigint" ? { blockNumber } : { blockTag }
+    });
+    return { data: result.data ?? "0x", status: "success" };
+  } catch (error) {
+    if (!(error instanceof CallExecutionError) || !(error.cause instanceof ExecutionRevertedError))
+      throw error;
+    return { data: "0x", status: "failure" };
+  }
+}
+function getStaticCallAddress(addresses) {
+  const occupied = new Set(addresses.map((address2) => address2.toLowerCase()));
+  let value = staticCallAddressBase;
+  while (occupied.has(`0x${value.toString(16).padStart(40, "0")}`))
+    value++;
+  return `0x${value.toString(16).padStart(40, "0")}`;
+}
+var getBalanceCode, staticCallCode, staticCallAddressBase, transferEventSelector, balanceOfFunction, decimalsFunction, tokenUriFunction, symbolFunction, staticCallFunction;
 var init_simulateCalls = __esm({
   "../../node_modules/viem/_esm/actions/public/simulateCalls.js"() {
     init_AbiConstructor();
+    init_AbiEvent();
     init_AbiFunction();
     init_parseAccount();
     init_address2();
     init_contracts();
     init_base();
-    init_encodeFunctionData();
-    init_utils8();
-    init_createAccessList();
+    init_contract();
+    init_node();
+    init_pad();
+    init_fromHex();
+    init_call();
+    init_getBlock();
+    init_getBlockNumber();
     init_simulateBlocks();
     getBalanceCode = "0x6080604052348015600e575f80fd5b5061016d8061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063f8b2cb4f1461002d575b5f80fd5b610047600480360381019061004291906100db565b61005d565b604051610054919061011e565b60405180910390f35b5f8173ffffffffffffffffffffffffffffffffffffffff16319050919050565b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6100aa82610081565b9050919050565b6100ba816100a0565b81146100c4575f80fd5b50565b5f813590506100d5816100b1565b92915050565b5f602082840312156100f0576100ef61007d565b5b5f6100fd848285016100c7565b91505092915050565b5f819050919050565b61011881610106565b82525050565b5f6020820190506101315f83018461010f565b9291505056fea26469706673582212203b9fe929fe995c7cf9887f0bdba8a36dd78e8b73f149b17d2d9ad7cd09d2dc6264736f6c634300081a0033";
+    staticCallCode = "0x608060405234801561000f575f5ffd5b5060043610610029575f3560e01c8063fd00430c1461002d575b5f5ffd5b6100476004803603810190610042919061012b565b610049565b005b80825f375f5f825f865afa610060573d5f5f3e3d5ffd5b3d5f5f3e3d5ff35b5f5ffd5b5f5ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f61009982610070565b9050919050565b6100a98161008f565b81146100b3575f5ffd5b50565b5f813590506100c4816100a0565b92915050565b5f5ffd5b5f5ffd5b5f5ffd5b5f5f83601f8401126100eb576100ea6100ca565b5b8235905067ffffffffffffffff811115610108576101076100ce565b5b602083019150836001820283011115610124576101236100d2565b5b9250929050565b5f5f5f6040848603121561014257610141610068565b5b5f61014f868287016100b6565b935050602084013567ffffffffffffffff8111156101705761016f61006c565b5b61017c868287016100d6565b9250925050925092509256fea2646970667358221220635ed99185cacf3f2acba6921f23687c969cec2bbaf5f9ad599f507e6e105e6964736f6c63430008230033";
+    staticCallAddressBase = 0x00000000000000000000000000000000deadbeefn;
+    transferEventSelector = getSelector2(from13("event Transfer(address indexed from, address indexed to, uint256 value)"));
+    balanceOfFunction = from14("function balanceOf(address) returns (uint256)");
+    decimalsFunction = from14("function decimals() returns (uint256)");
+    tokenUriFunction = from14("function tokenURI(uint256) returns (string)");
+    symbolFunction = from14("function symbol() returns (string)");
+    staticCallFunction = from14("function query(address target, bytes data)");
   }
 });
 
@@ -27319,7 +27942,7 @@ var SignatureErc6492_exports = {};
 __export(SignatureErc6492_exports, {
   InvalidWrappedSignatureError: () => InvalidWrappedSignatureError2,
   assert: () => assert7,
-  from: () => from13,
+  from: () => from15,
   magicBytes: () => magicBytes2,
   universalSignatureValidatorAbi: () => universalSignatureValidatorAbi,
   universalSignatureValidatorBytecode: () => universalSignatureValidatorBytecode,
@@ -27331,19 +27954,19 @@ function assert7(wrapped) {
   if (slice3(wrapped, -32) !== magicBytes2)
     throw new InvalidWrappedSignatureError2(wrapped);
 }
-function from13(wrapped) {
+function from15(wrapped) {
   if (typeof wrapped === "string")
     return unwrap2(wrapped);
   return wrapped;
 }
 function unwrap2(wrapped) {
   assert7(wrapped);
-  const [to, data, signature] = decode(from5("address, bytes, bytes"), wrapped);
+  const [to, data, signature] = decode(from6("address, bytes, bytes"), wrapped);
   return { data, signature, to };
 }
 function wrap2(value) {
   const { data, signature, to } = value;
-  return concat2(encode2(from5("address, bytes, bytes"), [
+  return concat2(encode2(from6("address, bytes, bytes"), [
     to,
     data,
     signature
@@ -27501,19 +28124,18 @@ async function verifyHash(client, parameters) {
   }
 }
 async function verifyErc8010(client, parameters) {
-  const { address: address2, blockNumber, blockTag, hash: hash3, multicallAddress } = parameters;
+  const { address: address2, blockHash, blockNumber, blockTag, hash: hash3, multicallAddress, requireCanonical } = parameters;
   const { authorization: authorization_ox, data: initData, signature, to } = SignatureErc8010_exports.unwrap(parameters.signature);
   const code = await getCode(client, {
     address: address2,
+    blockHash,
     blockNumber,
-    blockTag
+    blockTag,
+    requireCanonical
   });
   if (code === concatHex(["0xef0100", authorization_ox.address]))
     return await verifyErc1271(client, {
-      address: address2,
-      blockNumber,
-      blockTag,
-      hash: hash3,
+      ...parameters,
       signature
     });
   const authorization = {
@@ -27534,9 +28156,11 @@ async function verifyErc8010(client, parameters) {
     ...multicallAddress ? { address: multicallAddress } : { code: multicall3Bytecode },
     authorizationList: [authorization],
     abi: multicall3Abi,
+    blockHash,
     blockNumber,
     blockTag: "pending",
     functionName: "aggregate3",
+    requireCanonical,
     args: [
       [
         ...initData ? [
@@ -27602,14 +28226,16 @@ async function verifyErc6492(client, parameters) {
   throw new VerificationError();
 }
 async function verifyErc1271(client, parameters) {
-  const { address: address2, blockNumber, blockTag, hash: hash3, signature } = parameters;
+  const { address: address2, blockHash, blockNumber, blockTag, hash: hash3, requireCanonical, signature } = parameters;
   const result = await getAction(client, readContract, "readContract")({
     address: address2,
     abi: erc1271Abi,
     args: [hash3, signature],
+    blockHash,
     blockNumber,
     blockTag,
-    functionName: "isValidSignature"
+    functionName: "isValidSignature",
+    requireCanonical
   }).catch((error) => {
     if (error instanceof ContractFunctionExecutionError)
       throw new VerificationError();
@@ -27793,7 +28419,7 @@ var init_watchBlockNumber = __esm({
 // ../../node_modules/viem/_esm/actions/public/waitForTransactionReceipt.js
 async function waitForTransactionReceipt(client, parameters) {
   const {
-    checkReplacement = true,
+    checkReplacement = client.chain?.supportsTransactionReplacementDetection ?? true,
     confirmations = 1,
     hash: hash3,
     onReplaced,
@@ -27886,7 +28512,7 @@ async function waitForTransactionReceipt(client, parameters) {
                 shouldRetry: ({ error }) => error instanceof BlockNotFoundError
               });
               retrying = false;
-              const replacementTransaction = block.transactions.find(({ from: from14, nonce }) => from14 === replacedTransaction.from && nonce === replacedTransaction.nonce);
+              const replacementTransaction = block.transactions.find(({ from: from16, nonce }) => from16 === replacedTransaction.from && nonce === replacedTransaction.nonce);
               if (!replacementTransaction)
                 return;
               receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({
@@ -27937,6 +28563,68 @@ var init_waitForTransactionReceipt = __esm({
   }
 });
 
+// ../../node_modules/viem/_esm/actions/public/watchBlockHeaders.js
+function watchBlockHeaders(client, { onBlockHeader, onError }) {
+  let prevBlockHeader;
+  const observerId = stringify(["watchBlockHeaders", client.uid]);
+  return observe(observerId, { onBlockHeader, onError }, (emit) => {
+    let active = true;
+    let subscribed = false;
+    let unsubscribe = () => active = false;
+    (async () => {
+      try {
+        const transport = (() => {
+          if (client.transport.type === "fallback") {
+            const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket" || transport3.config.type === "ipc");
+            if (!transport2)
+              return client.transport;
+            return transport2.value;
+          }
+          return client.transport;
+        })();
+        const { unsubscribe: unsubscribe_ } = await transport.subscribe({
+          params: ["newHeads"],
+          onData(data) {
+            if (!active)
+              return;
+            const blockHeader = (client.chain?.formatters?.block?.format || formatBlock)(data.result, "watchBlockHeaders");
+            for (const field of blockFields)
+              delete blockHeader[field];
+            emit.onBlockHeader(blockHeader, prevBlockHeader);
+            prevBlockHeader = blockHeader;
+          },
+          onError(error) {
+            if (subscribed)
+              emit.onError?.(error);
+          }
+        });
+        subscribed = true;
+        unsubscribe = unsubscribe_;
+        if (!active)
+          unsubscribe();
+      } catch (err) {
+        emit.onError?.(err);
+      }
+    })();
+    return () => unsubscribe();
+  });
+}
+var blockFields;
+var init_watchBlockHeaders = __esm({
+  "../../node_modules/viem/_esm/actions/public/watchBlockHeaders.js"() {
+    init_block2();
+    init_observe();
+    init_stringify();
+    blockFields = [
+      "size",
+      "totalDifficulty",
+      "transactions",
+      "uncles",
+      "withdrawals"
+    ];
+  }
+});
+
 // ../../node_modules/viem/_esm/actions/public/watchBlocks.js
 function watchBlocks(client, { blockTag = client.experimental_blockTag ?? "latest", emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval }) {
   const enablePolling = (() => {
@@ -28334,6 +29022,16 @@ var init_watchPendingTransactions = __esm({
 });
 
 // ../../node_modules/viem/_esm/utils/siwe/parseSiweMessage.js
+function isValidSiweDateTime(value) {
+  if (!siweDateTimeRegex.test(value))
+    return false;
+  return !Number.isNaN(new Date(value).getTime());
+}
+function parseSiweDateTime(value) {
+  if (!isValidSiweDateTime(value))
+    return new Date(Number.NaN);
+  return new Date(value);
+}
 function parseSiweMessage(message) {
   const { scheme, statement, ...prefix } = message.match(prefixRegex)?.groups ?? {};
   const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } = message.match(suffixRegex)?.groups ?? {};
@@ -28342,18 +29040,19 @@ function parseSiweMessage(message) {
     ...prefix,
     ...suffix,
     ...chainId ? { chainId: Number(chainId) } : {},
-    ...expirationTime ? { expirationTime: new Date(expirationTime) } : {},
-    ...issuedAt ? { issuedAt: new Date(issuedAt) } : {},
-    ...notBefore ? { notBefore: new Date(notBefore) } : {},
+    ...expirationTime ? { expirationTime: parseSiweDateTime(expirationTime) } : {},
+    ...issuedAt ? { issuedAt: parseSiweDateTime(issuedAt) } : {},
+    ...notBefore ? { notBefore: parseSiweDateTime(notBefore) } : {},
     ...requestId ? { requestId } : {},
     ...resources ? { resources } : {},
     ...scheme ? { scheme } : {},
     ...statement ? { statement } : {}
   };
 }
-var prefixRegex, suffixRegex;
+var siweDateTimeRegex, prefixRegex, suffixRegex;
 var init_parseSiweMessage = __esm({
   "../../node_modules/viem/_esm/utils/siwe/parseSiweMessage.js"() {
+    siweDateTimeRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
     prefixRegex = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\/\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\n)(?<address>0x[a-fA-F0-9]{40})\n\n(?:(?<statement>.*)\n\n)?/;
     suffixRegex = /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/;
   }
@@ -28368,10 +29067,20 @@ function validateSiweMessage(parameters) {
     return false;
   if (scheme && message.scheme !== scheme)
     return false;
-  if (message.expirationTime && time >= message.expirationTime)
-    return false;
-  if (message.notBefore && time < message.notBefore)
+  if (Number.isNaN(time.getTime()))
     return false;
+  if (message.expirationTime) {
+    if (Number.isNaN(message.expirationTime.getTime()))
+      return false;
+    if (time >= message.expirationTime)
+      return false;
+  }
+  if (message.notBefore) {
+    if (Number.isNaN(message.notBefore.getTime()))
+      return false;
+    if (time < message.notBefore)
+      return false;
+  }
   try {
     if (!message.address)
       return false;
@@ -28424,14 +29133,197 @@ var init_verifySiweMessage = __esm({
   }
 });
 
+// ../../node_modules/viem/_esm/actions/token/internal.js
+function toAmount(amount, decimals) {
+  return { amount, decimals, formatted: formatUnits(amount, decimals) };
+}
+function toBaseUnits(amount, decimals) {
+  if (typeof amount === "bigint")
+    return amount;
+  const resolved = amount.decimals ?? decimals;
+  return parseUnits(amount.formatted, requireTokenDecimals(resolved));
+}
+function requireTokenDecimals(decimals) {
+  if (decimals === void 0)
+    throw new Error("Token decimals are required. Pass `amount.decimals` or select a declared token.");
+  return decimals;
+}
+function resolveAmountDecimals(amount, decimals) {
+  if (typeof amount === "bigint")
+    return decimals;
+  return amount.decimals ?? decimals;
+}
+function resolveToken(client, parameters) {
+  const { decimals, token } = parameters;
+  const declared = findDeclaredToken(client, token);
+  if (declared)
+    return {
+      address: declared.address,
+      decimals: decimals ?? declared.decimals
+    };
+  if (isAddress(token, { strict: false }))
+    return {
+      address: token,
+      decimals: decimals ?? inferDecimals(client, token)
+    };
+  throw new Error(`Token "${token}" is not a declared ERC-20 token on the client's \`tokens\` array (with an address for the client's chain), and is not a valid address.`);
+}
+function findDeclaredToken(client, token) {
+  const tokens = client.tokens;
+  const chainId = client.chain?.id;
+  if (!tokens || chainId === void 0)
+    return void 0;
+  const bySymbol = findTokenBySymbol(tokens, token);
+  if (bySymbol)
+    return resolveTokenForChain(bySymbol, chainId);
+  if (isAddress(token, { strict: false }))
+    for (const token_ of tokens) {
+      const resolved = resolveTokenForChain(token_, chainId);
+      if (resolved && isAddressEqual(resolved.address, token))
+        return resolved;
+    }
+  return void 0;
+}
+function resolveTokenForChain(token, chainId) {
+  const address2 = token.addresses[chainId];
+  if (!address2)
+    return void 0;
+  return {
+    address: address2,
+    currency: token.currency,
+    decimals: token.decimals,
+    name: token.name,
+    popular: token.popular,
+    symbol: token.symbol
+  };
+}
+function findTokenBySymbol(tokens, symbol) {
+  const lowerSymbol = symbol.toLowerCase();
+  for (const token of tokens) {
+    if (token.symbol?.toLowerCase() === lowerSymbol)
+      return token;
+  }
+  return void 0;
+}
+function inferDecimals(client, address2) {
+  const tokens = client.tokens;
+  const chainId = client.chain?.id;
+  if (tokens && chainId !== void 0)
+    for (const token of tokens) {
+      const resolved = resolveTokenForChain(token, chainId);
+      if (resolved && isAddressEqual(resolved.address, address2))
+        return resolved.decimals;
+    }
+  return void 0;
+}
+async function resolveTokenWithDecimals(client, parameters) {
+  const { address: address2, decimals } = resolveToken(client, parameters);
+  if (decimals !== void 0)
+    return { address: address2, decimals };
+  return {
+    address: address2,
+    decimals: await readContract(client, {
+      abi: erc20Abi,
+      address: address2,
+      functionName: "decimals"
+    })
+  };
+}
+function pickWriteParameters(parameters) {
+  const { account, chain: chain2, gas, maxFeePerGas, maxPriorityFeePerGas, nonce } = parameters;
+  return { account, chain: chain2, gas, maxFeePerGas, maxPriorityFeePerGas, nonce };
+}
+function defineCall(call2) {
+  return {
+    ...call2,
+    data: encodeFunctionData(call2),
+    to: call2.address
+  };
+}
+var init_internal = __esm({
+  "../../node_modules/viem/_esm/actions/token/internal.js"() {
+    init_abis();
+    init_isAddress();
+    init_isAddressEqual();
+    init_utils8();
+    init_formatUnits();
+    init_parseUnits();
+    init_readContract();
+  }
+});
+
+// ../../node_modules/viem/_esm/actions/token/approve.js
+async function approve(client, parameters) {
+  return approve.inner(writeContract, client, parameters);
+}
+function getCall(client, parameters) {
+  const { amount, spender, token } = parameters;
+  const { address: address2, decimals } = resolveToken(client, { token });
+  return {
+    abi: erc20Abi,
+    address: address2,
+    args: [spender, toBaseUnits(amount, decimals)],
+    functionName: "approve"
+  };
+}
+var init_approve = __esm({
+  "../../node_modules/viem/_esm/actions/token/approve.js"() {
+    init_abis();
+    init_parseEventLogs();
+    init_estimateContractGas();
+    init_simulateContract();
+    init_writeContract();
+    init_internal();
+    (function(approve2) {
+      async function inner(action, client, parameters) {
+        return await action(client, {
+          ...parameters,
+          ...approve2.call(client, parameters)
+        });
+      }
+      approve2.inner = inner;
+      function call2(client, parameters) {
+        return defineCall(getCall(client, parameters));
+      }
+      approve2.call = call2;
+      async function estimateGas2(client, parameters) {
+        return estimateContractGas(client, {
+          ...pickWriteParameters(parameters),
+          ...approve2.call(client, parameters)
+        });
+      }
+      approve2.estimateGas = estimateGas2;
+      async function simulate(client, parameters) {
+        return simulateContract(client, {
+          ...pickWriteParameters(parameters),
+          ...approve2.call(client, parameters)
+        });
+      }
+      approve2.simulate = simulate;
+      function extractEvent(logs) {
+        const [log] = parseEventLogs({
+          abi: erc20Abi,
+          logs,
+          eventName: "Approval",
+          strict: true
+        });
+        if (!log)
+          throw new Error("`Approval` event not found.");
+        return log;
+      }
+      approve2.extractEvent = extractEvent;
+    })(approve || (approve = {}));
+  }
+});
+
 // ../../node_modules/viem/_esm/actions/wallet/sendRawTransactionSync.js
 async function sendRawTransactionSync(client, { serializedTransaction, throwOnReceiptRevert, timeout }) {
   const receipt = await client.request({
     method: "eth_sendRawTransactionSync",
     params: timeout ? [serializedTransaction, timeout] : [serializedTransaction]
   }, { retryCount: 0 });
-  const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
-  const formatted = format(receipt);
+  const format2 = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
+  const formatted = format2(receipt);
   if (formatted.status === "reverted" && throwOnReceiptRevert)
     throw new TransactionReceiptRevertedError({ receipt: formatted });
   return formatted;
@@ -28443,6 +29335,502 @@ var init_sendRawTransactionSync = __esm({
   }
 });
 
+// ../../node_modules/viem/_esm/actions/wallet/sendTransactionSync.js
+async function sendTransactionSync(client, parameters) {
+  const { account: account_ = client.account, assertChainId = true, chain: chain2 = client.chain, accessList, authorizationList, blobs, data, dataSuffix = typeof client.dataSuffix === "string" ? client.dataSuffix : client.dataSuffix?.value, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, pollingInterval, throwOnReceiptRevert, type, value, ...rest } = parameters;
+  const timeout = parameters.timeout ?? Math.max((chain2?.blockTime ?? 0) * 3, 5e3);
+  if (typeof account_ === "undefined")
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/sendTransactionSync"
+    });
+  const account = account_ ? parseAccount(account_) : null;
+  let nonceManagerParameters;
+  try {
+    assertRequest(parameters);
+    const to = await (async () => {
+      if (parameters.to)
+        return parameters.to;
+      if (parameters.to === null)
+        return void 0;
+      if (authorizationList && authorizationList.length > 0)
+        return await recoverAuthorizationAddress({
+          authorization: authorizationList[0]
+        }).catch(() => {
+          throw new BaseError2("`to` is required. Could not infer from `authorizationList`.");
+        });
+      return void 0;
+    })();
+    if (account?.type === "json-rpc" || account === null) {
+      let chainId;
+      if (chain2 !== null) {
+        chainId = await getAction(client, getChainId, "getChainId")({});
+        if (assertChainId)
+          assertCurrentChain({
+            currentChainId: chainId,
+            chain: chain2
+          });
+      }
+      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
+      const format2 = chainFormat || formatTransactionRequest;
+      const request = format2({
+        // Pick out extra data that might exist on the chain's transaction request type.
+        ...extract(rest, { format: chainFormat }),
+        accessList,
+        account,
+        authorizationList,
+        blobs,
+        chainId,
+        data: dataSuffix ? concat([data ?? "0x", dataSuffix]) : data,
+        gas,
+        gasPrice,
+        maxFeePerBlobGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        to,
+        type,
+        value
+      }, "sendTransaction");
+      const isWalletNamespaceSupported = supportsWalletNamespace2.get(client.uid);
+      const method = isWalletNamespaceSupported ? "wallet_sendTransaction" : "eth_sendTransaction";
+      const hash3 = await (async () => {
+        try {
+          return await client.request({
+            method,
+            params: [request]
+          }, { retryCount: 0 });
+        } catch (e6) {
+          if (isWalletNamespaceSupported === false)
+            throw e6;
+          const error = e6;
+          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError") {
+            return await client.request({
+              method: "wallet_sendTransaction",
+              params: [request]
+            }, { retryCount: 0 }).then((hash4) => {
+              supportsWalletNamespace2.set(client.uid, true);
+              return hash4;
+            }).catch((e7) => {
+              const walletNamespaceError = e7;
+              if (walletNamespaceError.name === "MethodNotFoundRpcError" || walletNamespaceError.name === "MethodNotSupportedRpcError") {
+                supportsWalletNamespace2.set(client.uid, false);
+                throw error;
+              }
+              throw walletNamespaceError;
+            });
+          }
+          throw error;
+        }
+      })();
+      const receipt = await getAction(client, waitForTransactionReceipt, "waitForTransactionReceipt")({
+        checkReplacement: false,
+        hash: hash3,
+        pollingInterval,
+        timeout
+      });
+      if (throwOnReceiptRevert && receipt.status === "reverted")
+        throw new TransactionReceiptRevertedError({ receipt });
+      return receipt;
+    }
+    if (account?.type === "local") {
+      const nonceManager = (() => {
+        if (!account.nonceManager || typeof nonce !== "undefined")
+          return account.nonceManager;
+        const nonceManager2 = account.nonceManager;
+        return {
+          consume(parameters2) {
+            nonceManagerParameters = {
+              address: parameters2.address,
+              chainId: parameters2.chainId
+            };
+            return nonceManager2.consume(parameters2);
+          },
+          get(parameters2) {
+            return nonceManager2.get(parameters2);
+          },
+          increment(parameters2) {
+            return nonceManager2.increment(parameters2);
+          },
+          reset(parameters2) {
+            return nonceManager2.reset(parameters2);
+          }
+        };
+      })();
+      const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
+        account,
+        accessList,
+        authorizationList,
+        blobs,
+        chain: chain2,
+        data: dataSuffix ? concat([data ?? "0x", dataSuffix]) : data,
+        gas,
+        gasPrice,
+        maxFeePerBlobGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        nonceManager,
+        parameters: [...defaultParameters, "sidecars"],
+        type,
+        value,
+        ...rest,
+        to
+      });
+      const serializer = chain2?.serializers?.transaction;
+      const serializedTransaction = await account.signTransaction(request, {
+        serializer
+      });
+      return await getAction(client, sendRawTransactionSync, "sendRawTransactionSync")({
+        serializedTransaction,
+        throwOnReceiptRevert,
+        timeout: parameters.timeout
+      });
+    }
+    if (account?.type === "smart")
+      throw new AccountTypeNotSupportedError({
+        metaMessages: [
+          "Consider using the `sendUserOperation` Action instead."
+        ],
+        docsPath: "/docs/actions/bundler/sendUserOperation",
+        type: "smart"
+      });
+    throw new AccountTypeNotSupportedError({
+      docsPath: "/docs/actions/wallet/sendTransactionSync",
+      type: account?.type
+    });
+  } catch (err) {
+    if (err instanceof AccountTypeNotSupportedError)
+      throw err;
+    if (nonceManagerParameters && !(err instanceof TransactionReceiptRevertedError))
+      account?.nonceManager?.reset(nonceManagerParameters);
+    throw getTransactionError(err, {
+      ...parameters,
+      account,
+      chain: parameters.chain || void 0
+    });
+  }
+}
+var supportsWalletNamespace2;
+var init_sendTransactionSync = __esm({
+  "../../node_modules/viem/_esm/actions/wallet/sendTransactionSync.js"() {
+    init_parseAccount();
+    init_account();
+    init_base();
+    init_transaction();
+    init_recoverAuthorizationAddress();
+    init_assertCurrentChain();
+    init_concat();
+    init_getTransactionError();
+    init_extract();
+    init_transactionRequest();
+    init_getAction();
+    init_lru();
+    init_assertRequest();
+    init_getChainId();
+    init_waitForTransactionReceipt();
+    init_prepareTransactionRequest();
+    init_sendRawTransactionSync();
+    supportsWalletNamespace2 = new LruMap(128);
+  }
+});
+
+// ../../node_modules/viem/_esm/actions/wallet/writeContractSync.js
+async function writeContractSync(client, parameters) {
+  return writeContract.internal(client, sendTransactionSync, "sendTransactionSync", parameters);
+}
+var init_writeContractSync = __esm({
+  "../../node_modules/viem/_esm/actions/wallet/writeContractSync.js"() {
+    init_sendTransactionSync();
+    init_writeContract();
+  }
+});
+
+// ../../node_modules/viem/_esm/actions/token/approveSync.js
+async function approveSync(client, parameters) {
+  const { amount, token, throwOnReceiptRevert = true } = parameters;
+  const { decimals } = resolveToken(client, { token });
+  const resolved = resolveAmountDecimals(amount, decimals);
+  const receipt = await approve.inner(writeContractSync, client, {
+    ...parameters,
+    throwOnReceiptRevert
+  });
+  const { args } = approve.extractEvent(receipt.logs);
+  return {
+    ...args,
+    ...resolved === void 0 ? {} : { decimals: resolved, formatted: formatUnits(args.value, resolved) },
+    receipt
+  };
+}
+var init_approveSync = __esm({
+  "../../node_modules/viem/_esm/actions/token/approveSync.js"() {
+    init_formatUnits();
+    init_writeContractSync();
+    init_approve();
+    init_internal();
+  }
+});
+
+// ../../node_modules/viem/_esm/actions/token/getAllowance.js
+async function getAllowance(client, parameters) {
+  const { account, decimals, spender, token, ...rest } = parameters;
+  const [amount, { decimals: resolved }] = await Promise.all([
+    readContract(client, {
+      ...rest,
+      ...getAllowance.call(client, { account, spender, token })
+    }),
+    resolveTokenWithDecimals(client, {
+      decimals,
+      token
+    })
+  ]);
+  return toAmount(amount, resolved);
+}
+var init_getAllowance = __esm({
+  "../../node_modules/viem/_esm/actions/token/getAllowance.js"() {
+    init_abis();
+    init_readContract();
+    init_internal();
+    (function(getAllowance2) {
+      function call2(client, args) {
+        return defineCall({
+          address: resolveToken(client, args).address,
+          abi: erc20Abi,
+          functionName: "allowance",
+          args: [args.account, args.spender]
+        });
+      }
+      getAllowance2.call = call2;
+    })(getAllowance || (getAllowance = {}));
+  }
+});
+
+// ../../node_modules/viem/_esm/actions/token/getBalance.js
+async function getBalance2(client, parameters) {
+  const { account: account_ = client.account, decimals, token, ...rest } = parameters;
+  if (!account_)
+    throw new AccountNotFoundError();
+  const account = parseAccount(account_).address;
+  const [amount, { decimals: resolved }] = await Promise.all([
+    readContract(client, {
+      ...rest,
+      ...getBalance2.call(client, { account, token })
+    }),
+    resolveTokenWithDecimals(client, {
+      decimals,
+      token
+    })
+  ]);
+  return toAmount(amount, resolved);
+}
+var init_getBalance2 = __esm({
+  "../../node_modules/viem/_esm/actions/token/getBalance.js"() {
+    init_parseAccount();
+    init_abis();
+    init_account();
+    init_readContract();
+    init_internal();
+    (function(getBalance3) {
+      function call2(client, args) {
+        const account_ = args.account ?? client.account;
+        if (!account_)
+          throw new AccountNotFoundError();
+        const account = parseAccount(account_).address;
+        return defineCall({
+          address: resolveToken(client, args).address,
+          abi: erc20Abi,
+          functionName: "balanceOf",
+          args: [account]
+        });
+      }
+      getBalance3.call = call2;
+    })(getBalance2 || (getBalance2 = {}));
+  }
+});
+
+// ../../node_modules/viem/_esm/actions/token/getMetadata.js
+async function getMetadata(client, parameters) {
+  const { token, ...rest } = parameters;
+  const { address: address2 } = resolveToken(client, { token });
+  const declared = findDeclaredToken(client, token);
+  const [decimals_, name, symbol] = await Promise.all([
+    declared?.decimals ?? readContract(client, {
+      ...rest,
+      abi: erc20Abi,
+      address: address2,
+      functionName: "decimals"
+    }),
+    declared?.name ?? readContract(client, {
+      ...rest,
+      abi: erc20Abi,
+      address: address2,
+      functionName: "name"
+    }),
+    declared?.symbol ?? readContract(client, {
+      ...rest,
+      abi: erc20Abi,
+      address: address2,
+      functionName: "symbol"
+    })
+  ]);
+  return {
+    decimals: decimals_,
+    name,
+    symbol
+  };
+}
+var init_getMetadata = __esm({
+  "../../node_modules/viem/_esm/actions/token/getMetadata.js"() {
+    init_abis();
+    init_readContract();
+    init_internal();
+  }
+});
+
+// ../../node_modules/viem/_esm/actions/token/getTotalSupply.js
+async function getTotalSupply(client, parameters) {
+  const { decimals, token, ...rest } = parameters;
+  const [amount, { decimals: resolved }] = await Promise.all([
+    readContract(client, {
+      ...rest,
+      ...getTotalSupply.call(client, { token })
+    }),
+    resolveTokenWithDecimals(client, {
+      decimals,
+      token
+    })
+  ]);
+  return toAmount(amount, resolved);
+}
+var init_getTotalSupply = __esm({
+  "../../node_modules/viem/_esm/actions/token/getTotalSupply.js"() {
+    init_abis();
+    init_readContract();
+    init_internal();
+    (function(getTotalSupply2) {
+      function call2(client, args) {
+        return defineCall({
+          address: resolveToken(client, args).address,
+          abi: erc20Abi,
+          args: [],
+          functionName: "totalSupply"
+        });
+      }
+      getTotalSupply2.call = call2;
+    })(getTotalSupply || (getTotalSupply = {}));
+  }
+});
+
+// ../../node_modules/viem/_esm/actions/token/transfer.js
+async function transfer(client, parameters) {
+  return transfer.inner(writeContract, client, parameters);
+}
+function getCall2(client, parameters) {
+  const { amount, from: from16, to, token } = parameters;
+  const { address: address2, decimals } = resolveToken(client, { token });
+  const value = toBaseUnits(amount, decimals);
+  if (from16)
+    return {
+      abi: erc20Abi,
+      address: address2,
+      args: [from16, to, value],
+      functionName: "transferFrom"
+    };
+  return {
+    abi: erc20Abi,
+    address: address2,
+    args: [to, value],
+    functionName: "transfer"
+  };
+}
+var init_transfer = __esm({
+  "../../node_modules/viem/_esm/actions/token/transfer.js"() {
+    init_abis();
+    init_parseEventLogs();
+    init_estimateContractGas();
+    init_simulateContract();
+    init_writeContract();
+    init_internal();
+    (function(transfer2) {
+      async function inner(action, client, parameters) {
+        return await action(client, {
+          ...parameters,
+          ...transfer2.call(client, parameters)
+        });
+      }
+      transfer2.inner = inner;
+      function call2(client, parameters) {
+        return defineCall(getCall2(client, parameters));
+      }
+      transfer2.call = call2;
+      async function estimateGas2(client, parameters) {
+        return estimateContractGas(client, {
+          ...pickWriteParameters(parameters),
+          ...transfer2.call(client, parameters)
+        });
+      }
+      transfer2.estimateGas = estimateGas2;
+      async function simulate(client, parameters) {
+        return simulateContract(client, {
+          ...pickWriteParameters(parameters),
+          ...transfer2.call(client, parameters)
+        });
+      }
+      transfer2.simulate = simulate;
+      function extractEvent(logs) {
+        const [log] = parseEventLogs({
+          abi: erc20Abi,
+          logs,
+          eventName: "Transfer",
+          strict: true
+        });
+        if (!log)
+          throw new Error("`Transfer` event not found.");
+        return log;
+      }
+      transfer2.extractEvent = extractEvent;
+    })(transfer || (transfer = {}));
+  }
+});
+
+// ../../node_modules/viem/_esm/actions/token/transferSync.js
+async function transferSync(client, parameters) {
+  const { amount, token, throwOnReceiptRevert = true } = parameters;
+  const { decimals } = resolveToken(client, { token });
+  const resolved = resolveAmountDecimals(amount, decimals);
+  const receipt = await transfer.inner(writeContractSync, client, {
+    ...parameters,
+    throwOnReceiptRevert
+  });
+  const { args } = transfer.extractEvent(receipt.logs);
+  return {
+    ...args,
+    ...resolved === void 0 ? {} : { decimals: resolved, formatted: formatUnits(args.value, resolved) },
+    receipt
+  };
+}
+var init_transferSync = __esm({
+  "../../node_modules/viem/_esm/actions/token/transferSync.js"() {
+    init_formatUnits();
+    init_writeContractSync();
+    init_internal();
+    init_transfer();
+  }
+});
+
+// ../../node_modules/viem/_esm/actions/token/index.js
+var init_token = __esm({
+  "../../node_modules/viem/_esm/actions/token/index.js"() {
+    init_approve();
+    init_approveSync();
+    init_getAllowance();
+    init_getBalance2();
+    init_getMetadata();
+    init_getTotalSupply();
+    init_transfer();
+    init_transferSync();
+  }
+});
+
 // ../../node_modules/viem/_esm/clients/decorators/public.js
 function publicActions(client) {
   return {
@@ -28480,6 +29868,7 @@ function publicActions(client) {
     getProof: (args) => getProof(client, args),
     estimateMaxPriorityFeePerGas: (args) => estimateMaxPriorityFeePerGas(client, args),
     fillTransaction: (args) => fillTransaction(client, args),
+    getRawTransaction: (args) => getRawTransaction(client, args),
     getStorageAt: (args) => getStorageAt(client, args),
     getTransaction: (args) => getTransaction(client, args),
     getTransactionConfirmations: (args) => getTransactionConfirmations(client, args),
@@ -28500,11 +29889,21 @@ function publicActions(client) {
     verifyTypedData: (args) => verifyTypedData(client, args),
     uninstallFilter: (args) => uninstallFilter(client, args),
     waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),
+    watchBlockHeaders: (args) => watchBlockHeaders(client, args),
     watchBlocks: (args) => watchBlocks(client, args),
     watchBlockNumber: (args) => watchBlockNumber(client, args),
     watchContractEvent: (args) => watchContractEvent(client, args),
     watchEvent: (args) => watchEvent(client, args),
-    watchPendingTransactions: (args) => watchPendingTransactions(client, args)
+    watchPendingTransactions: (args) => watchPendingTransactions(client, args),
+    token: bindPublicToken(client)
+  };
+}
+function bindPublicToken(client) {
+  return {
+    getAllowance: bindActionDecorators(client, getAllowance),
+    getBalance: bindActionDecorators(client, getBalance2),
+    getMetadata: bindActionDecorators(client, getMetadata),
+    getTotalSupply: bindActionDecorators(client, getTotalSupply)
   };
 }
 var init_public = __esm({
@@ -28542,6 +29941,7 @@ var init_public = __esm({
     init_getGasPrice();
     init_getLogs();
     init_getProof();
+    init_getRawTransaction();
     init_getStorageAt();
     init_getTransaction();
     init_getTransactionConfirmations();
@@ -28557,15 +29957,18 @@ var init_public = __esm({
     init_verifyMessage();
     init_verifyTypedData();
     init_waitForTransactionReceipt();
+    init_watchBlockHeaders();
     init_watchBlockNumber();
     init_watchBlocks();
     init_watchContractEvent();
     init_watchEvent();
     init_watchPendingTransactions();
     init_verifySiweMessage();
+    init_token();
     init_prepareTransactionRequest();
     init_sendRawTransaction();
     init_sendRawTransactionSync();
+    init_createClient();
   }
 });
 
@@ -28762,193 +30165,6 @@ var init_sendCallsSync = __esm({
   }
 });
 
-// ../../node_modules/viem/_esm/actions/wallet/sendTransactionSync.js
-async function sendTransactionSync(client, parameters) {
-  const { account: account_ = client.account, assertChainId = true, chain: chain2 = client.chain, accessList, authorizationList, blobs, data, dataSuffix = typeof client.dataSuffix === "string" ? client.dataSuffix : client.dataSuffix?.value, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, pollingInterval, throwOnReceiptRevert, type, value, ...rest } = parameters;
-  const timeout = parameters.timeout ?? Math.max((chain2?.blockTime ?? 0) * 3, 5e3);
-  if (typeof account_ === "undefined")
-    throw new AccountNotFoundError({
-      docsPath: "/docs/actions/wallet/sendTransactionSync"
-    });
-  const account = account_ ? parseAccount(account_) : null;
-  let nonceManagerParameters;
-  try {
-    assertRequest(parameters);
-    const to = await (async () => {
-      if (parameters.to)
-        return parameters.to;
-      if (parameters.to === null)
-        return void 0;
-      if (authorizationList && authorizationList.length > 0)
-        return await recoverAuthorizationAddress({
-          authorization: authorizationList[0]
-        }).catch(() => {
-          throw new BaseError2("`to` is required. Could not infer from `authorizationList`.");
-        });
-      return void 0;
-    })();
-    if (account?.type === "json-rpc" || account === null) {
-      let chainId;
-      if (chain2 !== null) {
-        chainId = await getAction(client, getChainId, "getChainId")({});
-        if (assertChainId)
-          assertCurrentChain({
-            currentChainId: chainId,
-            chain: chain2
-          });
-      }
-      const chainFormat = client.chain?.formatters?.transactionRequest?.format;
-      const format = chainFormat || formatTransactionRequest;
-      const request = format({
-        // Pick out extra data that might exist on the chain's transaction request type.
-        ...extract(rest, { format: chainFormat }),
-        accessList,
-        account,
-        authorizationList,
-        blobs,
-        chainId,
-        data: dataSuffix ? concat([data ?? "0x", dataSuffix]) : data,
-        gas,
-        gasPrice,
-        maxFeePerBlobGas,
-        maxFeePerGas,
-        maxPriorityFeePerGas,
-        nonce,
-        to,
-        type,
-        value
-      }, "sendTransaction");
-      const isWalletNamespaceSupported = supportsWalletNamespace2.get(client.uid);
-      const method = isWalletNamespaceSupported ? "wallet_sendTransaction" : "eth_sendTransaction";
-      const hash3 = await (async () => {
-        try {
-          return await client.request({
-            method,
-            params: [request]
-          }, { retryCount: 0 });
-        } catch (e6) {
-          if (isWalletNamespaceSupported === false)
-            throw e6;
-          const error = e6;
-          if (error.name === "InvalidInputRpcError" || error.name === "InvalidParamsRpcError" || error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError") {
-            return await client.request({
-              method: "wallet_sendTransaction",
-              params: [request]
-            }, { retryCount: 0 }).then((hash4) => {
-              supportsWalletNamespace2.set(client.uid, true);
-              return hash4;
-            }).catch((e7) => {
-              const walletNamespaceError = e7;
-              if (walletNamespaceError.name === "MethodNotFoundRpcError" || walletNamespaceError.name === "MethodNotSupportedRpcError") {
-                supportsWalletNamespace2.set(client.uid, false);
-                throw error;
-              }
-              throw walletNamespaceError;
-            });
-          }
-          throw error;
-        }
-      })();
-      const receipt = await getAction(client, waitForTransactionReceipt, "waitForTransactionReceipt")({
-        checkReplacement: false,
-        hash: hash3,
-        pollingInterval,
-        timeout
-      });
-      if (throwOnReceiptRevert && receipt.status === "reverted")
-        throw new TransactionReceiptRevertedError({ receipt });
-      return receipt;
-    }
-    if (account?.type === "local") {
-      if (account.nonceManager && typeof nonce === "undefined") {
-        const requestChainId = rest.chainId;
-        const chainId = await (async () => {
-          if (typeof requestChainId === "number")
-            return requestChainId;
-          if (chain2)
-            return chain2.id;
-          return getAction(client, getChainId, "getChainId")({});
-        })();
-        nonceManagerParameters = { address: account.address, chainId };
-      }
-      const request = await getAction(client, prepareTransactionRequest, "prepareTransactionRequest")({
-        account,
-        accessList,
-        authorizationList,
-        blobs,
-        chain: chain2,
-        data: dataSuffix ? concat([data ?? "0x", dataSuffix]) : data,
-        gas,
-        gasPrice,
-        maxFeePerBlobGas,
-        maxFeePerGas,
-        maxPriorityFeePerGas,
-        nonce,
-        nonceManager: account.nonceManager,
-        parameters: [...defaultParameters, "sidecars"],
-        type,
-        value,
-        ...rest,
-        to
-      });
-      const serializer = chain2?.serializers?.transaction;
-      const serializedTransaction = await account.signTransaction(request, {
-        serializer
-      });
-      return await getAction(client, sendRawTransactionSync, "sendRawTransactionSync")({
-        serializedTransaction,
-        throwOnReceiptRevert,
-        timeout: parameters.timeout
-      });
-    }
-    if (account?.type === "smart")
-      throw new AccountTypeNotSupportedError({
-        metaMessages: [
-          "Consider using the `sendUserOperation` Action instead."
-        ],
-        docsPath: "/docs/actions/bundler/sendUserOperation",
-        type: "smart"
-      });
-    throw new AccountTypeNotSupportedError({
-      docsPath: "/docs/actions/wallet/sendTransactionSync",
-      type: account?.type
-    });
-  } catch (err) {
-    if (err instanceof AccountTypeNotSupportedError)
-      throw err;
-    if (nonceManagerParameters && !(err instanceof TransactionReceiptRevertedError))
-      account?.nonceManager?.reset(nonceManagerParameters);
-    throw getTransactionError(err, {
-      ...parameters,
-      account,
-      chain: parameters.chain || void 0
-    });
-  }
-}
-var supportsWalletNamespace2;
-var init_sendTransactionSync = __esm({
-  "../../node_modules/viem/_esm/actions/wallet/sendTransactionSync.js"() {
-    init_parseAccount();
-    init_account();
-    init_base();
-    init_transaction();
-    init_recoverAuthorizationAddress();
-    init_assertCurrentChain();
-    init_concat();
-    init_getTransactionError();
-    init_extract();
-    init_transactionRequest();
-    init_getAction();
-    init_lru();
-    init_assertRequest();
-    init_getChainId();
-    init_waitForTransactionReceipt();
-    init_prepareTransactionRequest();
-    init_sendRawTransactionSync();
-    supportsWalletNamespace2 = new LruMap(128);
-  }
-});
-
 // ../../node_modules/viem/_esm/actions/wallet/showCallsStatus.js
 async function showCallsStatus(client, parameters) {
   const { id } = parameters;
@@ -29038,7 +30254,7 @@ async function signTransaction(client, parameters) {
       chain: chain2
     });
   const formatters3 = chain2?.formatters || client.chain?.formatters;
-  const format = formatters3?.transactionRequest?.format || formatTransactionRequest;
+  const format2 = formatters3?.transactionRequest?.format || formatTransactionRequest;
   if (account.signTransaction)
     return account.signTransaction({
       ...transaction,
@@ -29049,7 +30265,7 @@ async function signTransaction(client, parameters) {
     method: "eth_signTransaction",
     params: [
       {
-        ...format({
+        ...format2({
           ...transaction,
           account
         }, "signTransaction"),
@@ -29131,17 +30347,6 @@ var init_watchAsset = __esm({
   }
 });
 
-// ../../node_modules/viem/_esm/actions/wallet/writeContractSync.js
-async function writeContractSync(client, parameters) {
-  return writeContract.internal(client, sendTransactionSync, "sendTransactionSync", parameters);
-}
-var init_writeContractSync = __esm({
-  "../../node_modules/viem/_esm/actions/wallet/writeContractSync.js"() {
-    init_sendTransactionSync();
-    init_writeContract();
-  }
-});
-
 // ../../node_modules/viem/_esm/clients/decorators/wallet.js
 function walletActions(client) {
   return {
@@ -29172,13 +30377,20 @@ function walletActions(client) {
     waitForCallsStatus: (args) => waitForCallsStatus(client, args),
     watchAsset: (args) => watchAsset(client, args),
     writeContract: (args) => writeContract(client, args),
-    writeContractSync: (args) => writeContractSync(client, args)
+    writeContractSync: (args) => writeContractSync(client, args),
+    token: {
+      approve: bindActionDecorators(client, approve),
+      approveSync: bindActionDecorators(client, approveSync),
+      transfer: bindActionDecorators(client, transfer),
+      transferSync: bindActionDecorators(client, transferSync)
+    }
   };
 }
 var init_wallet = __esm({
   "../../node_modules/viem/_esm/clients/decorators/wallet.js"() {
     init_fillTransaction();
     init_getChainId();
+    init_token();
     init_addChain();
     init_deployContract();
     init_getAddresses();
@@ -29205,6 +30417,7 @@ var init_wallet = __esm({
     init_watchAsset();
     init_writeContract();
     init_writeContractSync();
+    init_createClient();
   }
 });
 
@@ -29280,7 +30493,7 @@ function getSignalId(signal) {
   return nextId;
 }
 function http(url, config2 = {}) {
-  const { batch, fetchFn, fetchOptions, key = "http", methods, name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay, raw } = config2;
+  const { batch, fetchFn, fetchOptions, key = "http", maxResponseBodySize, methods, name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay, raw } = config2;
   return ({ chain: chain2, retryCount: retryCount_, timeout: timeout_ }) => {
     const { batchSize = 1e3, wait: wait2 = 0 } = typeof batch === "object" ? batch : {};
     const retryCount = config2.retryCount ?? retryCount_;
@@ -29291,6 +30504,7 @@ function http(url, config2 = {}) {
     const rpcClient = getHttpRpcClient(url_, {
       fetchFn,
       fetchOptions,
+      maxResponseBodySize,
       onRequest: onFetchRequest,
       onResponse: onFetchResponse,
       timeout
@@ -29523,15 +30737,15 @@ var init_isEip712Transaction = __esm({
 
 // ../../node_modules/viem/_esm/zksync/utils/assertEip712Transaction.js
 function assertEip712Transaction(transaction) {
-  const { chainId, to, from: from14, paymaster, paymasterInput } = transaction;
+  const { chainId, to, from: from16, paymaster, paymasterInput } = transaction;
   if (!isEIP712Transaction(transaction))
     throw new InvalidEip712TransactionError();
   if (!chainId || chainId <= 0)
     throw new InvalidChainIdError({ chainId });
   if (to && !isAddress(to))
     throw new InvalidAddressError({ address: to });
-  if (from14 && !isAddress(from14))
-    throw new InvalidAddressError({ address: from14 });
+  if (from16 && !isAddress(from16))
+    throw new InvalidAddressError({ address: from16 });
   if (paymaster && !isAddress(paymaster))
     throw new InvalidAddressError({ address: paymaster });
   if (paymaster && !paymasterInput) {
@@ -29559,7 +30773,7 @@ function serializeTransaction2(transaction, signature) {
   return serializeTransaction(transaction, signature);
 }
 function serializeTransactionEIP712(transaction) {
-  const { chainId, gas, nonce, to, from: from14, value, maxFeePerGas, maxPriorityFeePerGas, customSignature, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
+  const { chainId, gas, nonce, to, from: from16, value, maxFeePerGas, maxPriorityFeePerGas, customSignature, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
   assertEip712Transaction(transaction);
   const serializedTransaction = [
     nonce ? toHex(nonce) : "0x",
@@ -29573,7 +30787,7 @@ function serializeTransactionEIP712(transaction) {
     toHex(""),
     toHex(""),
     toHex(chainId),
-    from14 ?? "0x",
+    from16 ?? "0x",
     gasPerPubdata ? toHex(gasPerPubdata) : toHex(gasPerPubdataDefault),
     factoryDeps ?? [],
     customSignature ?? "0x",
@@ -29663,10 +30877,10 @@ var init_hashBytecode = __esm({
 
 // ../../node_modules/viem/_esm/zksync/utils/getEip712Domain.js
 function transactionToMessage(transaction) {
-  const { gas, nonce, to, from: from14, value, maxFeePerGas, maxPriorityFeePerGas, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
+  const { gas, nonce, to, from: from16, value, maxFeePerGas, maxPriorityFeePerGas, factoryDeps, paymaster, paymasterInput, gasPerPubdata, data } = transaction;
   return {
     txType: 113n,
-    from: BigInt(from14),
+    from: BigInt(from16),
     to: to ? BigInt(to) : 0n,
     gasLimit: gas ?? 0n,
     gasPerPubdataByteLimit: gasPerPubdata ?? gasPerPubdataDefault,
@@ -29891,6 +31105,8 @@ var init_formatters2 = __esm({
       transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({
         format(args) {
           return {
+            ...args.depositNonce ? { depositNonce: hexToBigInt(args.depositNonce) } : {},
+            ...args.depositReceiptVersion ? { depositReceiptVersion: hexToNumber(args.depositReceiptVersion) } : {},
             l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
             l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
             l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
@@ -29910,10 +31126,10 @@ function serializeTransaction3(transaction, signature) {
 }
 function serializeTransactionDeposit(transaction) {
   assertTransactionDeposit(transaction);
-  const { sourceHash, data, from: from14, gas, isSystemTx, mint, to, value } = transaction;
+  const { sourceHash, data, from: from16, gas, isSystemTx, mint, to, value } = transaction;
   const serializedTransaction = [
     sourceHash,
-    from14,
+    from16,
     to ?? "0x",
     mint ? toHex(mint) : "0x",
     value ? toHex(value) : "0x",
@@ -29934,9 +31150,9 @@ function isDeposit(transaction) {
   return false;
 }
 function assertTransactionDeposit(transaction) {
-  const { from: from14, to } = transaction;
-  if (from14 && !isAddress(from14))
-    throw new InvalidAddressError({ address: from14 });
+  const { from: from16, to } = transaction;
+  if (from16 && !isAddress(from16))
+    throw new InvalidAddressError({ address: from16 });
   if (to && !isAddress(to))
     throw new InvalidAddressError({ address: to });
 }
@@ -30190,13 +31406,20 @@ var init_eduChain = __esm({
       },
       rpcUrls: {
         default: {
-          http: ["https://rpc.edu-chain.raas.gelato.cloud"]
+          http: ["https://rpc.educhain.xyz"],
+          webSocket: ["wss://rpc.educhain.xyz"]
         }
       },
       blockExplorers: {
         default: {
           name: "EDU Chain Explorer",
-          url: "https://educhain.blockscout.com/"
+          url: "https://explorer.educhain.xyz/"
+        }
+      },
+      contracts: {
+        multicall3: {
+          address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+          blockCreated: 16410660
         }
       },
       testnet: false
@@ -30361,7 +31584,7 @@ var init_polygonAmoy = __esm({
       nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
       rpcUrls: {
         default: {
-          http: ["https://rpc-amoy.polygon.technology"]
+          http: ["https://polygon-amoy.drpc.org"]
         }
       },
       blockExplorers: {
@@ -30453,11 +31676,11 @@ var init_story = __esm({
     init_defineChain();
     story = /* @__PURE__ */ defineChain({
       id: 1514,
-      name: "Story",
+      name: "Data Network",
       nativeCurrency: {
         decimals: 18,
-        name: "IP Token",
-        symbol: "IP"
+        name: "DATA",
+        symbol: "DATA"
       },
       contracts: {
         multicall3: {
@@ -30474,13 +31697,13 @@ var init_story = __esm({
         }
       },
       rpcUrls: {
-        default: { http: ["https://mainnet.storyrpc.io"] }
+        default: { http: ["https://mainnet.datarpc.io"] }
       },
       blockExplorers: {
         default: {
-          name: "Story explorer",
-          url: "https://storyscan.io",
-          apiUrl: "https://storyscan.io/api/v2"
+          name: "Data Network explorer",
+          url: "https://datanetscan.io",
+          apiUrl: "https://datanetscan.io/api/v2"
         }
       },
       ensTlds: [".ip"],
@@ -30585,9 +31808,9 @@ function alphabet(letters) {
 function join9(separator = "") {
   astr("join", separator);
   return {
-    encode: (from14) => {
-      astrArr("join.decode", from14);
-      return from14.join(separator);
+    encode: (from16) => {
+      astrArr("join.decode", from16);
+      return from16.join(separator);
     },
     decode: (to) => {
       astr("join.decode", to);
@@ -30595,9 +31818,9 @@ function join9(separator = "") {
     }
   };
 }
-function convertRadix(data, from14, to) {
-  if (from14 < 2)
-    throw new Error(`convertRadix: invalid from=${from14}, base cannot be less than 2`);
+function convertRadix(data, from16, to) {
+  if (from16 < 2)
+    throw new Error(`convertRadix: invalid from=${from16}, base cannot be less than 2`);
   if (to < 2)
     throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
   aArr(data);
@@ -30607,26 +31830,26 @@ function convertRadix(data, from14, to) {
   const res = [];
   const digits = Array.from(data, (d) => {
     anumber3(d);
-    if (d < 0 || d >= from14)
+    if (d < 0 || d >= from16)
       throw new Error(`invalid integer: ${d}`);
     return d;
   });
   const dlen = digits.length;
   while (true) {
-    let carry = 0;
+    let carry2 = 0;
     let done = true;
     for (let i = pos; i < dlen; i++) {
       const digit = digits[i];
-      const fromCarry = from14 * carry;
+      const fromCarry = from16 * carry2;
       const digitBase = fromCarry + digit;
-      if (!Number.isSafeInteger(digitBase) || fromCarry / from14 !== carry || digitBase - digit !== fromCarry) {
+      if (!Number.isSafeInteger(digitBase) || fromCarry / from16 !== carry2 || digitBase - digit !== fromCarry) {
         throw new Error("convertRadix: carry overflow");
       }
       const div = digitBase / to;
-      carry = digitBase % to;
+      carry2 = digitBase % to;
       const rounded = Math.floor(div);
       digits[i] = rounded;
-      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+      if (!Number.isSafeInteger(rounded) || rounded * to + carry2 !== digitBase)
         throw new Error("convertRadix: carry overflow");
       if (!done)
         continue;
@@ -30635,7 +31858,7 @@ function convertRadix(data, from14, to) {
       else
         done = false;
     }
-    res.push(carry);
+    res.push(carry2);
     if (done)
       break;
   }
@@ -37096,7 +38319,7 @@ var require_permessage_deflate = __commonJS({
       acceptAsServer(offers) {
         const opts = this._options;
         const accepted = offers.find((params) => {
-          if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) {
+          if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && (typeof params.client_max_window_bits === "number" ? opts.clientMaxWindowBits > params.client_max_window_bits : !params.client_max_window_bits)) {
             return false;
           }
           return true;
@@ -37665,6 +38888,7 @@ var require_receiver = __commonJS({
         this._opcode = 0;
         this._totalPayloadLength = 0;
         this._messageLength = 0;
+        this._numFragments = 0;
         this._fragments = [];
         this._errored = false;
         this._loop = false;
@@ -38015,23 +39239,23 @@ var require_receiver = __commonJS({
           this.controlMessage(data, cb);
           return;
         }
+        if (this._maxFragments > 0 && ++this._numFragments > this._maxFragments) {
+          const error = this.createError(
+            RangeError,
+            "Too many message fragments",
+            false,
+            1008,
+            "WS_ERR_TOO_MANY_BUFFERED_PARTS"
+          );
+          cb(error);
+          return;
+        }
         if (this._compressed) {
           this._state = INFLATING;
           this.decompress(data, cb);
           return;
         }
         if (data.length) {
-          if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
-            const error = this.createError(
-              RangeError,
-              "Too many message fragments",
-              false,
-              1008,
-              "WS_ERR_TOO_MANY_BUFFERED_PARTS"
-            );
-            cb(error);
-            return;
-          }
           this._messageLength = this._totalPayloadLength;
           this._fragments.push(data);
         }
@@ -38061,17 +39285,6 @@ var require_receiver = __commonJS({
               cb(error);
               return;
             }
-            if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
-              const error = this.createError(
-                RangeError,
-                "Too many message fragments",
-                false,
-                1008,
-                "WS_ERR_TOO_MANY_BUFFERED_PARTS"
-              );
-              cb(error);
-              return;
-            }
             this._fragments.push(buf);
           }
           this.dataMessage(cb);
@@ -38094,6 +39307,7 @@ var require_receiver = __commonJS({
         this._totalPayloadLength = 0;
         this._messageLength = 0;
         this._fragmented = 0;
+        this._numFragments = 0;
         this._fragments = [];
         if (this._opcode === 2) {
           let data;
@@ -39088,7 +40302,7 @@ var require_extension = __commonJS({
       }
       return offers;
     }
-    function format(extensions) {
+    function format2(extensions) {
       return Object.keys(extensions).map((extension2) => {
         let configurations = extensions[extension2];
         if (!Array.isArray(configurations)) configurations = [configurations];
@@ -39103,7 +40317,7 @@ var require_extension = __commonJS({
         }).join(", ");
       }).join(", ");
     }
-    module.exports = { format, parse };
+    module.exports = { format: format2, parse };
   }
 });
 
@@ -39137,7 +40351,7 @@ var require_websocket = __commonJS({
     var {
       EventTarget: { addEventListener, removeEventListener }
     } = require_event_target();
-    var { format, parse } = require_extension();
+    var { format: format2, parse } = require_extension();
     var { toBuffer } = require_buffer_util();
     var kAborted = /* @__PURE__ */ Symbol("kAborted");
     var protocolVersions = [8, 13];
@@ -39594,8 +40808,8 @@ var require_websocket = __commonJS({
         autoPong: true,
         closeTimeout: CLOSE_TIMEOUT,
         protocolVersion: protocolVersions[1],
-        maxBufferedChunks: 1024 * 1024,
-        maxFragments: 128 * 1024,
+        maxBufferedChunks: 256 * 1024,
+        maxFragments: 16 * 1024,
         maxPayload: 100 * 1024 * 1024,
         skipUTF8Validation: false,
         perMessageDeflate: true,
@@ -39677,7 +40891,7 @@ var require_websocket = __commonJS({
           isServer: false,
           maxPayload: opts.maxPayload
         });
-        opts.headers["Sec-WebSocket-Extensions"] = format({
+        opts.headers["Sec-WebSocket-Extensions"] = format2({
           [PerMessageDeflate2.extensionName]: perMessageDeflate.offer()
         });
       }
@@ -40182,9 +41396,9 @@ var require_websocket_server = __commonJS({
        *     called
        * @param {Function} [options.handleProtocols] A hook to handle protocols
        * @param {String} [options.host] The hostname where to bind the server
-       * @param {Number} [options.maxBufferedChunks=1048576] The maximum number of
+       * @param {Number} [options.maxBufferedChunks=262144] The maximum number of
        *     buffered data chunks
-       * @param {Number} [options.maxFragments=131072] The maximum number of message
+       * @param {Number} [options.maxFragments=16384] The maximum number of message
        *     fragments
        * @param {Number} [options.maxPayload=104857600] The maximum allowed message
        *     size
@@ -40207,8 +41421,8 @@ var require_websocket_server = __commonJS({
         options = {
           allowSynchronousEvents: true,
           autoPong: true,
-          maxBufferedChunks: 1024 * 1024,
-          maxFragments: 128 * 1024,
+          maxBufferedChunks: 256 * 1024,
+          maxFragments: 16 * 1024,
           maxPayload: 100 * 1024 * 1024,
           skipUTF8Validation: false,
           perMessageDeflate: false,
@@ -42645,7 +43859,7 @@ function encodePayment(payment) {
   }
   throw new Error("Invalid network");
 }
-async function signAuthorization3(walletClient, { from: from14, to, value, validAfter, validBefore, nonce }, { asset, network, extra }) {
+async function signAuthorization3(walletClient, { from: from16, to, value, validAfter, validBefore, nonce }, { asset, network, extra }) {
   const chainId = getNetworkId(network);
   const name = extra?.name;
   const version4 = extra?.version;
@@ -42659,7 +43873,7 @@ async function signAuthorization3(walletClient, { from: from14, to, value, valid
     },
     primaryType: "TransferWithAuthorization",
     message: {
-      from: getAddress(from14),
+      from: getAddress(from16),
       to: getAddress(to),
       value,
       validAfter,
@@ -42689,7 +43903,7 @@ function createNonce() {
   );
   return toHex(cryptoObj.getRandomValues(new Uint8Array(32)));
 }
-function preparePaymentHeader(from14, x402Version, paymentRequirements) {
+function preparePaymentHeader(from16, x402Version, paymentRequirements) {
   const nonce = createNonce();
   const validAfter = BigInt(
     Math.floor(Date.now() / 1e3) - 600
@@ -42705,7 +43919,7 @@ function preparePaymentHeader(from14, x402Version, paymentRequirements) {
     payload: {
       signature: void 0,
       authorization: {
-        from: from14,
+        from: from16,
         to: paymentRequirements.payTo,
         value: paymentRequirements.maxAmountRequired,
         validAfter: validAfter.toString(),
@@ -42730,8 +43944,8 @@ async function signPaymentHeader(client, paymentRequirements, unsignedPaymentHea
   };
 }
 async function createPayment(client, x402Version, paymentRequirements) {
-  const from14 = isSignerWallet(client) ? client.account.address : client.address;
-  const unsignedPaymentHeader = preparePaymentHeader(from14, x402Version, paymentRequirements);
+  const from16 = isSignerWallet(client) ? client.account.address : client.address;
+  const unsignedPaymentHeader = preparePaymentHeader(from16, x402Version, paymentRequirements);
   return signPaymentHeader(client, paymentRequirements, unsignedPaymentHeader);
 }
 async function createPaymentHeader(client, x402Version, paymentRequirements) {
@@ -45961,7 +47175,7 @@ var COMMAND_REGISTRY = [
   },
   {
     name: "provider",
-    usage: "/provider [x402|venice|openrouter]",
+    usage: "/provider [blockrun|x402|venice|openrouter]",
     summary: "Show or select this session's LLM provider (validated immediately)",
     execute: async (rest, { session, state }) => {
       const config2 = await loadConfig();
@@ -45973,7 +47187,7 @@ var COMMAND_REGISTRY = [
         throw new Error("provider selection is unavailable in demo mode");
       }
       if (!isProviderId(rest[0])) {
-        throw new Error("/provider supports x402, venice, or openrouter");
+        throw new Error("/provider supports blockrun, x402, venice, or openrouter");
       }
       const providerId = rest[0];
       const provider = sharedTypedProvider(providerId, { timeoutMs: config2.llmTimeoutMs, x402ProxyUrl: config2.x402ProxyUrl });
@@ -46245,7 +47459,7 @@ async function sessionHasPendingReviews(session) {
 }
 function activeProviderId(session, fallback) {
   const recorded = session.models?.provider;
-  return recorded === "venice" || recorded === "openrouter" ? recorded : fallback;
+  return isProviderId(recorded) ? recorded : fallback;
 }
 async function updateSessionModels(session, change) {
   const config2 = await loadConfig();
@@ -47170,7 +48384,7 @@ async function configCommand(args) {
   switch (key) {
     case "provider": {
       if (!isProviderId(value)) {
-        throw new Error("provider must be x402, venice, or openrouter");
+        throw new Error("provider must be blockrun, x402, venice, or openrouter");
       }
       await updateConfig({ provider: value });
       break;