tenjin-cli 0.1.0-alpha.0 → 0.1.0-alpha.1

package/dist/{chunk-PAAL45FJ.js → chunk-IPOWB3G3.js}

@@ -7,19 +7,19 @@ import {
   hashAuthorization,
   hashMessage,
   hashTypedData,
+  keccak256 as keccak2562,
   publicKeyToAddress,
   serializeSignature,
   serializeTransaction,
   toBlobSidecars,
   toRlp
-} from "./chunk-SXQQ2ZSR.js";
+} from "./chunk-T4LKNY7T.js";
 import {
   secp256k1
-} from "./chunk-TX5T3LKJ.js";
+} from "./chunk-Q53IYV2G.js";
 import {
   AtomicReadyWalletRejectedUpgradeError,
   AtomicityNotSupportedError,
-  BaseError as BaseError2,
   BundleTooLargeError,
   CallExecutionError,
   ChainDisconnectedError,
@@ -28,7 +28,6 @@ import {
   ContractFunctionZeroDataError,
   DuplicateIdError,
   HttpRequestError,
-  IntegerOutOfRangeError,
   InternalRpcError,
   InvalidInputRpcError,
   InvalidParamsRpcError,
@@ -58,7 +57,6 @@ import {
   addressResolverAbi,
   assertRequest,
   call,
-  concat as concat2,
   createBatchScheduler,
   decodeAbiParameters,
   decodeFunctionResult,
@@ -75,14 +73,6 @@ import {
   formatAbiParameters,
   formatBlockParameter,
   formatTransactionRequest,
-  from,
-  from2,
-  fromBoolean,
-  fromBytes,
-  fromHex,
-  fromNumber,
-  fromString,
-  fromString2,
   getAbiItem,
   getAbortError,
   getCallError,
@@ -93,32 +83,16 @@ import {
   localBatchGatewayUrl,
   multicall3Abi,
   multicall3Bytecode,
-  padLeft,
-  padRight,
   parseAbiItem,
   parseAbiParameters,
   serializeStateOverride,
-  size as size2,
-  size2 as size3,
-  slice as slice2,
-  slice2 as slice3,
-  stringify as stringify2,
   textResolverAbi,
-  toBigInt,
-  toBoolean,
   toEventSelector,
-  toNumber,
-  toNumber2,
   toRpc,
-  toString,
-  trimLeft,
-  trimLeft2,
   universalResolverResolveAbi,
   universalResolverReverseAbi,
-  validate,
-  validate2,
   withResolvers
-} from "./chunk-WOHCAMDQ.js";
+} from "./chunk-LPRVHM7P.js";
 import {
   AbiDecodingDataSizeTooSmallError,
   AbiDecodingZeroDataError,
@@ -126,8 +100,10 @@ import {
   AbiEventSignatureEmptyTopicsError,
   AbiEventSignatureNotFoundError,
   BaseError,
+  BaseError2,
   DecodeLogDataMismatch,
   DecodeLogTopicsMismatch,
+  IntegerOutOfRangeError,
   InvalidAddressError,
   LruMap,
   PositionOutOfBoundsError,
@@ -139,12 +115,20 @@ import {
   WaitForTransactionReceiptTimeoutError,
   bytesToHex,
   concat,
+  concat2,
   concatHex,
   encodeAbiParameters,
   formatAbiItem,
   formatEther,
   formatGwei,
   formatUnits,
+  from,
+  fromBoolean,
+  fromBytes,
+  fromHex,
+  fromNumber,
+  fromString,
+  fromString2,
   getAddress,
   hexToBigInt,
   hexToBool,
@@ -152,18 +136,33 @@ import {
   isAddress,
   isHex,
   keccak256,
-  keccak_256,
   numberToHex,
+  padLeft,
+  padRight,
   parseAccount,
   prettyPrint,
   size,
+  size2,
+  size3,
   slice,
+  slice2,
+  slice3,
   stringToBytes,
   stringify,
+  stringify2,
+  toBigInt,
+  toBoolean,
   toBytes,
   toHex,
-  trim
-} from "./chunk-F5DZJLU3.js";
+  toNumber,
+  toNumber2,
+  toString,
+  trim,
+  trimLeft,
+  trimLeft2,
+  validate,
+  validate2
+} from "./chunk-BRJHUQSY.js";
 import {
   __export
 } from "./chunk-3IMLRUZE.js";
@@ -303,7 +302,7 @@ function getContractError(err, { abi: abi2, address, args, docsPath: docsPath3,
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/recoverPublicKey.js
 async function recoverPublicKey({ hash: hash2, signature }) {
   const hashHex = isHex(hash2) ? hash2 : toHex(hash2);
-  const { secp256k1: secp256k12 } = await import("./secp256k1-35YNNB6F.js");
+  const { secp256k1: secp256k12 } = await import("./secp256k1-BEZS642W.js");
   const signature_ = (() => {
     if (typeof signature === "object" && "r" in signature && "s" in signature) {
       const { r, s, v, yParity } = signature;
@@ -869,14 +868,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: from13, 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 } : {},
+      ...from13 ? { from: from13 } : {},
       ...type2 && !request.type ? { type: type2 } : {},
       ...typeof chainId2 !== "undefined" ? { chainId: chainId2 } : {},
       ...typeof gas2 !== "undefined" ? { gas: gas2 } : {},
@@ -3295,7 +3294,7 @@ var SignatureErc8010_exports = {};
 __export(SignatureErc8010_exports, {
   InvalidWrappedSignatureError: () => InvalidWrappedSignatureError,
   assert: () => assert4,
-  from: () => from9,
+  from: () => from8,
   magicBytes: () => magicBytes,
   suffixParameters: () => suffixParameters,
   unwrap: () => unwrap,
@@ -3340,15 +3339,6 @@ var caches = {
 };
 var checksum = caches.checksum;
 
-// node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/Hash.js
-function keccak2562(value, options = {}) {
-  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options;
-  const bytes = keccak_256(from(value));
-  if (as === "Bytes")
-    return bytes;
-  return fromBytes(bytes);
-}
-
 // node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/PublicKey.js
 function assert(publicKey, options = {}) {
   const { compressed } = options;
@@ -3371,11 +3361,11 @@ function assert(publicKey, options = {}) {
   }
   throw new InvalidError({ publicKey });
 }
-function from3(value) {
+function from2(value) {
   const publicKey = (() => {
-    if (validate2(value))
-      return fromHex2(value);
     if (validate(value))
+      return fromHex2(value);
+    if (validate2(value))
       return fromBytes2(value);
     const { prefix, x, y } = value;
     if (typeof x === "bigint" && typeof y === "bigint")
@@ -3392,8 +3382,8 @@ function fromHex2(publicKey) {
   if (publicKey.length !== 132 && publicKey.length !== 130 && publicKey.length !== 68)
     throw new InvalidSerializedSizeError({ publicKey });
   if (publicKey.length === 130) {
-    const x2 = BigInt(slice3(publicKey, 0, 32));
-    const y = BigInt(slice3(publicKey, 32, 64));
+    const x2 = BigInt(slice2(publicKey, 0, 32));
+    const y = BigInt(slice2(publicKey, 32, 64));
     return {
       prefix: 4,
       x: x2,
@@ -3401,17 +3391,17 @@ function fromHex2(publicKey) {
     };
   }
   if (publicKey.length === 132) {
-    const prefix2 = Number(slice3(publicKey, 0, 1));
-    const x2 = BigInt(slice3(publicKey, 1, 33));
-    const y = BigInt(slice3(publicKey, 33, 65));
+    const prefix2 = Number(slice2(publicKey, 0, 1));
+    const x2 = BigInt(slice2(publicKey, 1, 33));
+    const y = BigInt(slice2(publicKey, 33, 65));
     return {
       prefix: prefix2,
       x: x2,
       y
     };
   }
-  const prefix = Number(slice3(publicKey, 0, 1));
-  const x = BigInt(slice3(publicKey, 1, 33));
+  const prefix = Number(slice2(publicKey, 0, 1));
+  const x = BigInt(slice2(publicKey, 1, 33));
   return {
     prefix,
     x
@@ -3486,7 +3476,7 @@ var InvalidSerializedSizeError = class extends BaseError2 {
     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 ${size2(from(publicKey))} bytes.`
       ]
     });
     Object.defineProperty(this, "name", {
@@ -3522,7 +3512,7 @@ function checksum2(address) {
     return checksum.get(address);
   assert2(address, { strict: false });
   const hexAddress = address.substring(2).toLowerCase();
-  const hash2 = keccak2562(fromString(hexAddress), { as: "Bytes" });
+  const hash2 = keccak2562(fromString2(hexAddress), { as: "Bytes" });
   const characters = hexAddress.split("");
   for (let i = 0; i < 40; i += 2) {
     if (hash2[i >> 1] >> 4 >= 8 && characters[i]) {
@@ -3536,7 +3526,7 @@ function checksum2(address) {
   checksum.set(address, result);
   return result;
 }
-function from4(address, options = {}) {
+function from3(address, options = {}) {
   const { checksum: checksumVal = false } = options;
   assert2(address);
   if (checksumVal)
@@ -3545,7 +3535,7 @@ function from4(address, options = {}) {
 }
 function fromPublicKey(publicKey, options = {}) {
   const address = keccak2562(`0x${toHex2(publicKey).slice(4)}`).substring(26);
-  return from4(`0x${address}`, options);
+  return from3(`0x${address}`, options);
 }
 function validate3(address, options = {}) {
   const { strict = true } = options ?? {};
@@ -3724,16 +3714,16 @@ function decodeAddress2(cursor, options = {}) {
   const { checksum: checksum3 = false } = options;
   const value = cursor.readBytes(32);
   const wrap3 = (address) => checksum3 ? checksum2(address) : address;
-  return [wrap3(fromBytes(slice2(value, -20))), 32];
+  return [wrap3(fromBytes(slice3(value, -20))), 32];
 }
 function decodeArray(cursor, param, options) {
   const { checksumAddress, length, staticPosition } = options;
   if (!length) {
-    const offset = toNumber(cursor.readBytes(sizeOfOffset));
+    const offset = toNumber2(cursor.readBytes(sizeOfOffset));
     const start = staticPosition + offset;
     const startOfData = start + sizeOfLength;
     cursor.setPosition(start);
-    const length2 = toNumber(cursor.readBytes(sizeOfLength));
+    const length2 = toNumber2(cursor.readBytes(sizeOfLength));
     const dynamicChild = hasDynamicChild(param);
     let consumed2 = 0;
     const value2 = [];
@@ -3750,7 +3740,7 @@ function decodeArray(cursor, param, options) {
     return [value2, 32];
   }
   if (hasDynamicChild(param)) {
-    const offset = toNumber(cursor.readBytes(sizeOfOffset));
+    const offset = toNumber2(cursor.readBytes(sizeOfOffset));
     const start = staticPosition + offset;
     const value2 = [];
     for (let i = 0; i < length; ++i) {
@@ -3782,9 +3772,9 @@ function decodeBool(cursor) {
 function decodeBytes(cursor, param, { staticPosition }) {
   const [_, size5] = param.type.split("bytes");
   if (!size5) {
-    const offset = toNumber(cursor.readBytes(32));
+    const offset = toNumber2(cursor.readBytes(32));
     cursor.setPosition(staticPosition + offset);
-    const length = toNumber(cursor.readBytes(32));
+    const length = toNumber2(cursor.readBytes(32));
     if (length === 0) {
       cursor.setPosition(staticPosition + 32);
       return ["0x", 32];
@@ -3801,7 +3791,7 @@ function decodeNumber(cursor, param) {
   const size5 = Number.parseInt(param.type.split("int")[1] || "256", 10);
   const value = cursor.readBytes(32);
   return [
-    size5 > 48 ? toBigInt(value, { signed }) : toNumber(value, { signed }),
+    size5 > 48 ? toBigInt(value, { signed }) : toNumber2(value, { signed }),
     32
   ];
 }
@@ -3811,7 +3801,7 @@ function decodeTuple(cursor, param, options) {
   const value = hasUnnamedChild ? [] : {};
   let consumed = 0;
   if (hasDynamicChild(param)) {
-    const offset = toNumber(cursor.readBytes(sizeOfOffset));
+    const offset = toNumber2(cursor.readBytes(sizeOfOffset));
     const start = staticPosition + offset;
     for (let i = 0; i < param.components.length; ++i) {
       const component = param.components[i];
@@ -3838,16 +3828,16 @@ function decodeTuple(cursor, param, options) {
   return [value, consumed];
 }
 function decodeString(cursor, { staticPosition }) {
-  const offset = toNumber(cursor.readBytes(32));
+  const offset = toNumber2(cursor.readBytes(32));
   const start = staticPosition + offset;
   cursor.setPosition(start);
-  const length = toNumber(cursor.readBytes(32));
+  const length = toNumber2(cursor.readBytes(32));
   if (length === 0) {
     cursor.setPosition(staticPosition + 32);
     return ["", 32];
   }
   const data = cursor.readBytes(length, 32);
-  const value = toString(trimLeft(data));
+  const value = toString(trimLeft2(data));
   cursor.setPosition(staticPosition + 32);
   return [value, 32];
 }
@@ -3913,7 +3903,7 @@ function encode(preparedParameters) {
     if (dynamic)
       staticSize += 32;
     else
-      staticSize += size3(encoded);
+      staticSize += size2(encoded);
   }
   const staticParameters = [];
   const dynamicParameters = [];
@@ -3923,7 +3913,7 @@ function encode(preparedParameters) {
     if (dynamic) {
       staticParameters.push(fromNumber(staticSize + dynamicSize, { size: 32 }));
       dynamicParameters.push(encoded);
-      dynamicSize += size3(encoded);
+      dynamicSize += size2(encoded);
     } else {
       staticParameters.push(encoded);
     }
@@ -3980,7 +3970,7 @@ function encodeArray(value, options) {
 }
 function encodeBytes(value, { type }) {
   const [, parametersize] = type.split("bytes");
-  const bytesSize = size3(value);
+  const bytesSize = size2(value);
   if (!parametersize) {
     let value_ = value;
     if (bytesSize % 32 !== 0)
@@ -4024,15 +4014,15 @@ function encodeNumber(value, { signed, size: size5 }) {
   };
 }
 function encodeString(value) {
-  const hexValue = fromString2(value);
-  const partsLength = Math.ceil(size3(hexValue) / 32);
+  const hexValue = fromString(value);
+  const partsLength = Math.ceil(size2(hexValue) / 32);
   const parts = [];
   for (let i = 0; i < partsLength; i++) {
-    parts.push(padRight(slice3(hexValue, i * 32, (i + 1) * 32)));
+    parts.push(padRight(slice2(hexValue, i * 32, (i + 1) * 32)));
   }
   return {
     dynamic: true,
-    encoded: concat2(padRight(fromNumber(size3(hexValue), { size: 32 })), ...parts)
+    encoded: concat2(padRight(fromNumber(size2(hexValue), { size: 32 })), ...parts)
   };
 }
 function encodeTuple(value, options) {
@@ -4289,13 +4279,13 @@ function decode(parameters, data, options = {}) {
   const { as = "Array", checksumAddress = false } = options;
   const bytes = typeof data === "string" ? fromHex(data) : data;
   const cursor = create(bytes);
-  if (size2(bytes) === 0 && parameters.length > 0)
+  if (size3(bytes) === 0 && parameters.length > 0)
     throw new ZeroDataError();
-  if (size2(bytes) && size2(bytes) < 32)
+  if (size3(bytes) && size3(bytes) < 32)
     throw new DataSizeTooSmallError({
       data: typeof data === "string" ? data : fromBytes(data),
       parameters,
-      size: size2(bytes)
+      size: size3(bytes)
     });
   let consumed = 0;
   const values = as === "Array" ? [] : {};
@@ -4353,7 +4343,7 @@ function encodePacked(types, values) {
       return padLeft(address.toLowerCase(), isArray ? 32 : 0);
     }
     if (type === "string")
-      return fromString2(value);
+      return fromString(value);
     if (type === "bytes")
       return value;
     if (type === "bool")
@@ -4392,7 +4382,7 @@ function encodePacked(types, values) {
   }
   encodePacked2.encode = encode4;
 })(encodePacked || (encodePacked = {}));
-function from5(parameters) {
+function from4(parameters) {
   if (Array.isArray(parameters) && typeof parameters[0] === "string")
     return parseAbiParameters(parameters);
   if (typeof parameters === "string")
@@ -4439,7 +4429,7 @@ var ArrayLengthMismatchError = class extends BaseError2 {
 };
 var BytesSizeMismatchError = class extends BaseError2 {
   constructor({ expectedSize, value }) {
-    super(`Size of bytes "${value}" (bytes${size3(value)}) does not match expected size (bytes${expectedSize}).`);
+    super(`Size of bytes "${value}" (bytes${size2(value)}) does not match expected size (bytes${expectedSize}).`);
     Object.defineProperty(this, "name", {
       enumerable: true,
       configurable: true,
@@ -4487,7 +4477,7 @@ var InvalidTypeError = class extends BaseError2 {
 };
 
 // node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/Rlp.js
-function from6(value, options) {
+function from5(value, options) {
   const { as } = options;
   const encodable = getEncodable(value);
   const cursor = create(new Uint8Array(encodable.length));
@@ -4498,7 +4488,7 @@ function from6(value, options) {
 }
 function fromHex3(hex, options = {}) {
   const { as = "Hex" } = options;
-  return from6(hex, { as });
+  return from5(hex, { as });
 }
 function getEncodable(bytes) {
   if (Array.isArray(bytes))
@@ -4602,8 +4592,8 @@ function fromBytes3(signature) {
 function fromHex4(signature) {
   if (signature.length !== 130 && signature.length !== 132)
     throw new InvalidSerializedSizeError2({ signature });
-  const r = BigInt(slice3(signature, 0, 32));
-  const s = BigInt(slice3(signature, 32, 64));
+  const r = BigInt(slice2(signature, 0, 32));
+  const s = BigInt(slice2(signature, 32, 64));
   const yParity = (() => {
     const yParity2 = Number(`0x${signature.slice(130)}`);
     if (Number.isNaN(yParity2))
@@ -4630,9 +4620,9 @@ function extract2(value) {
     return void 0;
   if (typeof value.s === "undefined")
     return void 0;
-  return from7(value);
+  return from6(value);
 }
-function from7(signature) {
+function from6(signature) {
   const signature_ = (() => {
     if (typeof signature === "string")
       return fromHex4(signature);
@@ -4678,8 +4668,8 @@ function toTuple(signature) {
   const { r, s, yParity } = signature;
   return [
     yParity ? "0x01" : "0x",
-    r === 0n ? "0x" : trimLeft2(fromNumber(r)),
-    s === 0n ? "0x" : trimLeft2(fromNumber(s))
+    r === 0n ? "0x" : trimLeft(fromNumber(r)),
+    s === 0n ? "0x" : trimLeft(fromNumber(s))
   ];
 }
 function vToYParity(v) {
@@ -4696,7 +4686,7 @@ var InvalidSerializedSizeError2 = class extends BaseError2 {
     super(`Value \`${signature}\` is an invalid signature size.`, {
       metaMessages: [
         "Expected: 64 bytes or 65 bytes.",
-        `Received ${size3(from2(signature))} bytes.`
+        `Received ${size2(from(signature))} bytes.`
       ]
     });
     Object.defineProperty(this, "name", {
@@ -4764,7 +4754,7 @@ var InvalidVError = class extends BaseError2 {
 };
 
 // node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/Authorization.js
-function from8(authorization, options = {}) {
+function from7(authorization, options = {}) {
   if (typeof authorization.chainId === "string")
     return fromRpc2(authorization);
   return { ...authorization, ...options.signature };
@@ -4809,32 +4799,32 @@ function recoverPublicKey2(options) {
   const { payload, signature } = options;
   const { r, s, yParity } = signature;
   const signature_ = new secp256k1.Signature(BigInt(r), BigInt(s)).addRecoveryBit(yParity);
-  const point = signature_.recoverPublicKey(from2(payload).substring(2));
-  return from3(point);
+  const point = signature_.recoverPublicKey(from(payload).substring(2));
+  return from2(point);
 }
 
 // node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/erc8010/SignatureErc8010.js
 var magicBytes = "0x8010801080108010801080108010801080108010801080108010801080108010";
-var suffixParameters = from5("(uint256 chainId, address delegation, uint256 nonce, uint8 yParity, uint256 r, uint256 s), address to, bytes data");
+var suffixParameters = from4("(uint256 chainId, address delegation, uint256 nonce, uint8 yParity, uint256 r, uint256 s), address to, bytes data");
 function assert4(value) {
   if (typeof value === "string") {
-    if (slice3(value, -32) !== magicBytes)
+    if (slice2(value, -32) !== magicBytes)
       throw new InvalidWrappedSignatureError(value);
   } else
     assert3(value.authorization);
 }
-function from9(value) {
+function from8(value) {
   if (typeof value === "string")
     return unwrap(value);
   return value;
 }
 function unwrap(wrapped) {
   assert4(wrapped);
-  const suffixLength = toNumber2(slice3(wrapped, -64, -32));
-  const suffix = slice3(wrapped, -suffixLength - 64, -64);
-  const signature = slice3(wrapped, 0, -suffixLength - 64);
+  const suffixLength = toNumber(slice2(wrapped, -64, -32));
+  const suffix = slice2(wrapped, -suffixLength - 64, -64);
+  const signature = slice2(wrapped, 0, -suffixLength - 64);
   const [auth, to, data] = decode(suffixParameters, suffix);
-  const authorization = from8({
+  const authorization = from7({
     address: auth.delegation,
     chainId: Number(auth.chainId),
     nonce: auth.nonce,
@@ -4853,7 +4843,7 @@ function wrap(value) {
   assert4(value);
   const self = recoverAddress2({
     payload: getSignPayload(value.authorization),
-    signature: from7(value.authorization)
+    signature: from6(value.authorization)
   });
   const suffix = encode2(suffixParameters, [
     {
@@ -4864,7 +4854,7 @@ function wrap(value) {
     value.to ?? self,
     data ?? "0x"
   ]);
-  const suffixLength = fromNumber(size3(suffix), { size: 32 });
+  const suffixLength = fromNumber(size2(suffix), { size: 32 });
   return concat2(signature, suffix, suffixLength, magicBytes);
 }
 function validate4(value) {
@@ -5329,7 +5319,7 @@ function getAmbiguousTypes(sourceParameters, targetParameters, args) {
 }
 
 // node_modules/.pnpm/ox@0.14.30_typescript@6.0.3_zod@4.4.3/node_modules/ox/_esm/core/AbiItem.js
-function from10(abiItem, options = {}) {
+function from9(abiItem, options = {}) {
   const { prepare = true } = options;
   const item = (() => {
     if (Array.isArray(abiItem))
@@ -5345,11 +5335,11 @@ function from10(abiItem, options = {}) {
 }
 function fromAbi(abi2, name, options) {
   const { args = [], prepare = true } = options ?? {};
-  const isSelector = validate2(name, { strict: false });
+  const isSelector = validate(name, { strict: false });
   const abiItems = abi2.filter((abiItem2) => {
     if (isSelector) {
       if (abiItem2.type === "function" || abiItem2.type === "error")
-        return getSelector(abiItem2) === slice3(name, 0, 4);
+        return getSelector(abiItem2) === slice2(name, 0, 4);
       if (abiItem2.type === "event")
         return getSignatureHash(abiItem2) === name;
       return false;
@@ -5423,7 +5413,7 @@ function getSelector(...parameters) {
     }
     return parameters[0];
   })();
-  return slice3(getSignatureHash(abiItem), 0, 4);
+  return slice2(getSignatureHash(abiItem), 0, 4);
 }
 function getSignature(...parameters) {
   const abiItem = (() => {
@@ -5450,7 +5440,7 @@ function getSignatureHash(...parameters) {
   })();
   if (typeof abiItem !== "string" && "hash" in abiItem && abiItem.hash)
     return abiItem.hash;
-  return keccak2562(fromString2(getSignature(abiItem)));
+  return keccak2562(fromString(getSignature(abiItem)));
 }
 var AmbiguityError = class extends BaseError2 {
   constructor(x, y) {
@@ -5503,8 +5493,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 from10(abiConstructor) {
+  return from9(abiConstructor);
 }
 function fromAbi2(abi2) {
   const item = abi2.find((item2) => item2.type === "constructor");
@@ -5531,8 +5521,8 @@ function encodeData(...parameters) {
   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 from11(abiFunction, options = {}) {
+  return from9(abiFunction, options);
 }
 function fromAbi3(abi2, name, options) {
   const item = fromAbi(abi2, name, options);
@@ -5555,11 +5545,11 @@ async function simulateCalls(client, parameters) {
   const account = parameters.account ? parseAccount(parameters.account) : void 0;
   if (traceAssetChanges && !account)
     throw new BaseError("`account` is required when `traceAssetChanges` is true");
-  const getBalanceData = account ? encode3(from11("constructor(bytes, bytes)"), {
+  const getBalanceData = account ? encode3(from10("constructor(bytes, bytes)"), {
     bytecode: deploylessCallViaBytecodeBytecode,
     args: [
       getBalanceCode,
-      encodeData(from12("function getBalance(address)"), [account.address])
+      encodeData(from11("function getBalance(address)"), [account.address])
     ]
   }) : void 0;
   const assetAddresses = traceAssetChanges ? await Promise.all(parameters.calls.map(async (call2) => {
@@ -5586,7 +5576,7 @@ async function simulateCalls(client, parameters) {
         {
           calls: assetAddresses.map((address, i) => ({
             abi: [
-              from12("function balanceOf(address) returns (uint256)")
+              from11("function balanceOf(address) returns (uint256)")
             ],
             functionName: "balanceOf",
             args: [account.address],
@@ -5618,7 +5608,7 @@ async function simulateCalls(client, parameters) {
         {
           calls: assetAddresses.map((address, i) => ({
             abi: [
-              from12("function balanceOf(address) returns (uint256)")
+              from11("function balanceOf(address) returns (uint256)")
             ],
             functionName: "balanceOf",
             args: [account.address],
@@ -5638,7 +5628,7 @@ async function simulateCalls(client, parameters) {
           calls: assetAddresses.map((address, i) => ({
             to: address,
             abi: [
-              from12("function decimals() returns (uint256)")
+              from11("function decimals() returns (uint256)")
             ],
             functionName: "decimals",
             from: zeroAddress,
@@ -5656,7 +5646,7 @@ async function simulateCalls(client, parameters) {
           calls: assetAddresses.map((address, i) => ({
             to: address,
             abi: [
-              from12("function tokenURI(uint256) returns (string)")
+              from11("function tokenURI(uint256) returns (string)")
             ],
             functionName: "tokenURI",
             args: [0n],
@@ -5674,7 +5664,7 @@ async function simulateCalls(client, parameters) {
         {
           calls: assetAddresses.map((address, i) => ({
             to: address,
-            abi: [from12("function symbol() returns (string)")],
+            abi: [from11("function symbol() returns (string)")],
             functionName: "symbol",
             from: zeroAddress,
             nonce: i
@@ -5750,7 +5740,7 @@ var SignatureErc6492_exports = {};
 __export(SignatureErc6492_exports, {
   InvalidWrappedSignatureError: () => InvalidWrappedSignatureError2,
   assert: () => assert5,
-  from: () => from13,
+  from: () => from12,
   magicBytes: () => magicBytes2,
   universalSignatureValidatorAbi: () => universalSignatureValidatorAbi,
   universalSignatureValidatorBytecode: () => universalSignatureValidatorBytecode,
@@ -5805,22 +5795,22 @@ var universalSignatureValidatorAbi = [
   }
 ];
 function assert5(wrapped) {
-  if (slice3(wrapped, -32) !== magicBytes2)
+  if (slice2(wrapped, -32) !== magicBytes2)
     throw new InvalidWrappedSignatureError2(wrapped);
 }
-function from13(wrapped) {
+function from12(wrapped) {
   if (typeof wrapped === "string")
     return unwrap2(wrapped);
   return wrapped;
 }
 function unwrap2(wrapped) {
   assert5(wrapped);
-  const [to, data, signature] = decode(from5("address, bytes, bytes"), wrapped);
+  const [to, data, signature] = decode(from4("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(from4("address, bytes, bytes"), [
     to,
     data,
     signature
@@ -6234,7 +6224,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: from13, nonce }) => from13 === replacedTransaction.from && nonce === replacedTransaction.nonce);
               if (!replacementTransaction)
                 return;
               receipt = await getAction(client, getTransactionReceipt, "getTransactionReceipt")({
@@ -7187,10 +7177,10 @@ var serializers = {
 };
 function serializeTransactionDeposit(transaction) {
   assertTransactionDeposit(transaction);
-  const { sourceHash, data, from: from14, gas, isSystemTx, mint, to, value } = transaction;
+  const { sourceHash, data, from: from13, gas, isSystemTx, mint, to, value } = transaction;
   const serializedTransaction = [
     sourceHash,
-    from14,
+    from13,
     to ?? "0x",
     mint ? toHex(mint) : "0x",
     value ? toHex(value) : "0x",
@@ -7211,9 +7201,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: from13, to } = transaction;
+  if (from13 && !isAddress(from13))
+    throw new InvalidAddressError({ address: from13 });
   if (to && !isAddress(to))
     throw new InvalidAddressError({ address: to });
 }
@@ -7304,4 +7294,4 @@ export {
   USDC_DECIMALS,
   getUsdcBalance
 };
-//# sourceMappingURL=chunk-PAAL45FJ.js.map
+//# sourceMappingURL=chunk-IPOWB3G3.js.map