damm-sdk 1.4.20 → 1.4.22

package/dist/index.cjs

@@ -41,6 +41,104 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// node_modules/abitype/dist/esm/regex.js
+function execTyped(regex, string) {
+  const match = regex.exec(string);
+  return match?.groups;
+}
+var init_regex = () => {};
+
+// node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
+function formatAbiParameter(abiParameter) {
+  let type = abiParameter.type;
+  if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
+    type = "(";
+    const length = abiParameter.components.length;
+    for (let i = 0;i < length; i++) {
+      const component = abiParameter.components[i];
+      type += formatAbiParameter(component);
+      if (i < length - 1)
+        type += ", ";
+    }
+    const result = execTyped(tupleRegex, abiParameter.type);
+    type += `)${result?.array ?? ""}`;
+    return formatAbiParameter({
+      ...abiParameter,
+      type
+    });
+  }
+  if ("indexed" in abiParameter && abiParameter.indexed)
+    type = `${type} indexed`;
+  if (abiParameter.name)
+    return `${type} ${abiParameter.name}`;
+  return type;
+}
+var tupleRegex;
+var init_formatAbiParameter = __esm(() => {
+  init_regex();
+  tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
+});
+
+// node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
+function formatAbiParameters(abiParameters) {
+  let params = "";
+  const length = abiParameters.length;
+  for (let i = 0;i < length; i++) {
+    const abiParameter = abiParameters[i];
+    params += formatAbiParameter(abiParameter);
+    if (i !== length - 1)
+      params += ", ";
+  }
+  return params;
+}
+var init_formatAbiParameters = __esm(() => {
+  init_formatAbiParameter();
+});
+
+// node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
+function formatAbiItem(abiItem) {
+  if (abiItem.type === "function")
+    return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${abiItem.outputs?.length ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
+  if (abiItem.type === "event")
+    return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
+  if (abiItem.type === "error")
+    return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
+  if (abiItem.type === "constructor")
+    return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
+  if (abiItem.type === "fallback")
+    return `fallback() external${abiItem.stateMutability === "payable" ? " payable" : ""}`;
+  return "receive() external payable";
+}
+var init_formatAbiItem = __esm(() => {
+  init_formatAbiParameters();
+});
+
+// node_modules/abitype/dist/esm/exports/index.js
+var init_exports = __esm(() => {
+  init_formatAbiItem();
+});
+
+// node_modules/viem/_esm/utils/abi/formatAbiItem.js
+function formatAbiItem2(abiItem, { includeName = false } = {}) {
+  if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
+    throw new InvalidDefinitionTypeError(abiItem.type);
+  return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
+}
+function formatAbiParams(params, { includeName = false } = {}) {
+  if (!params)
+    return "";
+  return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
+}
+function formatAbiParam(param, { includeName }) {
+  if (param.type.startsWith("tuple")) {
+    return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
+  }
+  return param.type + (includeName && param.name ? ` ${param.name}` : "");
+}
+var init_formatAbiItem2 = __esm(() => {
+  init_abi();
+});
+
 // node_modules/viem/_esm/utils/data/isHex.js
 function isHex(value, { strict = true } = {}) {
   if (!value)
@@ -149,6 +247,153 @@ var init_base = __esm(() => {
   };
 });
 
+// node_modules/viem/_esm/errors/abi.js
+var AbiDecodingDataSizeTooSmallError, AbiDecodingZeroDataError, AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiFunctionNotFoundError, AbiFunctionSignatureNotFoundError, AbiItemAmbiguityError, InvalidAbiEncodingTypeError, InvalidAbiDecodingTypeError, InvalidArrayError, InvalidDefinitionTypeError;
+var init_abi = __esm(() => {
+  init_formatAbiItem2();
+  init_size();
+  init_base();
+  AbiDecodingDataSizeTooSmallError = class AbiDecodingDataSizeTooSmallError extends BaseError {
+    constructor({ data, params, size: size2 }) {
+      super([`Data size of ${size2} bytes is too small for given parameters.`].join(`
+`), {
+        metaMessages: [
+          `Params: (${formatAbiParams(params, { includeName: true })})`,
+          `Data:   ${data} (${size2} bytes)`
+        ],
+        name: "AbiDecodingDataSizeTooSmallError"
+      });
+      Object.defineProperty(this, "data", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "params", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "size", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      this.data = data;
+      this.params = params;
+      this.size = size2;
+    }
+  };
+  AbiDecodingZeroDataError = class AbiDecodingZeroDataError extends BaseError {
+    constructor() {
+      super('Cannot decode zero data ("0x") with ABI parameters.', {
+        name: "AbiDecodingZeroDataError"
+      });
+    }
+  };
+  AbiEncodingArrayLengthMismatchError = class AbiEncodingArrayLengthMismatchError extends BaseError {
+    constructor({ expectedLength, givenLength, type }) {
+      super([
+        `ABI encoding array length mismatch for type ${type}.`,
+        `Expected length: ${expectedLength}`,
+        `Given length: ${givenLength}`
+      ].join(`
+`), { name: "AbiEncodingArrayLengthMismatchError" });
+    }
+  };
+  AbiEncodingBytesSizeMismatchError = class AbiEncodingBytesSizeMismatchError extends BaseError {
+    constructor({ expectedSize, value }) {
+      super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
+    }
+  };
+  AbiEncodingLengthMismatchError = class AbiEncodingLengthMismatchError extends BaseError {
+    constructor({ expectedLength, givenLength }) {
+      super([
+        "ABI encoding params/values length mismatch.",
+        `Expected length (params): ${expectedLength}`,
+        `Given length (values): ${givenLength}`
+      ].join(`
+`), { name: "AbiEncodingLengthMismatchError" });
+    }
+  };
+  AbiFunctionNotFoundError = class AbiFunctionNotFoundError extends BaseError {
+    constructor(functionName, { docsPath } = {}) {
+      super([
+        `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
+        "Make sure you are using the correct ABI and that the function exists on it."
+      ].join(`
+`), {
+        docsPath,
+        name: "AbiFunctionNotFoundError"
+      });
+    }
+  };
+  AbiFunctionSignatureNotFoundError = class AbiFunctionSignatureNotFoundError extends BaseError {
+    constructor(signature, { docsPath }) {
+      super([
+        `Encoded function signature "${signature}" not found on ABI.`,
+        "Make sure you are using the correct ABI and that the function exists on it.",
+        `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
+      ].join(`
+`), {
+        docsPath,
+        name: "AbiFunctionSignatureNotFoundError"
+      });
+    }
+  };
+  AbiItemAmbiguityError = class AbiItemAmbiguityError extends BaseError {
+    constructor(x, y) {
+      super("Found ambiguous types in overloaded ABI items.", {
+        metaMessages: [
+          `\`${x.type}\` in \`${formatAbiItem2(x.abiItem)}\`, and`,
+          `\`${y.type}\` in \`${formatAbiItem2(y.abiItem)}\``,
+          "",
+          "These types encode differently and cannot be distinguished at runtime.",
+          "Remove one of the ambiguous items in the ABI."
+        ],
+        name: "AbiItemAmbiguityError"
+      });
+    }
+  };
+  InvalidAbiEncodingTypeError = class InvalidAbiEncodingTypeError extends BaseError {
+    constructor(type, { docsPath }) {
+      super([
+        `Type "${type}" is not a valid encoding type.`,
+        "Please provide a valid ABI type."
+      ].join(`
+`), { docsPath, name: "InvalidAbiEncodingType" });
+    }
+  };
+  InvalidAbiDecodingTypeError = class InvalidAbiDecodingTypeError extends BaseError {
+    constructor(type, { docsPath }) {
+      super([
+        `Type "${type}" is not a valid decoding type.`,
+        "Please provide a valid ABI type."
+      ].join(`
+`), { docsPath, name: "InvalidAbiDecodingType" });
+    }
+  };
+  InvalidArrayError = class InvalidArrayError extends BaseError {
+    constructor(value) {
+      super([`Value "${value}" is not a valid array.`].join(`
+`), {
+        name: "InvalidArrayError"
+      });
+    }
+  };
+  InvalidDefinitionTypeError = class InvalidDefinitionTypeError extends BaseError {
+    constructor(type) {
+      super([
+        `"${type}" is not a valid definition type.`,
+        'Valid types: "function", "event", "error"'
+      ].join(`
+`), { name: "InvalidDefinitionTypeError" });
+    }
+  };
+});
+
 // node_modules/viem/_esm/errors/data.js
 var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
 var init_data = __esm(() => {
@@ -204,7 +449,7 @@ var init_pad = __esm(() => {
 });
 
 // node_modules/viem/_esm/errors/encoding.js
-var IntegerOutOfRangeError, SizeOverflowError;
+var IntegerOutOfRangeError, InvalidBytesBooleanError, SizeOverflowError;
 var init_encoding = __esm(() => {
   init_base();
   IntegerOutOfRangeError = class IntegerOutOfRangeError extends BaseError {
@@ -212,6 +457,13 @@ var init_encoding = __esm(() => {
       super(`Number "${value}" is not in safe ${size2 ? `${size2 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
     }
   };
+  InvalidBytesBooleanError = class InvalidBytesBooleanError extends BaseError {
+    constructor(bytes) {
+      super(`Bytes value "${bytes}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, {
+        name: "InvalidBytesBooleanError"
+      });
+    }
+  };
   SizeOverflowError = class SizeOverflowError extends BaseError {
     constructor({ givenSize, maxSize }) {
       super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
@@ -708,6 +960,93 @@ var init_keccak256 = __esm(() => {
   init_toHex();
 });
 
+// node_modules/viem/_esm/utils/hash/hashSignature.js
+function hashSignature(sig) {
+  return hash(sig);
+}
+var hash = (value) => keccak256(toBytes(value));
+var init_hashSignature = __esm(() => {
+  init_toBytes();
+  init_keccak256();
+});
+
+// node_modules/viem/_esm/utils/hash/normalizeSignature.js
+function normalizeSignature(signature) {
+  let active = true;
+  let current = "";
+  let level = 0;
+  let result = "";
+  let valid = false;
+  for (let i = 0;i < signature.length; i++) {
+    const char = signature[i];
+    if (["(", ")", ","].includes(char))
+      active = true;
+    if (char === "(")
+      level++;
+    if (char === ")")
+      level--;
+    if (!active)
+      continue;
+    if (level === 0) {
+      if (char === " " && ["event", "function", ""].includes(result))
+        result = "";
+      else {
+        result += char;
+        if (char === ")") {
+          valid = true;
+          break;
+        }
+      }
+      continue;
+    }
+    if (char === " ") {
+      if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
+        current = "";
+        active = false;
+      }
+      continue;
+    }
+    result += char;
+    current += char;
+  }
+  if (!valid)
+    throw new BaseError("Unable to normalize signature.");
+  return result;
+}
+var init_normalizeSignature = __esm(() => {
+  init_base();
+});
+
+// node_modules/viem/_esm/utils/hash/toSignature.js
+var toSignature = (def) => {
+  const def_ = (() => {
+    if (typeof def === "string")
+      return def;
+    return formatAbiItem(def);
+  })();
+  return normalizeSignature(def_);
+};
+var init_toSignature = __esm(() => {
+  init_exports();
+  init_normalizeSignature();
+});
+
+// node_modules/viem/_esm/utils/hash/toSignatureHash.js
+function toSignatureHash(fn) {
+  return hashSignature(toSignature(fn));
+}
+var init_toSignatureHash = __esm(() => {
+  init_hashSignature();
+  init_toSignature();
+});
+
+// node_modules/viem/_esm/utils/hash/toEventSelector.js
+var toEventSelector;
+var init_toEventSelector = __esm(() => {
+  init_toSignatureHash();
+  toEventSelector = toSignatureHash;
+});
+
 // node_modules/viem/_esm/errors/address.js
 var InvalidAddressError;
 var init_address = __esm(() => {
@@ -764,13 +1103,13 @@ function checksumAddress(address_, chainId) {
   if (checksumAddressCache.has(`${address_}.${chainId}`))
     return checksumAddressCache.get(`${address_}.${chainId}`);
   const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
-  const hash = keccak256(stringToBytes(hexAddress), "bytes");
+  const hash2 = keccak256(stringToBytes(hexAddress), "bytes");
   const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
   for (let i = 0;i < 40; i += 2) {
-    if (hash[i >> 1] >> 4 >= 8 && address[i]) {
+    if (hash2[i >> 1] >> 4 >= 8 && address[i]) {
       address[i] = address[i].toUpperCase();
     }
-    if ((hash[i >> 1] & 15) >= 8 && address[i + 1]) {
+    if ((hash2[i >> 1] & 15) >= 8 && address[i + 1]) {
       address[i + 1] = address[i + 1].toUpperCase();
     }
   }
@@ -820,11 +1159,38 @@ var init_isAddress = __esm(() => {
 });
 
 // node_modules/viem/_esm/utils/data/concat.js
+function concat(values) {
+  if (typeof values[0] === "string")
+    return concatHex(values);
+  return concatBytes(values);
+}
+function concatBytes(values) {
+  let length = 0;
+  for (const arr of values) {
+    length += arr.length;
+  }
+  const result = new Uint8Array(length);
+  let offset = 0;
+  for (const arr of values) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
 function concatHex(values) {
   return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
 }
 
 // node_modules/viem/_esm/utils/data/slice.js
+function slice(value, start, end, { strict } = {}) {
+  if (isHex(value, { strict: false }))
+    return sliceHex(value, start, end, {
+      strict
+    });
+  return sliceBytes(value, start, end, {
+    strict
+  });
+}
 function assertStartOffset(value, start) {
   if (typeof start === "number" && start > 0 && start > size(value) - 1)
     throw new SliceOffsetOutOfBoundsError({
@@ -842,6 +1208,13 @@ function assertEndOffset(value, start, end) {
     });
   }
 }
+function sliceBytes(value_, start, end, { strict } = {}) {
+  assertStartOffset(value_, start);
+  const value = value_.slice(start, end);
+  if (strict)
+    assertEndOffset(value, start, end);
+  return value;
+}
 function sliceHex(value_, start, end, { strict } = {}) {
   assertStartOffset(value_, start);
   const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
@@ -854,6 +1227,602 @@ var init_slice = __esm(() => {
   init_size();
 });
 
+// node_modules/viem/_esm/utils/regex.js
+var integerRegex;
+var init_regex2 = __esm(() => {
+  integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+});
+
+// node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
+function encodeAbiParameters(params, values) {
+  if (params.length !== values.length)
+    throw new AbiEncodingLengthMismatchError({
+      expectedLength: params.length,
+      givenLength: values.length
+    });
+  const preparedParams = prepareParams({
+    params,
+    values
+  });
+  const data = encodeParams(preparedParams);
+  if (data.length === 0)
+    return "0x";
+  return data;
+}
+function prepareParams({ params, values }) {
+  const preparedParams = [];
+  for (let i = 0;i < params.length; i++) {
+    preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
+  }
+  return preparedParams;
+}
+function prepareParam({ param, value }) {
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents) {
+    const [length, type] = arrayComponents;
+    return encodeArray(value, { length, param: { ...param, type } });
+  }
+  if (param.type === "tuple") {
+    return encodeTuple(value, {
+      param
+    });
+  }
+  if (param.type === "address") {
+    return encodeAddress(value);
+  }
+  if (param.type === "bool") {
+    return encodeBool(value);
+  }
+  if (param.type.startsWith("uint") || param.type.startsWith("int")) {
+    const signed = param.type.startsWith("int");
+    const [, , size2 = "256"] = integerRegex.exec(param.type) ?? [];
+    return encodeNumber(value, {
+      signed,
+      size: Number(size2)
+    });
+  }
+  if (param.type.startsWith("bytes")) {
+    return encodeBytes(value, { param });
+  }
+  if (param.type === "string") {
+    return encodeString(value);
+  }
+  throw new InvalidAbiEncodingTypeError(param.type, {
+    docsPath: "/docs/contract/encodeAbiParameters"
+  });
+}
+function encodeParams(preparedParams) {
+  let staticSize = 0;
+  for (let i = 0;i < preparedParams.length; i++) {
+    const { dynamic, encoded } = preparedParams[i];
+    if (dynamic)
+      staticSize += 32;
+    else
+      staticSize += size(encoded);
+  }
+  const staticParams = [];
+  const dynamicParams = [];
+  let dynamicSize = 0;
+  for (let i = 0;i < preparedParams.length; i++) {
+    const { dynamic, encoded } = preparedParams[i];
+    if (dynamic) {
+      staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
+      dynamicParams.push(encoded);
+      dynamicSize += size(encoded);
+    } else {
+      staticParams.push(encoded);
+    }
+  }
+  return concat([...staticParams, ...dynamicParams]);
+}
+function encodeAddress(value) {
+  if (!isAddress(value))
+    throw new InvalidAddressError({ address: value });
+  return { dynamic: false, encoded: padHex(value.toLowerCase()) };
+}
+function encodeArray(value, { length, param }) {
+  const dynamic = length === null;
+  if (!Array.isArray(value))
+    throw new InvalidArrayError(value);
+  if (!dynamic && value.length !== length)
+    throw new AbiEncodingArrayLengthMismatchError({
+      expectedLength: length,
+      givenLength: value.length,
+      type: `${param.type}[${length}]`
+    });
+  let dynamicChild = false;
+  const preparedParams = [];
+  for (let i = 0;i < value.length; i++) {
+    const preparedParam = prepareParam({ param, value: value[i] });
+    if (preparedParam.dynamic)
+      dynamicChild = true;
+    preparedParams.push(preparedParam);
+  }
+  if (dynamic || dynamicChild) {
+    const data = encodeParams(preparedParams);
+    if (dynamic) {
+      const length2 = numberToHex(preparedParams.length, { size: 32 });
+      return {
+        dynamic: true,
+        encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
+      };
+    }
+    if (dynamicChild)
+      return { dynamic: true, encoded: data };
+  }
+  return {
+    dynamic: false,
+    encoded: concat(preparedParams.map(({ encoded }) => encoded))
+  };
+}
+function encodeBytes(value, { param }) {
+  const [, paramSize] = param.type.split("bytes");
+  const bytesSize = size(value);
+  if (!paramSize) {
+    let value_ = value;
+    if (bytesSize % 32 !== 0)
+      value_ = padHex(value_, {
+        dir: "right",
+        size: Math.ceil((value.length - 2) / 2 / 32) * 32
+      });
+    return {
+      dynamic: true,
+      encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
+    };
+  }
+  if (bytesSize !== Number.parseInt(paramSize))
+    throw new AbiEncodingBytesSizeMismatchError({
+      expectedSize: Number.parseInt(paramSize),
+      value
+    });
+  return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
+}
+function encodeBool(value) {
+  if (typeof value !== "boolean")
+    throw new BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
+  return { dynamic: false, encoded: padHex(boolToHex(value)) };
+}
+function encodeNumber(value, { signed, size: size2 = 256 }) {
+  if (typeof size2 === "number") {
+    const max = 2n ** (BigInt(size2) - (signed ? 1n : 0n)) - 1n;
+    const min = signed ? -max - 1n : 0n;
+    if (value > max || value < min)
+      throw new IntegerOutOfRangeError({
+        max: max.toString(),
+        min: min.toString(),
+        signed,
+        size: size2 / 8,
+        value: value.toString()
+      });
+  }
+  return {
+    dynamic: false,
+    encoded: numberToHex(value, {
+      size: 32,
+      signed
+    })
+  };
+}
+function encodeString(value) {
+  const hexValue = stringToHex(value);
+  const partsLength = Math.ceil(size(hexValue) / 32);
+  const parts = [];
+  for (let i = 0;i < partsLength; i++) {
+    parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
+      dir: "right"
+    }));
+  }
+  return {
+    dynamic: true,
+    encoded: concat([
+      padHex(numberToHex(size(hexValue), { size: 32 })),
+      ...parts
+    ])
+  };
+}
+function encodeTuple(value, { param }) {
+  let dynamic = false;
+  const preparedParams = [];
+  for (let i = 0;i < param.components.length; i++) {
+    const param_ = param.components[i];
+    const index = Array.isArray(value) ? i : param_.name;
+    const preparedParam = prepareParam({
+      param: param_,
+      value: value[index]
+    });
+    preparedParams.push(preparedParam);
+    if (preparedParam.dynamic)
+      dynamic = true;
+  }
+  return {
+    dynamic,
+    encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
+  };
+}
+function getArrayComponents(type) {
+  const matches = type.match(/^(.*)\[(\d+)?\]$/);
+  return matches ? [matches[2] ? Number(matches[2]) : null, matches[1]] : undefined;
+}
+var init_encodeAbiParameters = __esm(() => {
+  init_abi();
+  init_address();
+  init_base();
+  init_encoding();
+  init_isAddress();
+  init_pad();
+  init_size();
+  init_slice();
+  init_toHex();
+  init_regex2();
+});
+
+// node_modules/viem/_esm/utils/hash/toFunctionSelector.js
+var toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
+var init_toFunctionSelector = __esm(() => {
+  init_slice();
+  init_toSignatureHash();
+});
+
+// node_modules/viem/_esm/utils/abi/getAbiItem.js
+function getAbiItem(parameters) {
+  const { abi, args = [], name } = parameters;
+  const isSelector = isHex(name, { strict: false });
+  const abiItems = abi.filter((abiItem) => {
+    if (isSelector) {
+      if (abiItem.type === "function")
+        return toFunctionSelector(abiItem) === name;
+      if (abiItem.type === "event")
+        return toEventSelector(abiItem) === name;
+      return false;
+    }
+    return "name" in abiItem && abiItem.name === name;
+  });
+  if (abiItems.length === 0)
+    return;
+  if (abiItems.length === 1)
+    return abiItems[0];
+  let matchedAbiItem = undefined;
+  for (const abiItem of abiItems) {
+    if (!("inputs" in abiItem))
+      continue;
+    if (!args || args.length === 0) {
+      if (!abiItem.inputs || abiItem.inputs.length === 0)
+        return abiItem;
+      continue;
+    }
+    if (!abiItem.inputs)
+      continue;
+    if (abiItem.inputs.length === 0)
+      continue;
+    if (abiItem.inputs.length !== args.length)
+      continue;
+    const matched = args.every((arg, index) => {
+      const abiParameter = "inputs" in abiItem && abiItem.inputs[index];
+      if (!abiParameter)
+        return false;
+      return isArgOfType(arg, abiParameter);
+    });
+    if (matched) {
+      if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
+        const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
+        if (ambiguousTypes)
+          throw new AbiItemAmbiguityError({
+            abiItem,
+            type: ambiguousTypes[0]
+          }, {
+            abiItem: matchedAbiItem,
+            type: ambiguousTypes[1]
+          });
+      }
+      matchedAbiItem = abiItem;
+    }
+  }
+  if (matchedAbiItem)
+    return matchedAbiItem;
+  return abiItems[0];
+}
+function isArgOfType(arg, abiParameter) {
+  const argType = typeof arg;
+  const abiParameterType = abiParameter.type;
+  switch (abiParameterType) {
+    case "address":
+      return isAddress(arg, { strict: false });
+    case "bool":
+      return argType === "boolean";
+    case "function":
+      return argType === "string";
+    case "string":
+      return argType === "string";
+    default: {
+      if (abiParameterType === "tuple" && "components" in abiParameter)
+        return Object.values(abiParameter.components).every((component, index) => {
+          return isArgOfType(Object.values(arg)[index], component);
+        });
+      if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
+        return argType === "number" || argType === "bigint";
+      if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
+        return argType === "string" || arg instanceof Uint8Array;
+      if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
+        return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
+          ...abiParameter,
+          type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
+        }));
+      }
+      return false;
+    }
+  }
+}
+function getAmbiguousTypes(sourceParameters, targetParameters, args) {
+  for (const parameterIndex in sourceParameters) {
+    const sourceParameter = sourceParameters[parameterIndex];
+    const targetParameter = targetParameters[parameterIndex];
+    if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
+      return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
+    const types = [sourceParameter.type, targetParameter.type];
+    const ambiguous = (() => {
+      if (types.includes("address") && types.includes("bytes20"))
+        return true;
+      if (types.includes("address") && types.includes("string"))
+        return isAddress(args[parameterIndex], { strict: false });
+      if (types.includes("address") && types.includes("bytes"))
+        return isAddress(args[parameterIndex], { strict: false });
+      return false;
+    })();
+    if (ambiguous)
+      return types;
+  }
+  return;
+}
+var init_getAbiItem = __esm(() => {
+  init_abi();
+  init_isAddress();
+  init_toEventSelector();
+  init_toFunctionSelector();
+});
+
+// node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js
+function prepareEncodeFunctionData(parameters) {
+  const { abi, args, functionName } = parameters;
+  let abiItem = abi[0];
+  if (functionName) {
+    const item = getAbiItem({
+      abi,
+      args,
+      name: functionName
+    });
+    if (!item)
+      throw new AbiFunctionNotFoundError(functionName, { docsPath });
+    abiItem = item;
+  }
+  if (abiItem.type !== "function")
+    throw new AbiFunctionNotFoundError(undefined, { docsPath });
+  return {
+    abi: [abiItem],
+    functionName: toFunctionSelector(formatAbiItem2(abiItem))
+  };
+}
+var docsPath = "/docs/contract/encodeFunctionData";
+var init_prepareEncodeFunctionData = __esm(() => {
+  init_abi();
+  init_toFunctionSelector();
+  init_formatAbiItem2();
+  init_getAbiItem();
+});
+
+// node_modules/viem/_esm/utils/abi/encodeFunctionData.js
+function encodeFunctionData(parameters) {
+  const { args } = parameters;
+  const { abi, functionName } = (() => {
+    if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x"))
+      return parameters;
+    return prepareEncodeFunctionData(parameters);
+  })();
+  const abiItem = abi[0];
+  const signature = functionName;
+  const data = "inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : undefined;
+  return concatHex([signature, data ?? "0x"]);
+}
+var init_encodeFunctionData = __esm(() => {
+  init_encodeAbiParameters();
+  init_prepareEncodeFunctionData();
+});
+
+// node_modules/viem/_esm/errors/cursor.js
+var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
+var init_cursor = __esm(() => {
+  init_base();
+  NegativeOffsetError = class NegativeOffsetError extends BaseError {
+    constructor({ offset }) {
+      super(`Offset \`${offset}\` cannot be negative.`, {
+        name: "NegativeOffsetError"
+      });
+    }
+  };
+  PositionOutOfBoundsError = class PositionOutOfBoundsError extends BaseError {
+    constructor({ length, position }) {
+      super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
+    }
+  };
+  RecursiveReadLimitExceededError = class RecursiveReadLimitExceededError extends BaseError {
+    constructor({ count, limit }) {
+      super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
+    }
+  };
+});
+
+// node_modules/viem/_esm/utils/cursor.js
+function createCursor(bytes, { recursiveReadLimit = 8192 } = {}) {
+  const cursor = Object.create(staticCursor);
+  cursor.bytes = bytes;
+  cursor.dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  cursor.positionReadCount = new Map;
+  cursor.recursiveReadLimit = recursiveReadLimit;
+  return cursor;
+}
+var staticCursor;
+var init_cursor2 = __esm(() => {
+  init_cursor();
+  staticCursor = {
+    bytes: new Uint8Array,
+    dataView: new DataView(new ArrayBuffer(0)),
+    position: 0,
+    positionReadCount: new Map,
+    recursiveReadCount: 0,
+    recursiveReadLimit: Number.POSITIVE_INFINITY,
+    assertReadLimit() {
+      if (this.recursiveReadCount >= this.recursiveReadLimit)
+        throw new RecursiveReadLimitExceededError({
+          count: this.recursiveReadCount + 1,
+          limit: this.recursiveReadLimit
+        });
+    },
+    assertPosition(position) {
+      if (position < 0 || position > this.bytes.length - 1)
+        throw new PositionOutOfBoundsError({
+          length: this.bytes.length,
+          position
+        });
+    },
+    decrementPosition(offset) {
+      if (offset < 0)
+        throw new NegativeOffsetError({ offset });
+      const position = this.position - offset;
+      this.assertPosition(position);
+      this.position = position;
+    },
+    getReadCount(position) {
+      return this.positionReadCount.get(position || this.position) || 0;
+    },
+    incrementPosition(offset) {
+      if (offset < 0)
+        throw new NegativeOffsetError({ offset });
+      const position = this.position + offset;
+      this.assertPosition(position);
+      this.position = position;
+    },
+    inspectByte(position_) {
+      const position = position_ ?? this.position;
+      this.assertPosition(position);
+      return this.bytes[position];
+    },
+    inspectBytes(length, position_) {
+      const position = position_ ?? this.position;
+      this.assertPosition(position + length - 1);
+      return this.bytes.subarray(position, position + length);
+    },
+    inspectUint8(position_) {
+      const position = position_ ?? this.position;
+      this.assertPosition(position);
+      return this.bytes[position];
+    },
+    inspectUint16(position_) {
+      const position = position_ ?? this.position;
+      this.assertPosition(position + 1);
+      return this.dataView.getUint16(position);
+    },
+    inspectUint24(position_) {
+      const position = position_ ?? this.position;
+      this.assertPosition(position + 2);
+      return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
+    },
+    inspectUint32(position_) {
+      const position = position_ ?? this.position;
+      this.assertPosition(position + 3);
+      return this.dataView.getUint32(position);
+    },
+    pushByte(byte) {
+      this.assertPosition(this.position);
+      this.bytes[this.position] = byte;
+      this.position++;
+    },
+    pushBytes(bytes) {
+      this.assertPosition(this.position + bytes.length - 1);
+      this.bytes.set(bytes, this.position);
+      this.position += bytes.length;
+    },
+    pushUint8(value) {
+      this.assertPosition(this.position);
+      this.bytes[this.position] = value;
+      this.position++;
+    },
+    pushUint16(value) {
+      this.assertPosition(this.position + 1);
+      this.dataView.setUint16(this.position, value);
+      this.position += 2;
+    },
+    pushUint24(value) {
+      this.assertPosition(this.position + 2);
+      this.dataView.setUint16(this.position, value >> 8);
+      this.dataView.setUint8(this.position + 2, value & ~4294967040);
+      this.position += 3;
+    },
+    pushUint32(value) {
+      this.assertPosition(this.position + 3);
+      this.dataView.setUint32(this.position, value);
+      this.position += 4;
+    },
+    readByte() {
+      this.assertReadLimit();
+      this._touch();
+      const value = this.inspectByte();
+      this.position++;
+      return value;
+    },
+    readBytes(length, size2) {
+      this.assertReadLimit();
+      this._touch();
+      const value = this.inspectBytes(length);
+      this.position += size2 ?? length;
+      return value;
+    },
+    readUint8() {
+      this.assertReadLimit();
+      this._touch();
+      const value = this.inspectUint8();
+      this.position += 1;
+      return value;
+    },
+    readUint16() {
+      this.assertReadLimit();
+      this._touch();
+      const value = this.inspectUint16();
+      this.position += 2;
+      return value;
+    },
+    readUint24() {
+      this.assertReadLimit();
+      this._touch();
+      const value = this.inspectUint24();
+      this.position += 3;
+      return value;
+    },
+    readUint32() {
+      this.assertReadLimit();
+      this._touch();
+      const value = this.inspectUint32();
+      this.position += 4;
+      return value;
+    },
+    get remaining() {
+      return this.bytes.length - this.position;
+    },
+    setPosition(position) {
+      const oldPosition = this.position;
+      this.assertPosition(position);
+      this.position = position;
+      return () => this.position = oldPosition;
+    },
+    _touch() {
+      if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
+        return;
+      const count = this.getReadCount();
+      this.positionReadCount.set(this.position, count + 1);
+      if (count > 0)
+        this.recursiveReadCount++;
+    }
+  };
+});
+
 // node_modules/viem/_esm/utils/encoding/fromBytes.js
 function bytesToBigInt(bytes, opts = {}) {
   if (typeof opts.size !== "undefined")
@@ -861,6 +1830,16 @@ function bytesToBigInt(bytes, opts = {}) {
   const hex = bytesToHex(bytes, opts);
   return hexToBigInt(hex, opts);
 }
+function bytesToBool(bytes_, opts = {}) {
+  let bytes = bytes_;
+  if (typeof opts.size !== "undefined") {
+    assertSize(bytes, { size: opts.size });
+    bytes = trim(bytes);
+  }
+  if (bytes.length > 1 || bytes[0] > 1)
+    throw new InvalidBytesBooleanError(bytes);
+  return Boolean(bytes[0]);
+}
 function bytesToNumber(bytes, opts = {}) {
   if (typeof opts.size !== "undefined")
     assertSize(bytes, { size: opts.size });
@@ -876,10 +1855,208 @@ function bytesToString(bytes_, opts = {}) {
   return new TextDecoder().decode(bytes);
 }
 var init_fromBytes = __esm(() => {
+  init_encoding();
   init_fromHex();
   init_toHex();
 });
 
+// node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
+function decodeAbiParameters(params, data) {
+  const bytes = typeof data === "string" ? hexToBytes(data) : data;
+  const cursor = createCursor(bytes);
+  if (size(bytes) === 0 && params.length > 0)
+    throw new AbiDecodingZeroDataError;
+  if (size(data) && size(data) < 32)
+    throw new AbiDecodingDataSizeTooSmallError({
+      data: typeof data === "string" ? data : bytesToHex(data),
+      params,
+      size: size(data)
+    });
+  let consumed = 0;
+  const values = [];
+  for (let i = 0;i < params.length; ++i) {
+    const param = params[i];
+    cursor.setPosition(consumed);
+    const [data2, consumed_] = decodeParameter(cursor, param, {
+      staticPosition: 0
+    });
+    consumed += consumed_;
+    values.push(data2);
+  }
+  return values;
+}
+function decodeParameter(cursor, param, { staticPosition }) {
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents) {
+    const [length, type] = arrayComponents;
+    return decodeArray(cursor, { ...param, type }, { length, staticPosition });
+  }
+  if (param.type === "tuple")
+    return decodeTuple(cursor, param, { staticPosition });
+  if (param.type === "address")
+    return decodeAddress(cursor);
+  if (param.type === "bool")
+    return decodeBool(cursor);
+  if (param.type.startsWith("bytes"))
+    return decodeBytes(cursor, param, { staticPosition });
+  if (param.type.startsWith("uint") || param.type.startsWith("int"))
+    return decodeNumber(cursor, param);
+  if (param.type === "string")
+    return decodeString(cursor, { staticPosition });
+  throw new InvalidAbiDecodingTypeError(param.type, {
+    docsPath: "/docs/contract/decodeAbiParameters"
+  });
+}
+function decodeAddress(cursor) {
+  const value = cursor.readBytes(32);
+  return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
+}
+function decodeArray(cursor, param, { length, staticPosition }) {
+  if (!length) {
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
+    const start = staticPosition + offset;
+    const startOfData = start + sizeOfLength;
+    cursor.setPosition(start);
+    const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
+    const dynamicChild = hasDynamicChild(param);
+    let consumed2 = 0;
+    const value2 = [];
+    for (let i = 0;i < length2; ++i) {
+      cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
+      const [data, consumed_] = decodeParameter(cursor, param, {
+        staticPosition: startOfData
+      });
+      consumed2 += consumed_;
+      value2.push(data);
+    }
+    cursor.setPosition(staticPosition + 32);
+    return [value2, 32];
+  }
+  if (hasDynamicChild(param)) {
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
+    const start = staticPosition + offset;
+    const value2 = [];
+    for (let i = 0;i < length; ++i) {
+      cursor.setPosition(start + i * 32);
+      const [data] = decodeParameter(cursor, param, {
+        staticPosition: start
+      });
+      value2.push(data);
+    }
+    cursor.setPosition(staticPosition + 32);
+    return [value2, 32];
+  }
+  let consumed = 0;
+  const value = [];
+  for (let i = 0;i < length; ++i) {
+    const [data, consumed_] = decodeParameter(cursor, param, {
+      staticPosition: staticPosition + consumed
+    });
+    consumed += consumed_;
+    value.push(data);
+  }
+  return [value, consumed];
+}
+function decodeBool(cursor) {
+  return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
+}
+function decodeBytes(cursor, param, { staticPosition }) {
+  const [_, size2] = param.type.split("bytes");
+  if (!size2) {
+    const offset = bytesToNumber(cursor.readBytes(32));
+    cursor.setPosition(staticPosition + offset);
+    const length = bytesToNumber(cursor.readBytes(32));
+    if (length === 0) {
+      cursor.setPosition(staticPosition + 32);
+      return ["0x", 32];
+    }
+    const data = cursor.readBytes(length);
+    cursor.setPosition(staticPosition + 32);
+    return [bytesToHex(data), 32];
+  }
+  const value = bytesToHex(cursor.readBytes(Number.parseInt(size2), 32));
+  return [value, 32];
+}
+function decodeNumber(cursor, param) {
+  const signed = param.type.startsWith("int");
+  const size2 = Number.parseInt(param.type.split("int")[1] || "256");
+  const value = cursor.readBytes(32);
+  return [
+    size2 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
+    32
+  ];
+}
+function decodeTuple(cursor, param, { staticPosition }) {
+  const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
+  const value = hasUnnamedChild ? [] : {};
+  let consumed = 0;
+  if (hasDynamicChild(param)) {
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
+    const start = staticPosition + offset;
+    for (let i = 0;i < param.components.length; ++i) {
+      const component = param.components[i];
+      cursor.setPosition(start + consumed);
+      const [data, consumed_] = decodeParameter(cursor, component, {
+        staticPosition: start
+      });
+      consumed += consumed_;
+      value[hasUnnamedChild ? i : component?.name] = data;
+    }
+    cursor.setPosition(staticPosition + 32);
+    return [value, 32];
+  }
+  for (let i = 0;i < param.components.length; ++i) {
+    const component = param.components[i];
+    const [data, consumed_] = decodeParameter(cursor, component, {
+      staticPosition
+    });
+    value[hasUnnamedChild ? i : component?.name] = data;
+    consumed += consumed_;
+  }
+  return [value, consumed];
+}
+function decodeString(cursor, { staticPosition }) {
+  const offset = bytesToNumber(cursor.readBytes(32));
+  const start = staticPosition + offset;
+  cursor.setPosition(start);
+  const length = bytesToNumber(cursor.readBytes(32));
+  if (length === 0) {
+    cursor.setPosition(staticPosition + 32);
+    return ["", 32];
+  }
+  const data = cursor.readBytes(length, 32);
+  const value = bytesToString(trim(data));
+  cursor.setPosition(staticPosition + 32);
+  return [value, 32];
+}
+function hasDynamicChild(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(hasDynamicChild);
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
+    return true;
+  return false;
+}
+var sizeOfLength = 32, sizeOfOffset = 32;
+var init_decodeAbiParameters = __esm(() => {
+  init_abi();
+  init_getAddress();
+  init_cursor2();
+  init_size();
+  init_slice();
+  init_fromBytes();
+  init_toBytes();
+  init_toHex();
+  init_encodeAbiParameters();
+});
+
 // node_modules/viem/_esm/constants/number.js
 var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
 var init_number = __esm(() => {
@@ -981,6 +2158,28 @@ var init_number = __esm(() => {
   maxUint256 = 2n ** 256n - 1n;
 });
 
+// node_modules/viem/_esm/utils/abi/decodeFunctionData.js
+function decodeFunctionData(parameters) {
+  const { abi, data } = parameters;
+  const signature = slice(data, 0, 4);
+  const description = abi.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem2(x)));
+  if (!description)
+    throw new AbiFunctionSignatureNotFoundError(signature, {
+      docsPath: "/docs/contract/decodeFunctionData"
+    });
+  return {
+    functionName: description.name,
+    args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : undefined
+  };
+}
+var init_decodeFunctionData = __esm(() => {
+  init_abi();
+  init_slice();
+  init_toFunctionSelector();
+  init_decodeAbiParameters();
+  init_formatAbiItem2();
+});
+
 // node:buffer
 var exports_buffer2 = {};
 __export(exports_buffer2, {
@@ -15271,10 +16470,10 @@ function stylizeNoColor(str, styleType) {
   return str;
 }
 function arrayToHash(array) {
-  var hash = {};
+  var hash2 = {};
   return array.forEach(function(val, idx) {
-    hash[val] = true;
-  }), hash;
+    hash2[val] = true;
+  }), hash2;
 }
 function formatValue(ctx, value, recurseTimes) {
   if (ctx.customInspect && value && isFunction(value.inspect) && value.inspect !== inspect2 && !(value.constructor && value.constructor.prototype === value)) {
@@ -23271,10 +24470,10 @@ var init_crypto = __esm(() => {
   });
   require_hmac = __commonJS2((exports2, module2) => {
     var utils = require_utils32(), assert = require_minimalistic_assert2();
-    function Hmac(hash, key, enc) {
+    function Hmac(hash2, key, enc) {
       if (!(this instanceof Hmac))
-        return new Hmac(hash, key, enc);
-      this.Hash = hash, this.blockSize = hash.blockSize / 8, this.outSize = hash.outSize / 8, this.inner = null, this.outer = null, this._init(utils.toArray(key, enc));
+        return new Hmac(hash2, key, enc);
+      this.Hash = hash2, this.blockSize = hash2.blockSize / 8, this.outSize = hash2.outSize / 8, this.inner = null, this.outer = null, this._init(utils.toArray(key, enc));
     }
     module2.exports = Hmac;
     Hmac.prototype._init = function init(key) {
@@ -23298,24 +24497,24 @@ var init_crypto = __esm(() => {
     };
   });
   require_hash = __commonJS2((exports2) => {
-    var hash = exports2;
-    hash.utils = require_utils32();
-    hash.common = require_common();
-    hash.sha = require_sha();
-    hash.ripemd = require_ripemd();
-    hash.hmac = require_hmac();
-    hash.sha1 = hash.sha.sha1;
-    hash.sha256 = hash.sha.sha256;
-    hash.sha224 = hash.sha.sha224;
-    hash.sha384 = hash.sha.sha384;
-    hash.sha512 = hash.sha.sha512;
-    hash.ripemd160 = hash.ripemd.ripemd160;
+    var hash2 = exports2;
+    hash2.utils = require_utils32();
+    hash2.common = require_common();
+    hash2.sha = require_sha();
+    hash2.ripemd = require_ripemd();
+    hash2.hmac = require_hmac();
+    hash2.sha1 = hash2.sha.sha1;
+    hash2.sha256 = hash2.sha.sha256;
+    hash2.sha224 = hash2.sha.sha224;
+    hash2.sha384 = hash2.sha.sha384;
+    hash2.sha512 = hash2.sha.sha512;
+    hash2.ripemd160 = hash2.ripemd.ripemd160;
   });
   require_secp256k1 = __commonJS2((exports2, module2) => {
     module2.exports = { doubles: { step: 4, points: [["e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a", "f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821"], ["8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508", "11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf"], ["175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739", "d3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695"], ["363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640", "4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9"], ["8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c", "4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36"], ["723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda", "96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f"], ["eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa", "5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999"], ["100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0", "cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09"], ["e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d", "9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d"], ["feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d", "e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088"], ["da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1", "9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d"], ["53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0", "5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8"], ["8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047", "10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a"], ["385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862", "283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453"], ["6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7", "7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160"], ["3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd", "56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0"], ["85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83", "7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6"], ["948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a", "53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589"], ["6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8", "bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17"], ["e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d", "4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda"], ["e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725", "7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd"], ["213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754", "4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2"], ["4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c", "17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6"], ["fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6", "6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f"], ["76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39", "c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01"], ["c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891", "893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3"], ["d895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b", "febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f"], ["b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03", "2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7"], ["e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d", "eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78"], ["a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070", "7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1"], ["90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4", "e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150"], ["8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da", "662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82"], ["e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11", "1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc"], ["8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e", "efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b"], ["e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41", "2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51"], ["b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef", "67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45"], ["d68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8", "db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120"], ["324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d", "648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84"], ["4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96", "35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d"], ["9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd", "ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d"], ["6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5", "9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8"], ["a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266", "40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8"], ["7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71", "34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac"], ["928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac", "c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f"], ["85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751", "1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962"], ["ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e", "493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907"], ["827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241", "c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec"], ["eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3", "be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d"], ["e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f", "4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414"], ["1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19", "aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd"], ["146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be", "b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0"], ["fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9", "6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811"], ["da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2", "8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1"], ["a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13", "7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c"], ["174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c", "ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73"], ["959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba", "2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd"], ["d2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151", "e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405"], ["64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073", "d99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589"], ["8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458", "38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e"], ["13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b", "69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27"], ["bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366", "d3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1"], ["8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa", "40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482"], ["8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0", "620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945"], ["dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787", "7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573"], ["f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e", "ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82"]] }, naf: { wnd: 7, points: [["f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9", "388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672"], ["2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4", "d8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6"], ["5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc", "6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da"], ["acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe", "cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37"], ["774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb", "d984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b"], ["f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8", "ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81"], ["d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e", "581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58"], ["defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34", "4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77"], ["2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c", "85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a"], ["352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5", "321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c"], ["2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f", "2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67"], ["9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714", "73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402"], ["daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729", "a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55"], ["c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db", "2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482"], ["6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4", "e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82"], ["1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5", "b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396"], ["605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479", "2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49"], ["62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d", "80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf"], ["80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f", "1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a"], ["7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb", "d0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7"], ["d528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9", "eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933"], ["49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963", "758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a"], ["77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74", "958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6"], ["f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530", "e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37"], ["463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b", "5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e"], ["f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247", "cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6"], ["caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1", "cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476"], ["2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120", "4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40"], ["7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435", "91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61"], ["754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18", "673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683"], ["e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8", "59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5"], ["186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb", "3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b"], ["df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f", "55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417"], ["5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143", "efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868"], ["290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba", "e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a"], ["af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45", "f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6"], ["766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a", "744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996"], ["59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e", "c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e"], ["f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8", "e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d"], ["7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c", "30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2"], ["948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519", "e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e"], ["7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab", "100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437"], ["3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca", "ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311"], ["d3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf", "8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4"], ["1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610", "68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575"], ["733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4", "f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d"], ["15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c", "d56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d"], ["a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940", "edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629"], ["e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980", "a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06"], ["311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3", "66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374"], ["34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf", "9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee"], ["f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63", "4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1"], ["d7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448", "fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b"], ["32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf", "5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661"], ["7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5", "8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6"], ["ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6", "8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e"], ["16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5", "5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d"], ["eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99", "f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc"], ["78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51", "f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4"], ["494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5", "42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c"], ["a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5", "204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b"], ["c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997", "4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913"], ["841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881", "73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154"], ["5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5", "39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865"], ["36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66", "d2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc"], ["336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726", "ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224"], ["8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede", "6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e"], ["1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94", "60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6"], ["85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31", "3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511"], ["29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51", "b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b"], ["a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252", "ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2"], ["4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5", "cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c"], ["d24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b", "6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3"], ["ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4", "322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d"], ["af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f", "6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700"], ["e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889", "2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4"], ["591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246", "b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196"], ["11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984", "998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4"], ["3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a", "b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257"], ["cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030", "bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13"], ["c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197", "6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096"], ["c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593", "c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38"], ["a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef", "21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f"], ["347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38", "60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448"], ["da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a", "49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a"], ["c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111", "5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4"], ["4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502", "7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437"], ["3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea", "be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7"], ["cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26", "8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d"], ["b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986", "39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a"], ["d4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e", "62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54"], ["48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4", "25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77"], ["dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda", "ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517"], ["6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859", "cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10"], ["e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f", "f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125"], ["eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c", "6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e"], ["13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942", "fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1"], ["ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a", "1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2"], ["b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80", "5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423"], ["ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d", "438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8"], ["8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1", "cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758"], ["52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63", "c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375"], ["e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352", "6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d"], ["7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193", "ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec"], ["5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00", "9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0"], ["32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58", "ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c"], ["e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7", "d3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4"], ["8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8", "c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f"], ["4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e", "67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649"], ["3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d", "cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826"], ["674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b", "299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5"], ["d32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f", "f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87"], ["30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6", "462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b"], ["be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297", "62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc"], ["93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a", "7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c"], ["b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c", "ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f"], ["d5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52", "4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a"], ["d3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb", "bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46"], ["463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065", "bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f"], ["7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917", "603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03"], ["74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9", "cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08"], ["30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3", "553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8"], ["9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57", "712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373"], ["176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66", "ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3"], ["75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8", "9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8"], ["809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721", "9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1"], ["1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180", "4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9"]] } };
   });
   require_curves = __commonJS2((exports2) => {
-    var curves = exports2, hash = require_hash(), curve = require_curve(), utils = require_utils22(), assert = utils.assert;
+    var curves = exports2, hash2 = require_hash(), curve = require_curve(), utils = require_utils22(), assert = utils.assert;
     function PresetCurve(options) {
       if (options.type === "short")
         this.curve = new curve.short(options);
@@ -23332,23 +24531,23 @@ var init_crypto = __esm(() => {
         return Object.defineProperty(curves, name, { configurable: true, enumerable: true, value: curve2 }), curve2;
       } });
     }
-    defineCurve("p192", { type: "short", prime: "p192", p: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff", a: "ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc", b: "64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1", n: "ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831", hash: hash.sha256, gRed: false, g: ["188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012", "07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811"] });
-    defineCurve("p224", { type: "short", prime: "p224", p: "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001", a: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe", b: "b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4", n: "ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d", hash: hash.sha256, gRed: false, g: ["b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21", "bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34"] });
-    defineCurve("p256", { type: "short", prime: null, p: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff", a: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc", b: "5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b", n: "ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551", hash: hash.sha256, gRed: false, g: ["6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296", "4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5"] });
-    defineCurve("p384", { type: "short", prime: null, p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 ffffffff", a: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 fffffffc", b: "b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f 5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef", n: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 f4372ddf 581a0db2 48b0a77a ecec196a ccc52973", hash: hash.sha384, gRed: false, g: ["aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 5502f25d bf55296c 3a545e38 72760ab7", "3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 0a60b1ce 1d7e819d 7a431d7c 90ea0e5f"] });
-    defineCurve("p521", { type: "short", prime: null, p: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff", a: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffc", b: "00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b 99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd 3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00", n: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409", hash: hash.sha512, gRed: false, g: ["000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66", "00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 3fad0761 353c7086 a272c240 88be9476 9fd16650"] });
-    defineCurve("curve25519", { type: "mont", prime: "p25519", p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed", a: "76d06", b: "1", n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed", hash: hash.sha256, gRed: false, g: ["9"] });
-    defineCurve("ed25519", { type: "edwards", prime: "p25519", p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed", a: "-1", c: "1", d: "52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3", n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed", hash: hash.sha256, gRed: false, g: ["216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a", "6666666666666666666666666666666666666666666666666666666666666658"] });
+    defineCurve("p192", { type: "short", prime: "p192", p: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff", a: "ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc", b: "64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1", n: "ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831", hash: hash2.sha256, gRed: false, g: ["188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012", "07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811"] });
+    defineCurve("p224", { type: "short", prime: "p224", p: "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001", a: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe", b: "b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4", n: "ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d", hash: hash2.sha256, gRed: false, g: ["b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21", "bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34"] });
+    defineCurve("p256", { type: "short", prime: null, p: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff", a: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc", b: "5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b", n: "ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551", hash: hash2.sha256, gRed: false, g: ["6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296", "4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5"] });
+    defineCurve("p384", { type: "short", prime: null, p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 ffffffff", a: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 fffffffc", b: "b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f 5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef", n: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 f4372ddf 581a0db2 48b0a77a ecec196a ccc52973", hash: hash2.sha384, gRed: false, g: ["aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 5502f25d bf55296c 3a545e38 72760ab7", "3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 0a60b1ce 1d7e819d 7a431d7c 90ea0e5f"] });
+    defineCurve("p521", { type: "short", prime: null, p: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff", a: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffc", b: "00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b 99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd 3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00", n: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409", hash: hash2.sha512, gRed: false, g: ["000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66", "00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 3fad0761 353c7086 a272c240 88be9476 9fd16650"] });
+    defineCurve("curve25519", { type: "mont", prime: "p25519", p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed", a: "76d06", b: "1", n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed", hash: hash2.sha256, gRed: false, g: ["9"] });
+    defineCurve("ed25519", { type: "edwards", prime: "p25519", p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed", a: "-1", c: "1", d: "52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3", n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed", hash: hash2.sha256, gRed: false, g: ["216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a", "6666666666666666666666666666666666666666666666666666666666666658"] });
     var pre;
     try {
       pre = require_secp256k1();
     } catch (e) {
       pre = undefined;
     }
-    defineCurve("secp256k1", { type: "short", prime: "k256", p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f", a: "0", b: "7", n: "ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141", h: "1", hash: hash.sha256, beta: "7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee", lambda: "5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72", basis: [{ a: "3086d221a7d46bcde86c90e49284eb15", b: "-e4437ed6010e88286f547fa90abfe4c3" }, { a: "114ca50f7a8e2f3f657c1108d9d44cfd8", b: "3086d221a7d46bcde86c90e49284eb15" }], gRed: false, g: ["79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798", "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8", pre] });
+    defineCurve("secp256k1", { type: "short", prime: "k256", p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f", a: "0", b: "7", n: "ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141", h: "1", hash: hash2.sha256, beta: "7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee", lambda: "5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72", basis: [{ a: "3086d221a7d46bcde86c90e49284eb15", b: "-e4437ed6010e88286f547fa90abfe4c3" }, { a: "114ca50f7a8e2f3f657c1108d9d44cfd8", b: "3086d221a7d46bcde86c90e49284eb15" }], gRed: false, g: ["79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798", "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8", pre] });
   });
   require_hmac_drbg = __commonJS2((exports2, module2) => {
-    var hash = require_hash(), utils = require_utils3(), assert = require_minimalistic_assert2();
+    var hash2 = require_hash(), utils = require_utils3(), assert = require_minimalistic_assert2();
     function HmacDRBG(options) {
       if (!(this instanceof HmacDRBG))
         return new HmacDRBG(options);
@@ -23365,7 +24564,7 @@ var init_crypto = __esm(() => {
       this._update(seed), this._reseed = 1, this.reseedInterval = 281474976710656;
     };
     HmacDRBG.prototype._hmac = function hmac() {
-      return new hash.hmac(this.hash, this.K);
+      return new hash2.hmac(this.hash, this.K);
     };
     HmacDRBG.prototype._update = function update(seed) {
       var kmac = this._hmac().update(this.V).update([0]);
@@ -23735,7 +24934,7 @@ var init_crypto = __esm(() => {
       return this.eddsa.g.mul(this.priv());
     });
     cachedProperty(KeyPair, "privBytes", function privBytes() {
-      var eddsa = this.eddsa, hash = this.hash(), lastIx = eddsa.encodingLength - 1, a = hash.slice(0, eddsa.encodingLength);
+      var eddsa = this.eddsa, hash2 = this.hash(), lastIx = eddsa.encodingLength - 1, a = hash2.slice(0, eddsa.encodingLength);
       return a[0] &= 248, a[lastIx] &= 127, a[lastIx] |= 64, a;
     });
     cachedProperty(KeyPair, "priv", function priv() {
@@ -23795,11 +24994,11 @@ var init_crypto = __esm(() => {
     module2.exports = Signature;
   });
   require_eddsa = __commonJS2((exports2, module2) => {
-    var hash = require_hash(), curves = require_curves(), utils = require_utils22(), assert = utils.assert, parseBytes = utils.parseBytes, KeyPair = require_key2(), Signature = require_signature2();
+    var hash2 = require_hash(), curves = require_curves(), utils = require_utils22(), assert = utils.assert, parseBytes = utils.parseBytes, KeyPair = require_key2(), Signature = require_signature2();
     function EDDSA(curve) {
       if (assert(curve === "ed25519", "only tested with ed25519 so far"), !(this instanceof EDDSA))
         return new EDDSA(curve);
-      curve = curves[curve].curve, this.curve = curve, this.g = curve.g, this.g.precompute(curve.n.bitLength() + 1), this.pointClass = curve.point().constructor, this.encodingLength = Math.ceil(curve.n.bitLength() / 8), this.hash = hash.sha512;
+      curve = curves[curve].curve, this.curve = curve, this.g = curve.g, this.g.precompute(curve.n.bitLength() + 1), this.pointClass = curve.point().constructor, this.encodingLength = Math.ceil(curve.n.bitLength() / 8), this.hash = hash2.sha512;
     }
     module2.exports = EDDSA;
     EDDSA.prototype.sign = function sign(message, secret) {
@@ -23814,10 +25013,10 @@ var init_crypto = __esm(() => {
       return RplusAh.eq(SG);
     };
     EDDSA.prototype.hashInt = function hashInt() {
-      var hash2 = this.hash();
+      var hash22 = this.hash();
       for (var i2 = 0;i2 < arguments.length; i2++)
-        hash2.update(arguments[i2]);
-      return utils.intFromLE(hash2.digest()).umod(this.curve.n);
+        hash22.update(arguments[i2]);
+      return utils.intFromLE(hash22.digest()).umod(this.curve.n);
     };
     EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {
       return KeyPair.fromPublic(this, pub);
@@ -27944,10 +29143,10 @@ var init_crypto = __esm(() => {
       }
       var keyLen = keyBits / 8, key = Buffer22.alloc(keyLen), iv = Buffer22.alloc(ivLen || 0), tmp = Buffer22.alloc(0);
       while (keyLen > 0 || ivLen > 0) {
-        var hash = new MD5;
-        if (hash.update(tmp), hash.update(password), salt)
-          hash.update(salt);
-        tmp = hash.digest();
+        var hash2 = new MD5;
+        if (hash2.update(tmp), hash2.update(password), salt)
+          hash2.update(salt);
+        tmp = hash2.digest();
         var used = 0;
         if (keyLen > 0) {
           var keyStart = key.length - keyLen;
@@ -34245,12 +35444,12 @@ var require_ripemd2 = __commonJS((exports2) => {
 var require_hmac2 = __commonJS((exports2, module2) => {
   var utils = require_utils4();
   var assert = require_minimalistic_assert();
-  function Hmac(hash, key, enc) {
+  function Hmac(hash2, key, enc) {
     if (!(this instanceof Hmac))
-      return new Hmac(hash, key, enc);
-    this.Hash = hash;
-    this.blockSize = hash.blockSize / 8;
-    this.outSize = hash.outSize / 8;
+      return new Hmac(hash2, key, enc);
+    this.Hash = hash2;
+    this.blockSize = hash2.blockSize / 8;
+    this.outSize = hash2.outSize / 8;
     this.inner = null;
     this.outer = null;
     this._init(utils.toArray(key, enc));
@@ -34281,18 +35480,18 @@ var require_hmac2 = __commonJS((exports2, module2) => {
 
 // node_modules/hash.js/lib/hash.js
 var require_hash2 = __commonJS((exports2) => {
-  var hash = exports2;
-  hash.utils = require_utils4();
-  hash.common = require_common3();
-  hash.sha = require_sha2();
-  hash.ripemd = require_ripemd2();
-  hash.hmac = require_hmac2();
-  hash.sha1 = hash.sha.sha1;
-  hash.sha256 = hash.sha.sha256;
-  hash.sha224 = hash.sha.sha224;
-  hash.sha384 = hash.sha.sha384;
-  hash.sha512 = hash.sha.sha512;
-  hash.ripemd160 = hash.ripemd.ripemd160;
+  var hash2 = exports2;
+  hash2.utils = require_utils4();
+  hash2.common = require_common3();
+  hash2.sha = require_sha2();
+  hash2.ripemd = require_ripemd2();
+  hash2.hmac = require_hmac2();
+  hash2.sha1 = hash2.sha.sha1;
+  hash2.sha256 = hash2.sha.sha256;
+  hash2.sha224 = hash2.sha.sha224;
+  hash2.sha384 = hash2.sha.sha384;
+  hash2.sha512 = hash2.sha.sha512;
+  hash2.ripemd160 = hash2.ripemd.ripemd160;
 });
 
 // node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js
@@ -35082,7 +36281,7 @@ var require_secp256k12 = __commonJS((exports2, module2) => {
 // node_modules/elliptic/lib/elliptic/curves.js
 var require_curves2 = __commonJS((exports2) => {
   var curves = exports2;
-  var hash = require_hash2();
+  var hash2 = require_hash2();
   var curve = require_curve2();
   var utils = require_utils2();
   var assert = utils.assert;
@@ -35122,7 +36321,7 @@ var require_curves2 = __commonJS((exports2) => {
     a: "ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc",
     b: "64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1",
     n: "ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831",
-    hash: hash.sha256,
+    hash: hash2.sha256,
     gRed: false,
     g: [
       "188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012",
@@ -35136,7 +36335,7 @@ var require_curves2 = __commonJS((exports2) => {
     a: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe",
     b: "b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4",
     n: "ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d",
-    hash: hash.sha256,
+    hash: hash2.sha256,
     gRed: false,
     g: [
       "b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21",
@@ -35150,7 +36349,7 @@ var require_curves2 = __commonJS((exports2) => {
     a: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc",
     b: "5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b",
     n: "ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551",
-    hash: hash.sha256,
+    hash: hash2.sha256,
     gRed: false,
     g: [
       "6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296",
@@ -35164,7 +36363,7 @@ var require_curves2 = __commonJS((exports2) => {
     a: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff " + "fffffffe ffffffff 00000000 00000000 fffffffc",
     b: "b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f " + "5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef",
     n: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 " + "f4372ddf 581a0db2 48b0a77a ecec196a ccc52973",
-    hash: hash.sha384,
+    hash: hash2.sha384,
     gRed: false,
     g: [
       "aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 " + "5502f25d bf55296c 3a545e38 72760ab7",
@@ -35178,7 +36377,7 @@ var require_curves2 = __commonJS((exports2) => {
     a: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff " + "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff " + "ffffffff ffffffff ffffffff ffffffff fffffffc",
     b: "00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b " + "99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd " + "3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00",
     n: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff " + "ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 " + "f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409",
-    hash: hash.sha512,
+    hash: hash2.sha512,
     gRed: false,
     g: [
       "000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 " + "053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 " + "a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66",
@@ -35192,7 +36391,7 @@ var require_curves2 = __commonJS((exports2) => {
     a: "76d06",
     b: "1",
     n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed",
-    hash: hash.sha256,
+    hash: hash2.sha256,
     gRed: false,
     g: [
       "9"
@@ -35206,7 +36405,7 @@ var require_curves2 = __commonJS((exports2) => {
     c: "1",
     d: "52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3",
     n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed",
-    hash: hash.sha256,
+    hash: hash2.sha256,
     gRed: false,
     g: [
       "216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a",
@@ -35227,7 +36426,7 @@ var require_curves2 = __commonJS((exports2) => {
     b: "7",
     n: "ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141",
     h: "1",
-    hash: hash.sha256,
+    hash: hash2.sha256,
     beta: "7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee",
     lambda: "5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72",
     basis: [
@@ -35251,7 +36450,7 @@ var require_curves2 = __commonJS((exports2) => {
 
 // node_modules/hmac-drbg/lib/hmac-drbg.js
 var require_hmac_drbg2 = __commonJS((exports2, module2) => {
-  var hash = require_hash2();
+  var hash2 = require_hash2();
   var utils = require_utils();
   var assert = require_minimalistic_assert();
   function HmacDRBG(options) {
@@ -35285,7 +36484,7 @@ var require_hmac_drbg2 = __commonJS((exports2, module2) => {
     this.reseedInterval = 281474976710656;
   };
   HmacDRBG.prototype._hmac = function hmac() {
-    return new hash.hmac(this.hash, this.K);
+    return new hash2.hmac(this.hash, this.K);
   };
   HmacDRBG.prototype._update = function update(seed) {
     var kmac = this._hmac().update(this.V).update([0]);
@@ -35779,9 +36978,9 @@ var require_key5 = __commonJS((exports2, module2) => {
   });
   cachedProperty(KeyPair, "privBytes", function privBytes() {
     var eddsa = this.eddsa;
-    var hash = this.hash();
+    var hash2 = this.hash();
     var lastIx = eddsa.encodingLength - 1;
-    var a = hash.slice(0, eddsa.encodingLength);
+    var a = hash2.slice(0, eddsa.encodingLength);
     a[0] &= 248;
     a[lastIx] &= 127;
     a[lastIx] |= 64;
@@ -35861,7 +37060,7 @@ var require_signature5 = __commonJS((exports2, module2) => {
 
 // node_modules/elliptic/lib/elliptic/eddsa/index.js
 var require_eddsa2 = __commonJS((exports2, module2) => {
-  var hash = require_hash2();
+  var hash2 = require_hash2();
   var curves = require_curves2();
   var utils = require_utils2();
   var assert = utils.assert;
@@ -35878,7 +37077,7 @@ var require_eddsa2 = __commonJS((exports2, module2) => {
     this.g.precompute(curve.n.bitLength() + 1);
     this.pointClass = curve.point().constructor;
     this.encodingLength = Math.ceil(curve.n.bitLength() / 8);
-    this.hash = hash.sha512;
+    this.hash = hash2.sha512;
   }
   module2.exports = EDDSA;
   EDDSA.prototype.sign = function sign(message, secret) {
@@ -35901,10 +37100,10 @@ var require_eddsa2 = __commonJS((exports2, module2) => {
     return RplusAh.eq(SG);
   };
   EDDSA.prototype.hashInt = function hashInt() {
-    var hash2 = this.hash();
+    var hash3 = this.hash();
     for (var i2 = 0;i2 < arguments.length; i2++)
-      hash2.update(arguments[i2]);
-    return utils.intFromLE(hash2.digest()).umod(this.curve.n);
+      hash3.update(arguments[i2]);
+    return utils.intFromLE(hash3.digest()).umod(this.curve.n);
   };
   EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {
     return KeyPair.fromPublic(this, pub);
@@ -43623,16 +44822,16 @@ var require_lib26 = __commonJS((exports2) => {
   exports2.BlockForkEvent = BlockForkEvent;
   var TransactionForkEvent = function(_super) {
     __extends(TransactionForkEvent2, _super);
-    function TransactionForkEvent2(hash, expiry) {
+    function TransactionForkEvent2(hash2, expiry) {
       var _this = this;
-      if (!(0, bytes_1.isHexString)(hash, 32)) {
-        logger25.throwArgumentError("invalid transaction hash", "hash", hash);
+      if (!(0, bytes_1.isHexString)(hash2, 32)) {
+        logger25.throwArgumentError("invalid transaction hash", "hash", hash2);
       }
       _this = _super.call(this, {
         _isForkEvent: true,
         _isTransactionForkEvent: true,
         expiry: expiry || 0,
-        hash
+        hash: hash2
       }) || this;
       return _this;
     }
@@ -44959,6 +46158,7 @@ __export(exports_src, {
   sendOFTTrx: () => sendOFTTrx,
   safeTransferFromWithDataErc721Trx: () => safeTransferFromWithDataErc721Trx,
   safeTransferFromErc721Trx: () => safeTransferFromErc721Trx,
+  rewrapRouteSingleAsSafeRouteSingle: () => rewrapRouteSingleAsSafeRouteSingle,
   revokeFromVaultWhitelistTrx: () => revokeFromVaultWhitelistTrx,
   requestRedeemSyrupVaultTrx: () => requestRedeemSyrupVaultTrx,
   requestRedeemOriginArmTrx: () => requestRedeemOriginArmTrx,
@@ -44992,12 +46192,14 @@ __export(exports_src, {
   getWormholeChainId: () => getWormholeChainId,
   getGnosisTrxSimulationResult: () => getGnosisTrxSimulationResult,
   getExecutorApiUrl: () => getExecutorApiUrl,
+  getCCIPChainSelector: () => getCCIPChainSelector,
   getAxelarGmpApiUrl: () => getAxelarGmpApiUrl,
   getAddressOrThrow: () => getAddressOrThrow,
   getAddressNameOrThrow: () => getAddressNameOrThrow,
   fetchWormholeVAA: () => fetchWormholeVAA,
   fetchExecutorTxStatus: () => fetchExecutorTxStatus,
   fetchExecutorQuote: () => fetchExecutorQuote,
+  fetchEnsoRoute: () => fetchEnsoRoute,
   fetchAxelarGmpStatus: () => fetchAxelarGmpStatus,
   executeTrx: () => executeTrx,
   executeNextTx: () => executeNextTx,
@@ -45006,7 +46208,10 @@ __export(exports_src, {
   execWithRoleReturnDataTrx: () => execWithRoleReturnDataTrx,
   execTransactionWithDelay: () => execTransactionWithDelay,
   execTransactionFromModuleTrx: () => execTransactionFromModuleTrx,
+  ensoSafeRouteSingleTrx: () => ensoSafeRouteSingleTrx,
+  ensoRouterAbi: () => enso_router_abi_default,
   encodeTransceiverInstructions: () => encodeTransceiverInstructions,
+  encodeEnsoToken: () => encodeEnsoToken,
   depositToLendleTrx: () => depositToLendleTrx,
   depositSyrupVaultTrx: () => depositSyrupVaultTrx,
   depositOriginArmWethTrx: () => depositOriginArmWethTrx,
@@ -45025,11 +46230,13 @@ __export(exports_src, {
   closeVaultTrx: () => closeVaultTrx,
   claimRedeemOriginArmTrx: () => claimRedeemOriginArmTrx,
   claimFundingFeesTrx: () => claimFundingFeesTrx,
+  ccipSendTrx: () => ccipSendTrx,
   cancelOrderTrx: () => cancelOrderTrx,
   calculateDeterministicVaultAddress: () => calculateDeterministicVaultAddress,
   buildWormholeTransferArgsFromAvatar: () => buildWormholeTransferArgsFromAvatar,
   buildRelayInstructions: () => buildRelayInstructions,
   buildMonadDefaultTransceiverInstructions: () => buildMonadDefaultTransceiverInstructions,
+  buildCCIPMessage: () => buildCCIPMessage,
   borrowMorphoBlueTrx: () => borrowMorphoBlueTrx,
   borrowFromLendleTrx: () => borrowFromLendleTrx,
   borrowFromAaveV3Trx: () => borrowFromAaveV3Trx,
@@ -45088,6 +46295,7 @@ __export(exports_src, {
   UniswapV3DecreaseLiquidityCalldata: () => UniswapV3DecreaseLiquidityCalldata,
   UniswapV3CollectFeesCalldata: () => UniswapV3CollectFeesCalldata,
   UniswapV3BurnPositionCalldata: () => UniswapV3BurnPositionCalldata,
+  UnexpectedEnsoSelectorError: () => UnexpectedEnsoSelectorError,
   USDT_ARB: () => USDT_ARB,
   USDCe_ARB: () => USDCe_ARB,
   USDC_ARB: () => USDC_ARB,
@@ -45155,7 +46363,11 @@ __export(exports_src, {
   FluidLiteAbi: () => fluid_lite_abi_default,
   Erc721Abi: () => erc721_abi_default2,
   Erc20Abi: () => erc20_abi_default,
+  EnsoUnexpectedRouterError: () => EnsoUnexpectedRouterError,
+  EnsoTokenType: () => EnsoTokenType,
+  EnsoRouteApiError: () => EnsoRouteApiError,
   ERC721: () => erc721_abi_default,
+  ENSO_API_BASE: () => ENSO_API_BASE,
   DepositToLendleCalldata: () => DepositToLendleCalldata,
   DepositSyrupVaultCalldata: () => DepositSyrupVaultCalldata,
   DepositOriginArmWethCalldata: () => DepositOriginArmWethCalldata,
@@ -45180,6 +46392,11 @@ __export(exports_src, {
   CctpTokenMessengerV2Abi: () => token_messenger_v2_abi_default,
   CctpMessageTransmitterV2Abi: () => message_transmitter_v2_abi_default,
   CancelOrderCalldata: () => CancelOrderCalldata,
+  CCIP_CHAIN_SELECTORS: () => CCIP_CHAIN_SELECTORS,
+  CCIPSendCalldata: () => CCIPSendCalldata,
+  CCIPRouterAbi: () => ccip_router_abi_default,
+  CCIPGetFeeTrx: () => CCIPGetFeeTrx,
+  CCIPGetFeeCalldata: () => CCIPGetFeeCalldata,
   CALL_OP_CODE: () => CALL_OP_CODE,
   BorrowMorphoBlueCalldata: () => BorrowMorphoBlueCalldata,
   BorrowFromLendleCalldata: () => BorrowFromLendleCalldata,
@@ -45588,6 +46805,9 @@ var erc721_abi_default = [
 var zeroAddress = "0x0000000000000000000000000000000000000000";
 // node_modules/viem/_esm/index.js
 init_number();
+init_decodeFunctionData();
+init_encodeAbiParameters();
+init_encodeFunctionData();
 init_toBytes();
 init_toHex();
 init_fromBytes();
@@ -45633,7 +46853,7 @@ __export(exports_ethers, {
 });
 
 // node_modules/@ethersproject/contracts/lib.esm/index.js
-var import_abi = __toESM(require_lib13());
+var import_abi7 = __toESM(require_lib13());
 
 // node_modules/@ethersproject/bignumber/lib.esm/bignumber.js
 var import_bn = __toESM(require_bn());
@@ -46890,7 +48110,7 @@ class VoidSigner extends Signer {
 }
 
 // node_modules/@ethersproject/contracts/lib.esm/index.js
-var import_address3 = __toESM(require_lib7());
+var import_address4 = __toESM(require_lib7());
 var import_bytes3 = __toESM(require_lib2());
 var import_properties3 = __toESM(require_lib4());
 var import_transactions = __toESM(require_lib15());
@@ -46950,7 +48170,7 @@ function resolveName(resolver, nameOrPromise) {
       logger5.throwArgumentError("invalid address or ENS name", "name", name);
     }
     try {
-      return import_address3.getAddress(name);
+      return import_address4.getAddress(name);
     } catch (error) {}
     if (!resolver) {
       logger5.throwError("a provider or signer is needed to resolve ENS names", Logger.errors.UNSUPPORTED_OPERATION, {
@@ -47002,7 +48222,7 @@ function populateTransaction(contract, fragment, args) {
           override: resolveName(contract.signer, overrides.from),
           signer: contract.signer.getAddress()
         }).then((check) => __awaiter3(this, undefined, undefined, function* () {
-          if (import_address3.getAddress(check.signer) !== check.override) {
+          if (import_address4.getAddress(check.signer) !== check.override) {
             logger5.throwError("Contract with a Signer cannot override from", Logger.errors.UNSUPPORTED_OPERATION, {
               operation: "overrides.from"
             });
@@ -47309,7 +48529,7 @@ class FragmentRunningEvent extends RunningEvent {
     }
   }
   getEmit(event) {
-    const errors = import_abi.checkResultErrors(event.args);
+    const errors = import_abi7.checkResultErrors(event.args);
     if (errors.length) {
       throw errors[0].error;
     }
@@ -47393,7 +48613,7 @@ class BaseContract {
       import_properties3.defineReadOnly(this, "resolvedAddress", resolveName(this.provider, addressOrName));
     } else {
       try {
-        import_properties3.defineReadOnly(this, "resolvedAddress", Promise.resolve(import_address3.getAddress(addressOrName)));
+        import_properties3.defineReadOnly(this, "resolvedAddress", Promise.resolve(import_address4.getAddress(addressOrName)));
       } catch (error) {
         logger5.throwError("provider is required to use ENS name as contract address", Logger.errors.UNSUPPORTED_OPERATION, {
           operation: "new Contract"
@@ -47460,13 +48680,13 @@ class BaseContract {
     });
   }
   static getContractAddress(transaction) {
-    return import_address3.getContractAddress(transaction);
+    return import_address4.getContractAddress(transaction);
   }
   static getInterface(contractInterface) {
-    if (import_abi.Interface.isInterface(contractInterface)) {
+    if (import_abi7.Interface.isInterface(contractInterface)) {
       return contractInterface;
     }
-    return new import_abi.Interface(contractInterface);
+    return new import_abi7.Interface(contractInterface);
   }
   deployed() {
     return this._deployed();
@@ -47521,7 +48741,7 @@ class BaseContract {
     return new this.constructor(addressOrName, this.interface, this.signer || this.provider);
   }
   static isIndexed(value) {
-    return import_abi.Indexed.isIndexed(value);
+    return import_abi7.Indexed.isIndexed(value);
   }
   _normalizeRunningEvent(runningEvent) {
     if (this._runningEvents[runningEvent.tag]) {
@@ -47815,7 +49035,7 @@ class ContractFactory {
     return Contract.getInterface(contractInterface);
   }
   static getContractAddress(tx) {
-    return import_address3.getContractAddress(tx);
+    return import_address4.getContractAddress(tx);
   }
   static getContract(address, contractInterface, signer) {
     return new Contract(address, contractInterface, signer);
@@ -47823,11 +49043,11 @@ class ContractFactory {
 }
 
 // node_modules/@ethersproject/wallet/lib.esm/index.js
-var import_address4 = __toESM(require_lib7());
+var import_address5 = __toESM(require_lib7());
 var import_bytes4 = __toESM(require_lib2());
 var import_hash = __toESM(require_lib12());
 var import_hdnode = __toESM(require_lib20());
-var import_keccak2562 = __toESM(require_lib5());
+var import_keccak2563 = __toESM(require_lib5());
 var import_properties4 = __toESM(require_lib4());
 var import_random = __toESM(require_lib21());
 var import_signing_key = __toESM(require_lib14());
@@ -47881,7 +49101,7 @@ class Wallet extends Signer {
       const signingKey = new import_signing_key.SigningKey(privateKey.privateKey);
       import_properties4.defineReadOnly(this, "_signingKey", () => signingKey);
       import_properties4.defineReadOnly(this, "address", import_transactions2.computeAddress(this.publicKey));
-      if (this.address !== import_address4.getAddress(privateKey.address)) {
+      if (this.address !== import_address5.getAddress(privateKey.address)) {
         logger6.throwArgumentError("privateKey/address mismatch", "privateKey", "[REDACTED]");
       }
       if (hasMnemonic(privateKey)) {
@@ -47940,12 +49160,12 @@ class Wallet extends Signer {
   signTransaction(transaction) {
     return import_properties4.resolveProperties(transaction).then((tx) => {
       if (tx.from != null) {
-        if (import_address4.getAddress(tx.from) !== this.address) {
+        if (import_address5.getAddress(tx.from) !== this.address) {
           logger6.throwArgumentError("transaction from address mismatch", "transaction.from", transaction.from);
         }
         delete tx.from;
       }
-      const signature = this._signingKey().signDigest(import_keccak2562.keccak256(import_transactions2.serialize(tx)));
+      const signature = this._signingKey().signDigest(import_keccak2563.keccak256(import_transactions2.serialize(tx)));
       return import_transactions2.serialize(tx, signature);
     });
   }
@@ -47987,7 +49207,7 @@ class Wallet extends Signer {
       options = {};
     }
     if (options.extraEntropy) {
-      entropy = import_bytes4.arrayify(import_bytes4.hexDataSlice(import_keccak2562.keccak256(import_bytes4.concat([entropy, options.extraEntropy])), 0, 16));
+      entropy = import_bytes4.arrayify(import_bytes4.hexDataSlice(import_keccak2563.keccak256(import_bytes4.concat([entropy, options.extraEntropy])), 0, 16));
     }
     const mnemonic = import_hdnode.entropyToMnemonic(entropy, options.locale);
     return Wallet.fromMnemonic(mnemonic, options.path, options.locale);
@@ -48314,7 +49534,7 @@ var import_bech32 = __toESM(require_bech32());
 var version10 = "providers/5.7.2";
 
 // node_modules/@ethersproject/providers/lib.esm/formatter.js
-var import_address5 = __toESM(require_lib7());
+var import_address6 = __toESM(require_lib7());
 var import_bytes5 = __toESM(require_lib2());
 var import_properties5 = __toESM(require_lib4());
 var import_transactions3 = __toESM(require_lib15());
@@ -48330,7 +49550,7 @@ class Formatter {
     const bigNumber = this.bigNumber.bind(this);
     const blockTag = this.blockTag.bind(this);
     const data = this.data.bind(this);
-    const hash = this.hash.bind(this);
+    const hash2 = this.hash.bind(this);
     const hex = this.hex.bind(this);
     const number = this.number.bind(this);
     const type = this.type.bind(this);
@@ -48338,10 +49558,10 @@ class Formatter {
       return this.data(v, true);
     };
     formats.transaction = {
-      hash,
+      hash: hash2,
       type,
       accessList: Formatter.allowNull(this.accessList.bind(this), null),
-      blockHash: Formatter.allowNull(hash, null),
+      blockHash: Formatter.allowNull(hash2, null),
       blockNumber: Formatter.allowNull(number, null),
       transactionIndex: Formatter.allowNull(number, null),
       confirmations: Formatter.allowNull(number, null),
@@ -48376,12 +49596,12 @@ class Formatter {
     formats.receiptLog = {
       transactionIndex: number,
       blockNumber: number,
-      transactionHash: hash,
+      transactionHash: hash2,
       address,
-      topics: Formatter.arrayOf(hash),
+      topics: Formatter.arrayOf(hash2),
       data,
       logIndex: number,
-      blockHash: hash
+      blockHash: hash2
     };
     formats.receipt = {
       to: Formatter.allowNull(this.address, null),
@@ -48391,8 +49611,8 @@ class Formatter {
       root: Formatter.allowNull(hex),
       gasUsed: bigNumber,
       logsBloom: Formatter.allowNull(data),
-      blockHash: hash,
-      transactionHash: hash,
+      blockHash: hash2,
+      transactionHash: hash2,
       logs: Formatter.arrayOf(this.receiptLog.bind(this)),
       blockNumber: number,
       confirmations: Formatter.allowNull(number, null),
@@ -48402,8 +49622,8 @@ class Formatter {
       type
     };
     formats.block = {
-      hash: Formatter.allowNull(hash),
-      parentHash: hash,
+      hash: Formatter.allowNull(hash2),
+      parentHash: hash2,
       number,
       timestamp: number,
       nonce: Formatter.allowNull(hex),
@@ -48412,7 +49632,7 @@ class Formatter {
       gasUsed: bigNumber,
       miner: Formatter.allowNull(address),
       extraData: data,
-      transactions: Formatter.allowNull(Formatter.arrayOf(hash)),
+      transactions: Formatter.allowNull(Formatter.arrayOf(hash2)),
       baseFeePerGas: Formatter.allowNull(bigNumber)
     };
     formats.blockWithTransactions = import_properties5.shallowCopy(formats.block);
@@ -48420,19 +49640,19 @@ class Formatter {
     formats.filter = {
       fromBlock: Formatter.allowNull(blockTag, undefined),
       toBlock: Formatter.allowNull(blockTag, undefined),
-      blockHash: Formatter.allowNull(hash, undefined),
+      blockHash: Formatter.allowNull(hash2, undefined),
       address: Formatter.allowNull(address, undefined),
       topics: Formatter.allowNull(this.topics.bind(this), undefined)
     };
     formats.filterLog = {
       blockNumber: Formatter.allowNull(number),
-      blockHash: Formatter.allowNull(hash),
+      blockHash: Formatter.allowNull(hash2),
       transactionIndex: number,
       removed: Formatter.allowNull(this.boolean.bind(this)),
       address,
       data: Formatter.allowFalsish(data, "0x"),
-      topics: Formatter.arrayOf(hash),
-      transactionHash: hash,
+      topics: Formatter.arrayOf(hash2),
+      transactionHash: hash2,
       logIndex: number
     };
     return formats;
@@ -48489,17 +49709,17 @@ class Formatter {
     return result;
   }
   address(value) {
-    return import_address5.getAddress(value);
+    return import_address6.getAddress(value);
   }
   callAddress(value) {
     if (!import_bytes5.isHexString(value, 32)) {
       return null;
     }
-    const address = import_address5.getAddress(import_bytes5.hexDataSlice(value, 12));
+    const address = import_address6.getAddress(import_bytes5.hexDataSlice(value, 12));
     return address === AddressZero ? null : address;
   }
   contractAddress(value) {
-    return import_address5.getContractAddress(value);
+    return import_address6.getContractAddress(value);
   }
   blockTag(blockTag) {
     if (blockTag == null) {
@@ -48935,7 +50155,7 @@ function bytesPad(value) {
   result.set(value);
   return result;
 }
-function encodeBytes(datas) {
+function encodeBytes2(datas) {
   const result = [];
   let byteCount = 0;
   for (let i2 = 0;i2 < datas.length; i2++) {
@@ -48986,7 +50206,7 @@ class Resolver {
       let parseBytes = false;
       if (yield this.supportsWildcard()) {
         parseBytes = true;
-        tx.data = import_bytes6.hexConcat(["0x9061b923", encodeBytes([import_hash2.dnsEncode(this.name), tx.data])]);
+        tx.data = import_bytes6.hexConcat(["0x9061b923", encodeBytes2([import_hash2.dnsEncode(this.name), tx.data])]);
       }
       try {
         let result = yield this.provider.call(tx);
@@ -49225,8 +50445,8 @@ class Resolver {
       if (skynet) {
         if (skynet[1].length === 34 * 2) {
           const urlSafe = { "=": "", "+": "-", "/": "_" };
-          const hash = import_base64.encode("0x" + skynet[1]).replace(/[=+\/]/g, (a) => urlSafe[a]);
-          return "sia://" + hash;
+          const hash2 = import_base64.encode("0x" + skynet[1]).replace(/[=+\/]/g, (a) => urlSafe[a]);
+          return "sia://" + hash2;
         }
       }
       return logger9.throwError(`invalid or unsupported content hash data`, Logger.errors.UNSUPPORTED_OPERATION, {
@@ -49464,13 +50684,13 @@ class BaseProvider extends Provider {
       this._events.forEach((event) => {
         switch (event.type) {
           case "tx": {
-            const hash = event.hash;
-            let runner = this.getTransactionReceipt(hash).then((receipt) => {
+            const hash2 = event.hash;
+            let runner = this.getTransactionReceipt(hash2).then((receipt) => {
               if (!receipt || receipt.blockNumber == null) {
                 return null;
               }
-              this._emitted["t:" + hash] = receipt.blockNumber;
-              this.emit(hash, receipt);
+              this._emitted["t:" + hash2] = receipt.blockNumber;
+              this.emit(hash2, receipt);
               return null;
             }).catch((error) => {
               this.emit("error", error);
@@ -49877,13 +51097,13 @@ class BaseProvider extends Provider {
       }
     });
   }
-  _wrapTransaction(tx, hash, startBlock) {
-    if (hash != null && import_bytes6.hexDataLength(hash) !== 32) {
+  _wrapTransaction(tx, hash2, startBlock) {
+    if (hash2 != null && import_bytes6.hexDataLength(hash2) !== 32) {
       throw new Error("invalid response - sendTransaction");
     }
     const result = tx;
-    if (hash != null && tx.hash !== hash) {
-      logger9.throwError("Transaction hash mismatch from Provider.sendTransaction.", Logger.errors.UNKNOWN_ERROR, { expectedHash: tx.hash, returnedHash: hash });
+    if (hash2 != null && tx.hash !== hash2) {
+      logger9.throwError("Transaction hash mismatch from Provider.sendTransaction.", Logger.errors.UNKNOWN_ERROR, { expectedHash: tx.hash, returnedHash: hash2 });
     }
     result.wait = (confirms, timeout) => __awaiter5(this, undefined, undefined, function* () {
       if (confirms == null) {
@@ -49929,8 +51149,8 @@ class BaseProvider extends Provider {
       }
       const blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
       try {
-        const hash = yield this.perform("sendTransaction", { signedTransaction: hexTx });
-        return this._wrapTransaction(tx, hash, blockNumber);
+        const hash2 = yield this.perform("sendTransaction", { signedTransaction: hexTx });
+        return this._wrapTransaction(tx, hash2, blockNumber);
       } catch (error) {
         error.transaction = tx;
         error.transactionHash = tx.hash;
@@ -50054,7 +51274,7 @@ class BaseProvider extends Provider {
           }
           const tx = {
             to: txSender,
-            data: import_bytes6.hexConcat([callbackSelector, encodeBytes([ccipResult, extraData])])
+            data: import_bytes6.hexConcat([callbackSelector, encodeBytes2([ccipResult, extraData])])
           };
           return this._call(tx, blockTag, attempt + 1);
         } catch (error) {
@@ -50754,8 +51974,8 @@ class JsonRpcSigner extends Signer {
         tx.from = sender;
       }
       const hexTx = this.provider.constructor.hexlifyTransaction(tx, { from: true });
-      return this.provider.send("eth_sendTransaction", [hexTx]).then((hash) => {
-        return hash;
+      return this.provider.send("eth_sendTransaction", [hexTx]).then((hash2) => {
+        return hash2;
       }, (error) => {
         if (typeof error.message === "string" && error.message.match(/user denied/i)) {
           logger10.throwError("user rejected transaction", Logger.errors.ACTION_REJECTED, {
@@ -50775,17 +51995,17 @@ class JsonRpcSigner extends Signer {
   sendTransaction(transaction) {
     return __awaiter6(this, undefined, undefined, function* () {
       const blockNumber = yield this.provider._getInternalBlockNumber(100 + 2 * this.provider.pollingInterval);
-      const hash = yield this.sendUncheckedTransaction(transaction);
+      const hash2 = yield this.sendUncheckedTransaction(transaction);
       try {
         return yield import_web2.poll(() => __awaiter6(this, undefined, undefined, function* () {
-          const tx = yield this.provider.getTransaction(hash);
+          const tx = yield this.provider.getTransaction(hash2);
           if (tx === null) {
             return;
           }
-          return this.provider._wrapTransaction(tx, hash, blockNumber);
+          return this.provider._wrapTransaction(tx, hash2, blockNumber);
         }), { oncePoll: this.provider });
       } catch (error) {
-        error.transactionHash = hash;
+        error.transactionHash = hash2;
         throw error;
       }
     });
@@ -50860,9 +52080,9 @@ class JsonRpcSigner extends Signer {
 
 class UncheckedJsonRpcSigner extends JsonRpcSigner {
   sendTransaction(transaction) {
-    return this.sendUncheckedTransaction(transaction).then((hash) => {
+    return this.sendUncheckedTransaction(transaction).then((hash2) => {
       return {
-        hash,
+        hash: hash2,
         nonce: null,
         gasLimit: null,
         gasPrice: null,
@@ -50872,7 +52092,7 @@ class UncheckedJsonRpcSigner extends JsonRpcSigner {
         confirmations: 0,
         from: null,
         wait: (confirmations) => {
-          return this.provider.waitForTransaction(hash, confirmations);
+          return this.provider.waitForTransaction(hash2, confirmations);
         }
       };
     });
@@ -51108,10 +52328,10 @@ class JsonRpcProvider extends BaseProvider {
             return null;
           }
           let seq = Promise.resolve();
-          hashes.forEach(function(hash) {
-            self2._emitted["t:" + hash.toLowerCase()] = "pending";
+          hashes.forEach(function(hash2) {
+            self2._emitted["t:" + hash2.toLowerCase()] = "pending";
             seq = seq.then(function() {
-              return self2.getTransaction(hash).then(function(tx) {
+              return self2.getTransaction(hash2).then(function(tx) {
                 self2.emit("pending", tx);
                 return null;
               });
@@ -51397,12 +52617,12 @@ class WebSocketProvider extends JsonRpcProvider {
         break;
       case "tx": {
         const emitReceipt = (event2) => {
-          const hash = event2.hash;
-          this.getTransactionReceipt(hash).then((receipt) => {
+          const hash2 = event2.hash;
+          this.getTransactionReceipt(hash2).then((receipt) => {
             if (!receipt) {
               return;
             }
-            this.emit(hash, receipt);
+            this.emit(hash2, receipt);
           });
         };
         emitReceipt(event);
@@ -53264,14 +54484,14 @@ __export(exports_utils, {
   namehash: () => import_hash5.namehash,
   mnemonicToSeed: () => import_hdnode2.mnemonicToSeed,
   mnemonicToEntropy: () => import_hdnode2.mnemonicToEntropy,
-  keccak256: () => import_keccak2563.keccak256,
+  keccak256: () => import_keccak2564.keccak256,
   joinSignature: () => import_bytes10.joinSignature,
   isValidName: () => import_hash5.isValidName,
   isValidMnemonic: () => import_hdnode2.isValidMnemonic,
   isHexString: () => import_bytes10.isHexString,
   isBytesLike: () => import_bytes10.isBytesLike,
   isBytes: () => import_bytes10.isBytes,
-  isAddress: () => import_address6.isAddress,
+  isAddress: () => import_address7.isAddress,
   id: () => import_hash5.id,
   hexlify: () => import_bytes10.hexlify,
   hexZeroPad: () => import_bytes10.hexZeroPad,
@@ -53283,10 +54503,10 @@ __export(exports_utils, {
   hashMessage: () => import_hash5.hashMessage,
   getStatic: () => import_properties17.getStatic,
   getJsonWalletAddress: () => import_json_wallets2.getJsonWalletAddress,
-  getIcapAddress: () => import_address6.getIcapAddress,
-  getCreate2Address: () => import_address6.getCreate2Address,
-  getContractAddress: () => import_address6.getContractAddress,
-  getAddress: () => import_address6.getAddress,
+  getIcapAddress: () => import_address7.getIcapAddress,
+  getCreate2Address: () => import_address7.getCreate2Address,
+  getContractAddress: () => import_address7.getContractAddress,
+  getAddress: () => import_address7.getAddress,
   getAccountPath: () => import_hdnode2.getAccountPath,
   formatUnits: () => import_units.formatUnits,
   formatEther: () => import_units.formatEther,
@@ -53296,14 +54516,14 @@ __export(exports_utils, {
   dnsEncode: () => import_hash5.dnsEncode,
   defineReadOnly: () => import_properties17.defineReadOnly,
   defaultPath: () => import_hdnode2.defaultPath,
-  defaultAbiCoder: () => import_abi2.defaultAbiCoder,
+  defaultAbiCoder: () => import_abi8.defaultAbiCoder,
   deepCopy: () => import_properties17.deepCopy,
   concat: () => import_bytes10.concat,
   computePublicKey: () => import_signing_key2.computePublicKey,
   computeHmac: () => import_sha22.computeHmac,
   computeAddress: () => import_transactions6.computeAddress,
   commify: () => import_units.commify,
-  checkResultErrors: () => import_abi2.checkResultErrors,
+  checkResultErrors: () => import_abi8.checkResultErrors,
   checkProperties: () => import_properties17.checkProperties,
   base64: () => base64,
   base58: () => import_basex2.Base58,
@@ -53316,33 +54536,33 @@ __export(exports_utils, {
   Utf8ErrorFuncs: () => import_strings4.Utf8ErrorFuncs,
   UnicodeNormalizationForm: () => import_strings5.UnicodeNormalizationForm,
   TransactionTypes: () => import_transactions6.TransactionTypes,
-  TransactionDescription: () => import_abi2.TransactionDescription,
+  TransactionDescription: () => import_abi8.TransactionDescription,
   SupportedAlgorithm: () => import_sha23.SupportedAlgorithm,
   SigningKey: () => import_signing_key2.SigningKey,
   RLP: () => RLP,
-  ParamType: () => import_abi2.ParamType,
+  ParamType: () => import_abi8.ParamType,
   Logger: () => Logger,
-  LogDescription: () => import_abi2.LogDescription,
-  Interface: () => import_abi2.Interface,
-  Indexed: () => import_abi2.Indexed,
+  LogDescription: () => import_abi8.LogDescription,
+  Interface: () => import_abi8.Interface,
+  Indexed: () => import_abi8.Indexed,
   HDNode: () => import_hdnode2.HDNode,
-  FunctionFragment: () => import_abi2.FunctionFragment,
-  Fragment: () => import_abi2.Fragment,
-  FormatTypes: () => import_abi2.FormatTypes,
-  EventFragment: () => import_abi2.EventFragment,
-  ErrorFragment: () => import_abi2.ErrorFragment,
-  ConstructorFragment: () => import_abi2.ConstructorFragment,
-  AbiCoder: () => import_abi2.AbiCoder
+  FunctionFragment: () => import_abi8.FunctionFragment,
+  Fragment: () => import_abi8.Fragment,
+  FormatTypes: () => import_abi8.FormatTypes,
+  EventFragment: () => import_abi8.EventFragment,
+  ErrorFragment: () => import_abi8.ErrorFragment,
+  ConstructorFragment: () => import_abi8.ConstructorFragment,
+  AbiCoder: () => import_abi8.AbiCoder
 });
-var import_abi2 = __toESM(require_lib13());
-var import_address6 = __toESM(require_lib7());
+var import_abi8 = __toESM(require_lib13());
+var import_address7 = __toESM(require_lib7());
 var base64 = __toESM(require_lib10());
 var import_basex2 = __toESM(require_lib16());
 var import_bytes10 = __toESM(require_lib2());
 var import_hash5 = __toESM(require_lib12());
 var import_hdnode2 = __toESM(require_lib20());
 var import_json_wallets2 = __toESM(require_lib22());
-var import_keccak2563 = __toESM(require_lib5());
+var import_keccak2564 = __toESM(require_lib5());
 var import_sha22 = __toESM(require_lib17());
 var import_solidity = __toESM(require_lib24());
 var import_random3 = __toESM(require_lib21());
@@ -53853,7 +55073,7 @@ var executeGnosisTrx = async ({
   sender
 }) => {
   const _sender = sender instanceof Wallet ? sender.address : sender;
-  const hash = await client.writeContract({
+  const hash2 = await client.writeContract({
     address: safeAddress,
     abi: safe_abi_default,
     functionName: "execTransaction",
@@ -53871,7 +55091,7 @@ var executeGnosisTrx = async ({
     ],
     account: _sender
   });
-  return hash;
+  return hash2;
 };
 var getGnosisTrxSimulationResult = async ({
   safeAddress,
@@ -59316,7 +60536,7 @@ function invariant(condition, message) {
 var import_decimal = __toESM(require_decimal());
 var import_big = __toESM(require_big());
 var import_toformat = __toESM(require_toFormat());
-var import_address7 = __toESM(require_lib7());
+var import_address8 = __toESM(require_lib7());
 function _defineProperties(target, props) {
   for (var i2 = 0;i2 < props.length; i2++) {
     var descriptor = props[i2];
@@ -59876,7 +61096,7 @@ var NativeCurrency = /* @__PURE__ */ function(_BaseCurrency) {
 }(BaseCurrency);
 function validateAndParseAddress(address) {
   try {
-    return import_address7.getAddress(address);
+    return import_address8.getAddress(address);
   } catch (error) {
     throw new Error(address + " is not a valid address.");
   }
@@ -59975,8 +61195,8 @@ function sqrt(value) {
 
 // node_modules/@uniswap/v3-sdk/dist/v3-sdk.esm.js
 var import_jsbi2 = __toESM(require_jsbi_umd());
-var import_abi3 = __toESM(require_lib13());
-var import_address8 = __toESM(require_lib7());
+var import_abi9 = __toESM(require_lib13());
+var import_address9 = __toESM(require_lib7());
 var import_solidity2 = __toESM(require_lib24());
 // node_modules/@uniswap/v3-periphery/artifacts/contracts/interfaces/IMulticall.sol/IMulticall.json
 var IMulticall_default = {
@@ -63912,7 +65132,7 @@ var Q192 = /* @__PURE__ */ import_jsbi2.default.exponentiate(Q96, /* @__PURE__ *
 function computePoolAddress(_ref) {
   var { factoryAddress, tokenA, tokenB, fee, initCodeHashManualOverride } = _ref;
   var _ref2 = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA], token0 = _ref2[0], token1 = _ref2[1];
-  return import_address8.getCreate2Address(factoryAddress, import_solidity2.keccak256(["bytes"], [import_abi3.defaultAbiCoder.encode(["address", "address", "uint24"], [token0.address, token1.address, fee])]), initCodeHashManualOverride != null ? initCodeHashManualOverride : POOL_INIT_CODE_HASH);
+  return import_address9.getCreate2Address(factoryAddress, import_solidity2.keccak256(["bytes"], [import_abi9.defaultAbiCoder.encode(["address", "address", "uint24"], [token0.address, token1.address, fee])]), initCodeHashManualOverride != null ? initCodeHashManualOverride : POOL_INIT_CODE_HASH);
 }
 var LiquidityMath = /* @__PURE__ */ function() {
   function LiquidityMath2() {}
@@ -64844,7 +66064,7 @@ var Multicall = /* @__PURE__ */ function() {
   };
   return Multicall2;
 }();
-Multicall.INTERFACE = /* @__PURE__ */ new import_abi3.Interface(IMulticall_default.abi);
+Multicall.INTERFACE = /* @__PURE__ */ new import_abi9.Interface(IMulticall_default.abi);
 function isAllowedPermit(permitOptions) {
   return "nonce" in permitOptions;
 }
@@ -64855,7 +66075,7 @@ var SelfPermit = /* @__PURE__ */ function() {
   };
   return SelfPermit2;
 }();
-SelfPermit.INTERFACE = /* @__PURE__ */ new import_abi3.Interface(ISelfPermit_default.abi);
+SelfPermit.INTERFACE = /* @__PURE__ */ new import_abi9.Interface(ISelfPermit_default.abi);
 var Payments = /* @__PURE__ */ function() {
   function Payments2() {}
   Payments2.encodeFeeBips = function encodeFeeBips(fee) {
@@ -64886,7 +66106,7 @@ var Payments = /* @__PURE__ */ function() {
   };
   return Payments2;
 }();
-Payments.INTERFACE = /* @__PURE__ */ new import_abi3.Interface(IPeripheryPaymentsWithFee_default.abi);
+Payments.INTERFACE = /* @__PURE__ */ new import_abi9.Interface(IPeripheryPaymentsWithFee_default.abi);
 var MaxUint128 = /* @__PURE__ */ toHex3(/* @__PURE__ */ import_jsbi2.default.subtract(/* @__PURE__ */ import_jsbi2.default.exponentiate(/* @__PURE__ */ import_jsbi2.default.BigInt(2), /* @__PURE__ */ import_jsbi2.default.BigInt(128)), /* @__PURE__ */ import_jsbi2.default.BigInt(1)));
 function isMint(options) {
   return Object.keys(options).some(function(k) {
@@ -65044,7 +66264,7 @@ var NonfungiblePositionManager = /* @__PURE__ */ function() {
   };
   return NonfungiblePositionManager2;
 }();
-NonfungiblePositionManager.INTERFACE = /* @__PURE__ */ new import_abi3.Interface(NonfungiblePositionManager_default.abi);
+NonfungiblePositionManager.INTERFACE = /* @__PURE__ */ new import_abi9.Interface(NonfungiblePositionManager_default.abi);
 var SwapQuoter = /* @__PURE__ */ function() {
   function SwapQuoter2() {}
   SwapQuoter2.quoteCallParameters = function quoteCallParameters(route, amount, tradeType, options) {
@@ -65085,8 +66305,8 @@ var SwapQuoter = /* @__PURE__ */ function() {
   };
   return SwapQuoter2;
 }();
-SwapQuoter.V1INTERFACE = /* @__PURE__ */ new import_abi3.Interface(Quoter_default.abi);
-SwapQuoter.V2INTERFACE = /* @__PURE__ */ new import_abi3.Interface(QuoterV2_default.abi);
+SwapQuoter.V1INTERFACE = /* @__PURE__ */ new import_abi9.Interface(Quoter_default.abi);
+SwapQuoter.V2INTERFACE = /* @__PURE__ */ new import_abi9.Interface(QuoterV2_default.abi);
 var Staker = /* @__PURE__ */ function() {
   function Staker2() {}
   Staker2.encodeClaim = function encodeClaim(incentiveKey, options) {
@@ -65139,9 +66359,9 @@ var Staker = /* @__PURE__ */ function() {
         var incentiveKey = incentiveKeys[i2];
         keys.push(this._encodeIncentiveKey(incentiveKey));
       }
-      data = import_abi3.defaultAbiCoder.encode([Staker2.INCENTIVE_KEY_ABI + "[]"], [keys]);
+      data = import_abi9.defaultAbiCoder.encode([Staker2.INCENTIVE_KEY_ABI + "[]"], [keys]);
     } else {
-      data = import_abi3.defaultAbiCoder.encode([Staker2.INCENTIVE_KEY_ABI], [this._encodeIncentiveKey(incentiveKeys[0])]);
+      data = import_abi9.defaultAbiCoder.encode([Staker2.INCENTIVE_KEY_ABI], [this._encodeIncentiveKey(incentiveKeys[0])]);
     }
     return data;
   };
@@ -65158,7 +66378,7 @@ var Staker = /* @__PURE__ */ function() {
   };
   return Staker2;
 }();
-Staker.INTERFACE = /* @__PURE__ */ new import_abi3.Interface(UniswapV3Staker_default.abi);
+Staker.INTERFACE = /* @__PURE__ */ new import_abi9.Interface(UniswapV3Staker_default.abi);
 Staker.INCENTIVE_KEY_ABI = "tuple(address rewardToken, address pool, uint256 startTime, uint256 endTime, address refundee)";
 var SwapRouter = /* @__PURE__ */ function() {
   function SwapRouter2() {}
@@ -65275,7 +66495,7 @@ var SwapRouter = /* @__PURE__ */ function() {
   };
   return SwapRouter2;
 }();
-SwapRouter.INTERFACE = /* @__PURE__ */ new import_abi3.Interface(SwapRouter_default.abi);
+SwapRouter.INTERFACE = /* @__PURE__ */ new import_abi9.Interface(SwapRouter_default.abi);
 
 // node_modules/@uniswap/v4-sdk/dist/v4-sdk.esm.js
 var import_solidity4 = __toESM(require_lib24());
@@ -65285,9 +66505,9 @@ var import_jsbi3 = __toESM(require_jsbi_umd());
 var import_decimal2 = __toESM(require_decimal());
 var import_big2 = __toESM(require_big());
 var import_toformat2 = __toESM(require_toFormat());
-var import_address9 = __toESM(require_lib7());
+var import_address10 = __toESM(require_lib7());
 var import_bytes11 = __toESM(require_lib2());
-var import_keccak2564 = __toESM(require_lib5());
+var import_keccak2565 = __toESM(require_lib5());
 var import_strings6 = __toESM(require_lib9());
 function _defineProperties3(e, r) {
   for (var t = 0;t < r.length; t++) {
@@ -65992,7 +67212,7 @@ var NativeCurrency2 = /* @__PURE__ */ function(_BaseCurrency) {
 }(BaseCurrency3);
 function validateAndParseAddress2(address) {
   try {
-    return import_address9.getAddress(address);
+    return import_address10.getAddress(address);
   } catch (error) {
     throw new Error(address + " is not a valid address.");
   }
@@ -66096,10 +67316,10 @@ function computeZksyncCreate2Address(sender, bytecodeHash, salt, input) {
   if (input === undefined) {
     input = "0x";
   }
-  var prefix2 = import_keccak2564.keccak256(import_strings6.toUtf8Bytes("zksyncCreate2"));
-  var inputHash = import_keccak2564.keccak256(input);
-  var addressBytes = import_keccak2564.keccak256(import_bytes11.concat([prefix2, import_bytes11.hexZeroPad(sender, 32), salt, bytecodeHash, inputHash])).slice(26);
-  return import_address9.getAddress(addressBytes);
+  var prefix2 = import_keccak2565.keccak256(import_strings6.toUtf8Bytes("zksyncCreate2"));
+  var inputHash = import_keccak2565.keccak256(input);
+  var addressBytes = import_keccak2565.keccak256(import_bytes11.concat([prefix2, import_bytes11.hexZeroPad(sender, 32), salt, bytecodeHash, inputHash])).slice(26);
+  return import_address10.getAddress(addressBytes);
 }
 var MAX_SAFE_INTEGER2 = /* @__PURE__ */ import_jsbi3.default.BigInt(Number.MAX_SAFE_INTEGER);
 var ZERO3 = /* @__PURE__ */ import_jsbi3.default.BigInt(0);
@@ -66123,8 +67343,8 @@ function sqrt2(value) {
 
 // node_modules/@uniswap/v4-sdk/node_modules/@uniswap/v3-sdk/dist/v3-sdk.esm.js
 var import_jsbi4 = __toESM(require_jsbi_umd());
-var import_abi4 = __toESM(require_lib13());
-var import_address10 = __toESM(require_lib7());
+var import_abi10 = __toESM(require_lib13());
+var import_address11 = __toESM(require_lib7());
 var import_solidity3 = __toESM(require_lib24());
 function _arrayLikeToArray2(r, a) {
   (a == null || a > r.length) && (a = r.length);
@@ -66570,13 +67790,13 @@ var Q1922 = /* @__PURE__ */ import_jsbi4.default.exponentiate(Q962, /* @__PURE__
 function computePoolAddress2(_ref) {
   var { factoryAddress, tokenA, tokenB, fee, initCodeHashManualOverride, chainId } = _ref;
   var _ref2 = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA], token0 = _ref2[0], token1 = _ref2[1];
-  var salt = import_solidity3.keccak256(["bytes"], [import_abi4.defaultAbiCoder.encode(["address", "address", "uint24"], [token0.address, token1.address, fee])]);
+  var salt = import_solidity3.keccak256(["bytes"], [import_abi10.defaultAbiCoder.encode(["address", "address", "uint24"], [token0.address, token1.address, fee])]);
   var initCodeHash = initCodeHashManualOverride != null ? initCodeHashManualOverride : poolInitCodeHash(chainId);
   switch (chainId) {
     case ChainId2.ZKSYNC:
       return computeZksyncCreate2Address(factoryAddress, initCodeHash, salt);
     default:
-      return import_address10.getCreate2Address(factoryAddress, salt, initCodeHash);
+      return import_address11.getCreate2Address(factoryAddress, salt, initCodeHash);
   }
 }
 var FullMath2 = /* @__PURE__ */ function() {
@@ -67522,7 +68742,7 @@ var Multicall2 = /* @__PURE__ */ function() {
   };
   return Multicall3;
 }();
-Multicall2.INTERFACE = /* @__PURE__ */ new import_abi4.Interface(IMulticall_default.abi);
+Multicall2.INTERFACE = /* @__PURE__ */ new import_abi10.Interface(IMulticall_default.abi);
 function isAllowedPermit2(permitOptions) {
   return "nonce" in permitOptions;
 }
@@ -67533,7 +68753,7 @@ var SelfPermit2 = /* @__PURE__ */ function() {
   };
   return SelfPermit3;
 }();
-SelfPermit2.INTERFACE = /* @__PURE__ */ new import_abi4.Interface(ISelfPermit_default.abi);
+SelfPermit2.INTERFACE = /* @__PURE__ */ new import_abi10.Interface(ISelfPermit_default.abi);
 var Payments2 = /* @__PURE__ */ function() {
   function Payments3() {}
   Payments3.encodeFeeBips = function encodeFeeBips(fee) {
@@ -67564,7 +68784,7 @@ var Payments2 = /* @__PURE__ */ function() {
   };
   return Payments3;
 }();
-Payments2.INTERFACE = /* @__PURE__ */ new import_abi4.Interface(IPeripheryPaymentsWithFee_default.abi);
+Payments2.INTERFACE = /* @__PURE__ */ new import_abi10.Interface(IPeripheryPaymentsWithFee_default.abi);
 var _excluded = ["expectedCurrencyOwed0", "expectedCurrencyOwed1"];
 var MaxUint1282 = /* @__PURE__ */ toHex4(/* @__PURE__ */ import_jsbi4.default.subtract(/* @__PURE__ */ import_jsbi4.default.exponentiate(/* @__PURE__ */ import_jsbi4.default.BigInt(2), /* @__PURE__ */ import_jsbi4.default.BigInt(128)), /* @__PURE__ */ import_jsbi4.default.BigInt(1)));
 function isMint2(options) {
@@ -67750,7 +68970,7 @@ var NonfungiblePositionManager2 = /* @__PURE__ */ function() {
   };
   return NonfungiblePositionManager3;
 }();
-NonfungiblePositionManager2.INTERFACE = /* @__PURE__ */ new import_abi4.Interface(NonfungiblePositionManager_default.abi);
+NonfungiblePositionManager2.INTERFACE = /* @__PURE__ */ new import_abi10.Interface(NonfungiblePositionManager_default.abi);
 var SwapQuoter2 = /* @__PURE__ */ function() {
   function SwapQuoter3() {}
   SwapQuoter3.quoteCallParameters = function quoteCallParameters(route, amount, tradeType, options) {
@@ -67791,8 +69011,8 @@ var SwapQuoter2 = /* @__PURE__ */ function() {
   };
   return SwapQuoter3;
 }();
-SwapQuoter2.V1INTERFACE = /* @__PURE__ */ new import_abi4.Interface(Quoter_default.abi);
-SwapQuoter2.V2INTERFACE = /* @__PURE__ */ new import_abi4.Interface(QuoterV2_default.abi);
+SwapQuoter2.V1INTERFACE = /* @__PURE__ */ new import_abi10.Interface(Quoter_default.abi);
+SwapQuoter2.V2INTERFACE = /* @__PURE__ */ new import_abi10.Interface(QuoterV2_default.abi);
 var Staker2 = /* @__PURE__ */ function() {
   function Staker3() {}
   Staker3.encodeClaim = function encodeClaim(incentiveKey, options) {
@@ -67845,9 +69065,9 @@ var Staker2 = /* @__PURE__ */ function() {
         var incentiveKey = incentiveKeys[i2];
         keys.push(this._encodeIncentiveKey(incentiveKey));
       }
-      data = import_abi4.defaultAbiCoder.encode([Staker3.INCENTIVE_KEY_ABI + "[]"], [keys]);
+      data = import_abi10.defaultAbiCoder.encode([Staker3.INCENTIVE_KEY_ABI + "[]"], [keys]);
     } else {
-      data = import_abi4.defaultAbiCoder.encode([Staker3.INCENTIVE_KEY_ABI], [this._encodeIncentiveKey(incentiveKeys[0])]);
+      data = import_abi10.defaultAbiCoder.encode([Staker3.INCENTIVE_KEY_ABI], [this._encodeIncentiveKey(incentiveKeys[0])]);
     }
     return data;
   };
@@ -67864,7 +69084,7 @@ var Staker2 = /* @__PURE__ */ function() {
   };
   return Staker3;
 }();
-Staker2.INTERFACE = /* @__PURE__ */ new import_abi4.Interface(UniswapV3Staker_default.abi);
+Staker2.INTERFACE = /* @__PURE__ */ new import_abi10.Interface(UniswapV3Staker_default.abi);
 Staker2.INCENTIVE_KEY_ABI = "tuple(address rewardToken, address pool, uint256 startTime, uint256 endTime, address refundee)";
 var SwapRouter2 = /* @__PURE__ */ function() {
   function SwapRouter3() {}
@@ -67981,12 +69201,12 @@ var SwapRouter2 = /* @__PURE__ */ function() {
   };
   return SwapRouter3;
 }();
-SwapRouter2.INTERFACE = /* @__PURE__ */ new import_abi4.Interface(SwapRouter_default.abi);
+SwapRouter2.INTERFACE = /* @__PURE__ */ new import_abi10.Interface(SwapRouter_default.abi);
 
 // node_modules/@uniswap/v4-sdk/dist/v4-sdk.esm.js
 var import_utils2 = __toESM(require_utils6());
 var import_jsbi5 = __toESM(require_jsbi_umd());
-var import_abi5 = __toESM(require_lib13());
+var import_abi11 = __toESM(require_lib13());
 function _arrayLikeToArray3(r, a) {
   (a == null || a > r.length) && (a = r.length);
   for (var e = 0, n = Array(a);e < a; e++)
@@ -69216,7 +70436,7 @@ var Multicall3 = /* @__PURE__ */ function() {
   };
   return Multicall4;
 }();
-Multicall3.INTERFACE = /* @__PURE__ */ new import_abi5.Interface(IMulticall_default.abi);
+Multicall3.INTERFACE = /* @__PURE__ */ new import_abi11.Interface(IMulticall_default.abi);
 var positionManagerAbi = [{
   type: "constructor",
   inputs: [{
@@ -70373,7 +71593,7 @@ var V4PositionManager = /* @__PURE__ */ function() {
   };
   return V4PositionManager2;
 }();
-V4PositionManager.INTERFACE = /* @__PURE__ */ new import_abi5.Interface(positionManagerAbi);
+V4PositionManager.INTERFACE = /* @__PURE__ */ new import_abi11.Interface(positionManagerAbi);
 
 // src/integrations/uniswapV4/uniswap.v4.ts
 var import_jsbi6 = __toESM(require_jsbi_umd());
@@ -86356,6 +87576,147 @@ var sendOFTTrx = ({
     value: args.nativeFee
   });
 };
+// src/integrations/ccip/ccip.router.abi.ts
+var ccip_router_abi_default = [
+  {
+    inputs: [
+      { name: "destinationChainSelector", type: "uint64" },
+      {
+        name: "message",
+        type: "tuple",
+        components: [
+          { name: "receiver", type: "bytes" },
+          { name: "data", type: "bytes" },
+          {
+            name: "tokenAmounts",
+            type: "tuple[]",
+            components: [
+              { name: "token", type: "address" },
+              { name: "amount", type: "uint256" }
+            ]
+          },
+          { name: "feeToken", type: "address" },
+          { name: "extraArgs", type: "bytes" }
+        ]
+      }
+    ],
+    name: "ccipSend",
+    outputs: [{ name: "messageId", type: "bytes32" }],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "destinationChainSelector", type: "uint64" },
+      {
+        name: "message",
+        type: "tuple",
+        components: [
+          { name: "receiver", type: "bytes" },
+          { name: "data", type: "bytes" },
+          {
+            name: "tokenAmounts",
+            type: "tuple[]",
+            components: [
+              { name: "token", type: "address" },
+              { name: "amount", type: "uint256" }
+            ]
+          },
+          { name: "feeToken", type: "address" },
+          { name: "extraArgs", type: "bytes" }
+        ]
+      }
+    ],
+    name: "getFee",
+    outputs: [{ name: "fee", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+// src/integrations/ccip/ccip.router.ts
+var ccipRouterInterface = new exports_ethers.utils.Interface(ccip_router_abi_default);
+var CCIP_CHAIN_SELECTORS = Object.freeze({
+  1: "5009297550715157269",
+  42161: "4949039107694359620",
+  8453: "15971525489660198786",
+  10: "3734403246176062136",
+  137: "4051577828743386545",
+  56: "11344663589394136015",
+  143: "8481857512324358265"
+});
+var getCCIPChainSelector = (chainId) => {
+  const selector = CCIP_CHAIN_SELECTORS[chainId];
+  if (!selector) {
+    throw new Error(`CCIP: No chain selector for chainId ${chainId}`);
+  }
+  return selector;
+};
+var CCIPGetFeeCalldata = (args) => {
+  return ccipRouterInterface.encodeFunctionData("getFee", [
+    args.destinationChainSelector,
+    {
+      receiver: args.message.receiver,
+      data: args.message.data,
+      tokenAmounts: args.message.tokenAmounts.map((t) => ({
+        token: t.token,
+        amount: t.amount
+      })),
+      feeToken: args.message.feeToken,
+      extraArgs: args.message.extraArgs
+    }
+  ]);
+};
+var CCIPGetFeeTrx = ({
+  routerAddress,
+  args
+}) => {
+  return createCall({
+    operation: 0,
+    to: routerAddress,
+    data: CCIPGetFeeCalldata(args),
+    value: 0n
+  });
+};
+var CCIPSendCalldata = (args) => {
+  return ccipRouterInterface.encodeFunctionData("ccipSend", [
+    args.destinationChainSelector,
+    {
+      receiver: args.message.receiver,
+      data: args.message.data,
+      tokenAmounts: args.message.tokenAmounts.map((t) => ({
+        token: t.token,
+        amount: t.amount
+      })),
+      feeToken: args.message.feeToken,
+      extraArgs: args.message.extraArgs
+    }
+  ]);
+};
+var ccipSendTrx = ({
+  routerAddress,
+  args
+}) => {
+  return createCall({
+    operation: 0,
+    to: routerAddress,
+    data: CCIPSendCalldata(args),
+    value: args.nativeFee
+  });
+};
+var buildCCIPMessage = ({
+  receiver,
+  token,
+  amount
+}) => {
+  const receiverEncoded = "0x" + receiver.slice(2).padStart(64, "0");
+  return Object.freeze({
+    receiver: receiverEncoded,
+    data: "0x",
+    tokenAmounts: Object.freeze([Object.freeze({ token, amount })]),
+    feeToken: "0x0000000000000000000000000000000000000000",
+    extraArgs: "0x"
+  });
+};
 // src/integrations/cctp/token.messenger.v2.abi.ts
 var token_messenger_v2_abi_default = [
   {
@@ -88335,6 +89696,181 @@ var fetchExecutorTxStatus = async ({
   }
   return await response.json();
 };
+// src/integrations/enso/enso.router.abi.ts
+var tokenTuple = {
+  name: "token",
+  type: "tuple",
+  components: [
+    { name: "tokenType", type: "uint8" },
+    { name: "data", type: "bytes" }
+  ]
+};
+var enso_router_abi_default = [
+  {
+    name: "routeSingle",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [
+      { ...tokenTuple, name: "tokenOut" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: []
+  },
+  {
+    name: "safeRouteSingle",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [
+      { ...tokenTuple, name: "tokenIn" },
+      { ...tokenTuple, name: "tokenOut" },
+      { name: "receiver", type: "address" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: []
+  }
+];
+// src/integrations/enso/enso.route.api.ts
+var ENSO_API_BASE = "https://api.enso.finance";
+
+class EnsoRouteApiError extends Error {
+  status;
+  statusText;
+  tokenIn;
+  tokenOut;
+  constructor({
+    status,
+    statusText,
+    tokenIn,
+    tokenOut
+  }) {
+    super(`Enso route API request failed with status ${status} (${statusText}) for swap ${tokenIn} -> ${tokenOut}`);
+    this.name = "EnsoRouteApiError";
+    this.status = status;
+    this.statusText = statusText;
+    this.tokenIn = tokenIn;
+    this.tokenOut = tokenOut;
+  }
+}
+var fetchEnsoRoute = async (args) => {
+  const {
+    chainId,
+    fromAddress,
+    receiver,
+    tokenIn,
+    tokenOut,
+    amountIn,
+    slippageBips,
+    apiKey,
+    apiBase = ENSO_API_BASE
+  } = args;
+  const params = new URLSearchParams({
+    chainId: String(chainId),
+    fromAddress,
+    receiver,
+    tokenIn,
+    tokenOut,
+    amountIn,
+    slippage: String(slippageBips)
+  });
+  const headers = { Accept: "application/json" };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  const response = await fetch(`${apiBase}/api/v1/shortcuts/route?${params.toString()}`, {
+    headers
+  });
+  if (!response.ok) {
+    throw new EnsoRouteApiError({
+      status: response.status,
+      statusText: response.statusText,
+      tokenIn,
+      tokenOut
+    });
+  }
+  return await response.json();
+};
+
+// src/integrations/enso/enso.ts
+var EnsoTokenType;
+((EnsoTokenType2) => {
+  EnsoTokenType2[EnsoTokenType2["Native"] = 0] = "Native";
+  EnsoTokenType2[EnsoTokenType2["ERC20"] = 1] = "ERC20";
+})(EnsoTokenType ||= {});
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+var isNativeToken = (token) => token.toLowerCase() === ZERO_ADDRESS2;
+var encodeEnsoToken = (token, amount) => {
+  if (isNativeToken(token)) {
+    return {
+      tokenType: 0 /* Native */,
+      data: encodeAbiParameters([{ type: "uint256" }], [amount])
+    };
+  }
+  return {
+    tokenType: 1 /* ERC20 */,
+    data: encodeAbiParameters([{ type: "address" }, { type: "uint256" }], [token, amount])
+  };
+};
+var ROUTE_SINGLE_SELECTOR = "0xb94c3609";
+
+class UnexpectedEnsoSelectorError extends Error {
+  selector;
+  constructor(selector) {
+    super(`Expected routeSingle selector ${ROUTE_SINGLE_SELECTOR}, got ${selector}. ` + `The Enso API may have changed its output format.`);
+    this.name = "UnexpectedEnsoSelectorError";
+    this.selector = selector;
+  }
+}
+var rewrapRouteSingleAsSafeRouteSingle = (args) => {
+  const { routeSingleCalldata, tokenIn, amountIn, receiver } = args;
+  const selector = routeSingleCalldata.slice(0, 10).toLowerCase();
+  if (selector !== ROUTE_SINGLE_SELECTOR) {
+    throw new UnexpectedEnsoSelectorError(selector);
+  }
+  const decoded = decodeFunctionData({
+    abi: enso_router_abi_default,
+    data: routeSingleCalldata
+  });
+  if (decoded.functionName !== "routeSingle") {
+    throw new UnexpectedEnsoSelectorError(selector);
+  }
+  const [tokenOutStruct, bundle] = decoded.args;
+  const tokenInStruct = encodeEnsoToken(tokenIn, amountIn);
+  return encodeFunctionData({
+    abi: enso_router_abi_default,
+    functionName: "safeRouteSingle",
+    args: [tokenInStruct, tokenOutStruct, receiver, bundle]
+  });
+};
+
+class EnsoUnexpectedRouterError extends Error {
+  got;
+  expected;
+  constructor(got, expected) {
+    super(`Enso API routed to ${got} but we expected RouterV2 ${expected}. ` + `Unsupported routing (e.g. EnsoWallet / ShortcutsDelegate) — aborting.`);
+    this.name = "EnsoUnexpectedRouterError";
+    this.got = got;
+    this.expected = expected;
+  }
+}
+var ensoSafeRouteSingleTrx = async (args) => {
+  const { routerAddress, tokenIn, amountIn, receiver } = args;
+  const route = await fetchEnsoRoute(args);
+  if (route.tx.to.toLowerCase() !== routerAddress.toLowerCase()) {
+    throw new EnsoUnexpectedRouterError(route.tx.to, routerAddress);
+  }
+  const safeRouteSingleCalldata = rewrapRouteSingleAsSafeRouteSingle({
+    routeSingleCalldata: route.tx.data,
+    tokenIn,
+    amountIn: BigInt(amountIn),
+    receiver
+  });
+  return createCall({
+    to: routerAddress,
+    data: safeRouteSingleCalldata,
+    operation: 0,
+    value: BigInt(route.tx.value || "0")
+  });
+};
 // src/lib/utils.ts
 var executeTrx = ({
   client,
@@ -88429,4 +89965,4 @@ var simulateOrThrow = async (env2) => {
   };
 };
 
-//# debugId=A4ABDA36EAFD3E7D64756E2164756E21
+//# debugId=AF938392ECFE167764756E2164756E21