damm-sdk 1.4.32 → 1.4.33

package/dist/index.cjs

@@ -41,12 +41,77 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// node_modules/abitype/dist/esm/version.js
+var version = "1.0.8";
+
+// node_modules/abitype/dist/esm/errors.js
+var BaseError;
+var init_errors = __esm(() => {
+  BaseError = class BaseError extends Error {
+    constructor(shortMessage, args = {}) {
+      const details = args.cause instanceof BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
+      const docsPath = args.cause instanceof BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
+      const message = [
+        shortMessage || "An error occurred.",
+        "",
+        ...args.metaMessages ? [...args.metaMessages, ""] : [],
+        ...docsPath ? [`Docs: https://abitype.dev${docsPath}`] : [],
+        ...details ? [`Details: ${details}`] : [],
+        `Version: abitype@${version}`
+      ].join(`
+`);
+      super(message);
+      Object.defineProperty(this, "details", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "docsPath", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "metaMessages", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "shortMessage", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "AbiTypeError"
+      });
+      if (args.cause)
+        this.cause = args.cause;
+      this.details = details;
+      this.docsPath = docsPath;
+      this.metaMessages = args.metaMessages;
+      this.shortMessage = shortMessage;
+    }
+  };
+});
+
 // node_modules/abitype/dist/esm/regex.js
 function execTyped(regex, string) {
   const match = regex.exec(string);
   return match?.groups;
 }
-var init_regex = () => {};
+var bytesRegex, integerRegex, isTupleRegex;
+var init_regex = __esm(() => {
+  bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+  integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+  isTupleRegex = /^\(.+?\).*?$/;
+});
 
 // node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
 function formatAbiParameter(abiParameter) {
@@ -113,9 +178,655 @@ var init_formatAbiItem = __esm(() => {
   init_formatAbiParameters();
 });
 
+// node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
+function isErrorSignature(signature) {
+  return errorSignatureRegex.test(signature);
+}
+function execErrorSignature(signature) {
+  return execTyped(errorSignatureRegex, signature);
+}
+function isEventSignature(signature) {
+  return eventSignatureRegex.test(signature);
+}
+function execEventSignature(signature) {
+  return execTyped(eventSignatureRegex, signature);
+}
+function isFunctionSignature(signature) {
+  return functionSignatureRegex.test(signature);
+}
+function execFunctionSignature(signature) {
+  return execTyped(functionSignatureRegex, signature);
+}
+function isStructSignature(signature) {
+  return structSignatureRegex.test(signature);
+}
+function execStructSignature(signature) {
+  return execTyped(structSignatureRegex, signature);
+}
+function isConstructorSignature(signature) {
+  return constructorSignatureRegex.test(signature);
+}
+function execConstructorSignature(signature) {
+  return execTyped(constructorSignatureRegex, signature);
+}
+function isFallbackSignature(signature) {
+  return fallbackSignatureRegex.test(signature);
+}
+function execFallbackSignature(signature) {
+  return execTyped(fallbackSignatureRegex, signature);
+}
+function isReceiveSignature(signature) {
+  return receiveSignatureRegex.test(signature);
+}
+var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, modifiers, eventModifiers, functionModifiers;
+var init_signatures = __esm(() => {
+  init_regex();
+  errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+  eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+  functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
+  structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
+  constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
+  fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
+  receiveSignatureRegex = /^receive\(\) external payable$/;
+  modifiers = new Set([
+    "memory",
+    "indexed",
+    "storage",
+    "calldata"
+  ]);
+  eventModifiers = new Set(["indexed"]);
+  functionModifiers = new Set([
+    "calldata",
+    "memory",
+    "storage"
+  ]);
+});
+
+// node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
+var UnknownTypeError, UnknownSolidityTypeError;
+var init_abiItem = __esm(() => {
+  init_errors();
+  UnknownTypeError = class UnknownTypeError extends BaseError {
+    constructor({ type }) {
+      super("Unknown type.", {
+        metaMessages: [
+          `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
+        ]
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "UnknownTypeError"
+      });
+    }
+  };
+  UnknownSolidityTypeError = class UnknownSolidityTypeError extends BaseError {
+    constructor({ type }) {
+      super("Unknown type.", {
+        metaMessages: [`Type "${type}" is not a valid ABI type.`]
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "UnknownSolidityTypeError"
+      });
+    }
+  };
+});
+
+// node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
+var InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
+var init_abiParameter = __esm(() => {
+  init_errors();
+  InvalidParameterError = class InvalidParameterError extends BaseError {
+    constructor({ param }) {
+      super("Invalid ABI parameter.", {
+        details: param
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "InvalidParameterError"
+      });
+    }
+  };
+  SolidityProtectedKeywordError = class SolidityProtectedKeywordError extends BaseError {
+    constructor({ param, name }) {
+      super("Invalid ABI parameter.", {
+        details: param,
+        metaMessages: [
+          `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
+        ]
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "SolidityProtectedKeywordError"
+      });
+    }
+  };
+  InvalidModifierError = class InvalidModifierError extends BaseError {
+    constructor({ param, type, modifier }) {
+      super("Invalid ABI parameter.", {
+        details: param,
+        metaMessages: [
+          `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`
+        ]
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "InvalidModifierError"
+      });
+    }
+  };
+  InvalidFunctionModifierError = class InvalidFunctionModifierError extends BaseError {
+    constructor({ param, type, modifier }) {
+      super("Invalid ABI parameter.", {
+        details: param,
+        metaMessages: [
+          `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`,
+          `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`
+        ]
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "InvalidFunctionModifierError"
+      });
+    }
+  };
+  InvalidAbiTypeParameterError = class InvalidAbiTypeParameterError extends BaseError {
+    constructor({ abiParameter }) {
+      super("Invalid ABI parameter.", {
+        details: JSON.stringify(abiParameter, null, 2),
+        metaMessages: ["ABI parameter type is invalid."]
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "InvalidAbiTypeParameterError"
+      });
+    }
+  };
+});
+
+// node_modules/abitype/dist/esm/human-readable/errors/signature.js
+var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
+var init_signature = __esm(() => {
+  init_errors();
+  InvalidSignatureError = class InvalidSignatureError extends BaseError {
+    constructor({ signature, type }) {
+      super(`Invalid ${type} signature.`, {
+        details: signature
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "InvalidSignatureError"
+      });
+    }
+  };
+  UnknownSignatureError = class UnknownSignatureError extends BaseError {
+    constructor({ signature }) {
+      super("Unknown signature.", {
+        details: signature
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "UnknownSignatureError"
+      });
+    }
+  };
+  InvalidStructSignatureError = class InvalidStructSignatureError extends BaseError {
+    constructor({ signature }) {
+      super("Invalid struct signature.", {
+        details: signature,
+        metaMessages: ["No properties exist."]
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "InvalidStructSignatureError"
+      });
+    }
+  };
+});
+
+// node_modules/abitype/dist/esm/human-readable/errors/struct.js
+var CircularReferenceError;
+var init_struct = __esm(() => {
+  init_errors();
+  CircularReferenceError = class CircularReferenceError extends BaseError {
+    constructor({ type }) {
+      super("Circular reference detected.", {
+        metaMessages: [`Struct "${type}" is a circular reference.`]
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "CircularReferenceError"
+      });
+    }
+  };
+});
+
+// node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
+var InvalidParenthesisError;
+var init_splitParameters = __esm(() => {
+  init_errors();
+  InvalidParenthesisError = class InvalidParenthesisError extends BaseError {
+    constructor({ current, depth }) {
+      super("Unbalanced parentheses.", {
+        metaMessages: [
+          `"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`
+        ],
+        details: `Depth "${depth}"`
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "InvalidParenthesisError"
+      });
+    }
+  };
+});
+
+// node_modules/abitype/dist/esm/human-readable/runtime/cache.js
+function getParameterCacheKey(param, type, structs) {
+  let structKey = "";
+  if (structs)
+    for (const struct of Object.entries(structs)) {
+      if (!struct)
+        continue;
+      let propertyKey = "";
+      for (const property of struct[1]) {
+        propertyKey += `[${property.type}${property.name ? `:${property.name}` : ""}]`;
+      }
+      structKey += `(${struct[0]}{${propertyKey}})`;
+    }
+  if (type)
+    return `${type}:${param}${structKey}`;
+  return param;
+}
+var parameterCache;
+var init_cache = __esm(() => {
+  parameterCache = new Map([
+    ["address", { type: "address" }],
+    ["bool", { type: "bool" }],
+    ["bytes", { type: "bytes" }],
+    ["bytes32", { type: "bytes32" }],
+    ["int", { type: "int256" }],
+    ["int256", { type: "int256" }],
+    ["string", { type: "string" }],
+    ["uint", { type: "uint256" }],
+    ["uint8", { type: "uint8" }],
+    ["uint16", { type: "uint16" }],
+    ["uint24", { type: "uint24" }],
+    ["uint32", { type: "uint32" }],
+    ["uint64", { type: "uint64" }],
+    ["uint96", { type: "uint96" }],
+    ["uint112", { type: "uint112" }],
+    ["uint160", { type: "uint160" }],
+    ["uint192", { type: "uint192" }],
+    ["uint256", { type: "uint256" }],
+    ["address owner", { type: "address", name: "owner" }],
+    ["address to", { type: "address", name: "to" }],
+    ["bool approved", { type: "bool", name: "approved" }],
+    ["bytes _data", { type: "bytes", name: "_data" }],
+    ["bytes data", { type: "bytes", name: "data" }],
+    ["bytes signature", { type: "bytes", name: "signature" }],
+    ["bytes32 hash", { type: "bytes32", name: "hash" }],
+    ["bytes32 r", { type: "bytes32", name: "r" }],
+    ["bytes32 root", { type: "bytes32", name: "root" }],
+    ["bytes32 s", { type: "bytes32", name: "s" }],
+    ["string name", { type: "string", name: "name" }],
+    ["string symbol", { type: "string", name: "symbol" }],
+    ["string tokenURI", { type: "string", name: "tokenURI" }],
+    ["uint tokenId", { type: "uint256", name: "tokenId" }],
+    ["uint8 v", { type: "uint8", name: "v" }],
+    ["uint256 balance", { type: "uint256", name: "balance" }],
+    ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
+    ["uint256 value", { type: "uint256", name: "value" }],
+    [
+      "event:address indexed from",
+      { type: "address", name: "from", indexed: true }
+    ],
+    ["event:address indexed to", { type: "address", name: "to", indexed: true }],
+    [
+      "event:uint indexed tokenId",
+      { type: "uint256", name: "tokenId", indexed: true }
+    ],
+    [
+      "event:uint256 indexed tokenId",
+      { type: "uint256", name: "tokenId", indexed: true }
+    ]
+  ]);
+});
+
+// node_modules/abitype/dist/esm/human-readable/runtime/utils.js
+function parseSignature(signature, structs = {}) {
+  if (isFunctionSignature(signature))
+    return parseFunctionSignature(signature, structs);
+  if (isEventSignature(signature))
+    return parseEventSignature(signature, structs);
+  if (isErrorSignature(signature))
+    return parseErrorSignature(signature, structs);
+  if (isConstructorSignature(signature))
+    return parseConstructorSignature(signature, structs);
+  if (isFallbackSignature(signature))
+    return parseFallbackSignature(signature);
+  if (isReceiveSignature(signature))
+    return {
+      type: "receive",
+      stateMutability: "payable"
+    };
+  throw new UnknownSignatureError({ signature });
+}
+function parseFunctionSignature(signature, structs = {}) {
+  const match = execFunctionSignature(signature);
+  if (!match)
+    throw new InvalidSignatureError({ signature, type: "function" });
+  const inputParams = splitParameters(match.parameters);
+  const inputs = [];
+  const inputLength = inputParams.length;
+  for (let i = 0;i < inputLength; i++) {
+    inputs.push(parseAbiParameter(inputParams[i], {
+      modifiers: functionModifiers,
+      structs,
+      type: "function"
+    }));
+  }
+  const outputs = [];
+  if (match.returns) {
+    const outputParams = splitParameters(match.returns);
+    const outputLength = outputParams.length;
+    for (let i = 0;i < outputLength; i++) {
+      outputs.push(parseAbiParameter(outputParams[i], {
+        modifiers: functionModifiers,
+        structs,
+        type: "function"
+      }));
+    }
+  }
+  return {
+    name: match.name,
+    type: "function",
+    stateMutability: match.stateMutability ?? "nonpayable",
+    inputs,
+    outputs
+  };
+}
+function parseEventSignature(signature, structs = {}) {
+  const match = execEventSignature(signature);
+  if (!match)
+    throw new InvalidSignatureError({ signature, type: "event" });
+  const params = splitParameters(match.parameters);
+  const abiParameters = [];
+  const length = params.length;
+  for (let i = 0;i < length; i++)
+    abiParameters.push(parseAbiParameter(params[i], {
+      modifiers: eventModifiers,
+      structs,
+      type: "event"
+    }));
+  return { name: match.name, type: "event", inputs: abiParameters };
+}
+function parseErrorSignature(signature, structs = {}) {
+  const match = execErrorSignature(signature);
+  if (!match)
+    throw new InvalidSignatureError({ signature, type: "error" });
+  const params = splitParameters(match.parameters);
+  const abiParameters = [];
+  const length = params.length;
+  for (let i = 0;i < length; i++)
+    abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
+  return { name: match.name, type: "error", inputs: abiParameters };
+}
+function parseConstructorSignature(signature, structs = {}) {
+  const match = execConstructorSignature(signature);
+  if (!match)
+    throw new InvalidSignatureError({ signature, type: "constructor" });
+  const params = splitParameters(match.parameters);
+  const abiParameters = [];
+  const length = params.length;
+  for (let i = 0;i < length; i++)
+    abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
+  return {
+    type: "constructor",
+    stateMutability: match.stateMutability ?? "nonpayable",
+    inputs: abiParameters
+  };
+}
+function parseFallbackSignature(signature) {
+  const match = execFallbackSignature(signature);
+  if (!match)
+    throw new InvalidSignatureError({ signature, type: "fallback" });
+  return {
+    type: "fallback",
+    stateMutability: match.stateMutability ?? "nonpayable"
+  };
+}
+function parseAbiParameter(param, options) {
+  const parameterCacheKey = getParameterCacheKey(param, options?.type, options?.structs);
+  if (parameterCache.has(parameterCacheKey))
+    return parameterCache.get(parameterCacheKey);
+  const isTuple = isTupleRegex.test(param);
+  const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
+  if (!match)
+    throw new InvalidParameterError({ param });
+  if (match.name && isSolidityKeyword(match.name))
+    throw new SolidityProtectedKeywordError({ param, name: match.name });
+  const name = match.name ? { name: match.name } : {};
+  const indexed = match.modifier === "indexed" ? { indexed: true } : {};
+  const structs = options?.structs ?? {};
+  let type;
+  let components = {};
+  if (isTuple) {
+    type = "tuple";
+    const params = splitParameters(match.type);
+    const components_ = [];
+    const length = params.length;
+    for (let i = 0;i < length; i++) {
+      components_.push(parseAbiParameter(params[i], { structs }));
+    }
+    components = { components: components_ };
+  } else if (match.type in structs) {
+    type = "tuple";
+    components = { components: structs[match.type] };
+  } else if (dynamicIntegerRegex.test(match.type)) {
+    type = `${match.type}256`;
+  } else {
+    type = match.type;
+    if (!(options?.type === "struct") && !isSolidityType(type))
+      throw new UnknownSolidityTypeError({ type });
+  }
+  if (match.modifier) {
+    if (!options?.modifiers?.has?.(match.modifier))
+      throw new InvalidModifierError({
+        param,
+        type: options?.type,
+        modifier: match.modifier
+      });
+    if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
+      throw new InvalidFunctionModifierError({
+        param,
+        type: options?.type,
+        modifier: match.modifier
+      });
+  }
+  const abiParameter = {
+    type: `${type}${match.array ?? ""}`,
+    ...name,
+    ...indexed,
+    ...components
+  };
+  parameterCache.set(parameterCacheKey, abiParameter);
+  return abiParameter;
+}
+function splitParameters(params, result = [], current = "", depth = 0) {
+  const length = params.trim().length;
+  for (let i = 0;i < length; i++) {
+    const char = params[i];
+    const tail = params.slice(i + 1);
+    switch (char) {
+      case ",":
+        return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
+      case "(":
+        return splitParameters(tail, result, `${current}${char}`, depth + 1);
+      case ")":
+        return splitParameters(tail, result, `${current}${char}`, depth - 1);
+      default:
+        return splitParameters(tail, result, `${current}${char}`, depth);
+    }
+  }
+  if (current === "")
+    return result;
+  if (depth !== 0)
+    throw new InvalidParenthesisError({ current, depth });
+  result.push(current.trim());
+  return result;
+}
+function isSolidityType(type) {
+  return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
+}
+function isSolidityKeyword(name) {
+  return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
+}
+function isValidDataLocation(type, isArray) {
+  return isArray || type === "bytes" || type === "string" || type === "tuple";
+}
+var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
+var init_utils = __esm(() => {
+  init_regex();
+  init_abiItem();
+  init_abiParameter();
+  init_signature();
+  init_splitParameters();
+  init_cache();
+  init_signatures();
+  abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
+  abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
+  dynamicIntegerRegex = /^u?int$/;
+  protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
+});
+
+// node_modules/abitype/dist/esm/human-readable/runtime/structs.js
+function parseStructs(signatures) {
+  const shallowStructs = {};
+  const signaturesLength = signatures.length;
+  for (let i = 0;i < signaturesLength; i++) {
+    const signature = signatures[i];
+    if (!isStructSignature(signature))
+      continue;
+    const match = execStructSignature(signature);
+    if (!match)
+      throw new InvalidSignatureError({ signature, type: "struct" });
+    const properties = match.properties.split(";");
+    const components = [];
+    const propertiesLength = properties.length;
+    for (let k = 0;k < propertiesLength; k++) {
+      const property = properties[k];
+      const trimmed = property.trim();
+      if (!trimmed)
+        continue;
+      const abiParameter = parseAbiParameter(trimmed, {
+        type: "struct"
+      });
+      components.push(abiParameter);
+    }
+    if (!components.length)
+      throw new InvalidStructSignatureError({ signature });
+    shallowStructs[match.name] = components;
+  }
+  const resolvedStructs = {};
+  const entries = Object.entries(shallowStructs);
+  const entriesLength = entries.length;
+  for (let i = 0;i < entriesLength; i++) {
+    const [name, parameters] = entries[i];
+    resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
+  }
+  return resolvedStructs;
+}
+function resolveStructs(abiParameters, structs, ancestors = new Set) {
+  const components = [];
+  const length = abiParameters.length;
+  for (let i = 0;i < length; i++) {
+    const abiParameter = abiParameters[i];
+    const isTuple = isTupleRegex.test(abiParameter.type);
+    if (isTuple)
+      components.push(abiParameter);
+    else {
+      const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
+      if (!match?.type)
+        throw new InvalidAbiTypeParameterError({ abiParameter });
+      const { array, type } = match;
+      if (type in structs) {
+        if (ancestors.has(type))
+          throw new CircularReferenceError({ type });
+        components.push({
+          ...abiParameter,
+          type: `tuple${array ?? ""}`,
+          components: resolveStructs(structs[type] ?? [], structs, new Set([...ancestors, type]))
+        });
+      } else {
+        if (isSolidityType(type))
+          components.push(abiParameter);
+        else
+          throw new UnknownTypeError({ type });
+      }
+    }
+  }
+  return components;
+}
+var typeWithoutTupleRegex;
+var init_structs = __esm(() => {
+  init_regex();
+  init_abiItem();
+  init_abiParameter();
+  init_signature();
+  init_struct();
+  init_signatures();
+  init_utils();
+  typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
+});
+
+// node_modules/abitype/dist/esm/human-readable/parseAbi.js
+function parseAbi(signatures) {
+  const structs = parseStructs(signatures);
+  const abi = [];
+  const length = signatures.length;
+  for (let i = 0;i < length; i++) {
+    const signature = signatures[i];
+    if (isStructSignature(signature))
+      continue;
+    abi.push(parseSignature(signature, structs));
+  }
+  return abi;
+}
+var init_parseAbi = __esm(() => {
+  init_signatures();
+  init_structs();
+  init_utils();
+});
+
 // node_modules/abitype/dist/esm/exports/index.js
 var init_exports = __esm(() => {
   init_formatAbiItem();
+  init_parseAbi();
 });
 
 // node_modules/viem/_esm/utils/abi/formatAbiItem.js
@@ -157,7 +868,7 @@ function size(value) {
 var init_size = () => {};
 
 // node_modules/viem/_esm/errors/version.js
-var version = "2.33.2";
+var version2 = "2.33.2";
 
 // node_modules/viem/_esm/errors/base.js
 function walk(err, fn) {
@@ -167,23 +878,23 @@ function walk(err, fn) {
     return walk(err.cause, fn);
   return fn ? null : err;
 }
-var errorConfig, BaseError;
+var errorConfig, BaseError2;
 var init_base = __esm(() => {
   errorConfig = {
     getDocsUrl: ({ docsBaseUrl, docsPath = "", docsSlug }) => docsPath ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath}${docsSlug ? `#${docsSlug}` : ""}` : undefined,
-    version: `viem@${version}`
+    version: `viem@${version2}`
   };
-  BaseError = class BaseError extends Error {
+  BaseError2 = class BaseError2 extends Error {
     constructor(shortMessage, args = {}) {
       const details = (() => {
-        if (args.cause instanceof BaseError)
+        if (args.cause instanceof BaseError2)
           return args.cause.details;
         if (args.cause?.message)
           return args.cause.message;
         return args.details;
       })();
       const docsPath = (() => {
-        if (args.cause instanceof BaseError)
+        if (args.cause instanceof BaseError2)
           return args.cause.docsPath || args.docsPath;
         return args.docsPath;
       })();
@@ -239,7 +950,7 @@ var init_base = __esm(() => {
       this.metaMessages = args.metaMessages;
       this.name = args.name ?? this.name;
       this.shortMessage = shortMessage;
-      this.version = version;
+      this.version = version2;
     }
     walk(fn) {
       return walk(this, fn);
@@ -253,7 +964,7 @@ var init_abi = __esm(() => {
   init_formatAbiItem2();
   init_size();
   init_base();
-  AbiDecodingDataSizeTooSmallError = class AbiDecodingDataSizeTooSmallError extends BaseError {
+  AbiDecodingDataSizeTooSmallError = class AbiDecodingDataSizeTooSmallError extends BaseError2 {
     constructor({ data, params, size: size2 }) {
       super([`Data size of ${size2} bytes is too small for given parameters.`].join(`
 `), {
@@ -286,14 +997,14 @@ var init_abi = __esm(() => {
       this.size = size2;
     }
   };
-  AbiDecodingZeroDataError = class AbiDecodingZeroDataError extends BaseError {
+  AbiDecodingZeroDataError = class AbiDecodingZeroDataError extends BaseError2 {
     constructor() {
       super('Cannot decode zero data ("0x") with ABI parameters.', {
         name: "AbiDecodingZeroDataError"
       });
     }
   };
-  AbiEncodingArrayLengthMismatchError = class AbiEncodingArrayLengthMismatchError extends BaseError {
+  AbiEncodingArrayLengthMismatchError = class AbiEncodingArrayLengthMismatchError extends BaseError2 {
     constructor({ expectedLength, givenLength, type }) {
       super([
         `ABI encoding array length mismatch for type ${type}.`,
@@ -303,12 +1014,12 @@ var init_abi = __esm(() => {
 `), { name: "AbiEncodingArrayLengthMismatchError" });
     }
   };
-  AbiEncodingBytesSizeMismatchError = class AbiEncodingBytesSizeMismatchError extends BaseError {
+  AbiEncodingBytesSizeMismatchError = class AbiEncodingBytesSizeMismatchError extends BaseError2 {
     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 {
+  AbiEncodingLengthMismatchError = class AbiEncodingLengthMismatchError extends BaseError2 {
     constructor({ expectedLength, givenLength }) {
       super([
         "ABI encoding params/values length mismatch.",
@@ -318,7 +1029,7 @@ var init_abi = __esm(() => {
 `), { name: "AbiEncodingLengthMismatchError" });
     }
   };
-  AbiFunctionNotFoundError = class AbiFunctionNotFoundError extends BaseError {
+  AbiFunctionNotFoundError = class AbiFunctionNotFoundError extends BaseError2 {
     constructor(functionName, { docsPath } = {}) {
       super([
         `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
@@ -330,7 +1041,7 @@ var init_abi = __esm(() => {
       });
     }
   };
-  AbiFunctionSignatureNotFoundError = class AbiFunctionSignatureNotFoundError extends BaseError {
+  AbiFunctionSignatureNotFoundError = class AbiFunctionSignatureNotFoundError extends BaseError2 {
     constructor(signature, { docsPath }) {
       super([
         `Encoded function signature "${signature}" not found on ABI.`,
@@ -343,7 +1054,7 @@ var init_abi = __esm(() => {
       });
     }
   };
-  AbiItemAmbiguityError = class AbiItemAmbiguityError extends BaseError {
+  AbiItemAmbiguityError = class AbiItemAmbiguityError extends BaseError2 {
     constructor(x, y) {
       super("Found ambiguous types in overloaded ABI items.", {
         metaMessages: [
@@ -357,7 +1068,7 @@ var init_abi = __esm(() => {
       });
     }
   };
-  InvalidAbiEncodingTypeError = class InvalidAbiEncodingTypeError extends BaseError {
+  InvalidAbiEncodingTypeError = class InvalidAbiEncodingTypeError extends BaseError2 {
     constructor(type, { docsPath }) {
       super([
         `Type "${type}" is not a valid encoding type.`,
@@ -366,7 +1077,7 @@ var init_abi = __esm(() => {
 `), { docsPath, name: "InvalidAbiEncodingType" });
     }
   };
-  InvalidAbiDecodingTypeError = class InvalidAbiDecodingTypeError extends BaseError {
+  InvalidAbiDecodingTypeError = class InvalidAbiDecodingTypeError extends BaseError2 {
     constructor(type, { docsPath }) {
       super([
         `Type "${type}" is not a valid decoding type.`,
@@ -375,7 +1086,7 @@ var init_abi = __esm(() => {
 `), { docsPath, name: "InvalidAbiDecodingType" });
     }
   };
-  InvalidArrayError = class InvalidArrayError extends BaseError {
+  InvalidArrayError = class InvalidArrayError extends BaseError2 {
     constructor(value) {
       super([`Value "${value}" is not a valid array.`].join(`
 `), {
@@ -383,7 +1094,7 @@ var init_abi = __esm(() => {
       });
     }
   };
-  InvalidDefinitionTypeError = class InvalidDefinitionTypeError extends BaseError {
+  InvalidDefinitionTypeError = class InvalidDefinitionTypeError extends BaseError2 {
     constructor(type) {
       super([
         `"${type}" is not a valid definition type.`,
@@ -398,12 +1109,12 @@ var init_abi = __esm(() => {
 var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
 var init_data = __esm(() => {
   init_base();
-  SliceOffsetOutOfBoundsError = class SliceOffsetOutOfBoundsError extends BaseError {
+  SliceOffsetOutOfBoundsError = class SliceOffsetOutOfBoundsError extends BaseError2 {
     constructor({ offset, position, size: size2 }) {
       super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size2}).`, { name: "SliceOffsetOutOfBoundsError" });
     }
   };
-  SizeExceedsPaddingSizeError = class SizeExceedsPaddingSizeError extends BaseError {
+  SizeExceedsPaddingSizeError = class SizeExceedsPaddingSizeError extends BaseError2 {
     constructor({ size: size2, targetSize, type }) {
       super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
     }
@@ -452,19 +1163,19 @@ var init_pad = __esm(() => {
 var IntegerOutOfRangeError, InvalidBytesBooleanError, SizeOverflowError;
 var init_encoding = __esm(() => {
   init_base();
-  IntegerOutOfRangeError = class IntegerOutOfRangeError extends BaseError {
+  IntegerOutOfRangeError = class IntegerOutOfRangeError extends BaseError2 {
     constructor({ max, min, signed, size: size2, value }) {
       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 {
+  InvalidBytesBooleanError = class InvalidBytesBooleanError extends BaseError2 {
     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 {
+  SizeOverflowError = class SizeOverflowError extends BaseError2 {
     constructor({ givenSize, maxSize }) {
       super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
     }
@@ -634,7 +1345,7 @@ function hexToBytes(hex_, opts = {}) {
     const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
     const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
     if (nibbleLeft === undefined || nibbleRight === undefined) {
-      throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+      throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
     }
     bytes[index] = nibbleLeft * 16 + nibbleRight;
   }
@@ -758,7 +1469,7 @@ function createHasher(hashCons) {
   return hashC;
 }
 var isLE, swap32IfBE;
-var init_utils = __esm(() => {
+var init_utils2 = __esm(() => {
   /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
   swap32IfBE = isLE ? (u) => u : byteSwap32;
@@ -808,7 +1519,7 @@ function keccakP(s, rounds = 24) {
 var _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_PI, SHA3_ROTL, _SHA3_IOTA, IOTAS, SHA3_IOTA_H, SHA3_IOTA_L, rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s), rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s), Keccak, gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen)), keccak_256;
 var init_sha3 = __esm(() => {
   init__u64();
-  init_utils();
+  init_utils2();
   _0n = BigInt(0);
   _1n = BigInt(1);
   _2n = BigInt(2);
@@ -1010,7 +1721,7 @@ function normalizeSignature(signature) {
     current += char;
   }
   if (!valid)
-    throw new BaseError("Unable to normalize signature.");
+    throw new BaseError2("Unable to normalize signature.");
   return result;
 }
 var init_normalizeSignature = __esm(() => {
@@ -1051,7 +1762,7 @@ var init_toEventSelector = __esm(() => {
 var InvalidAddressError;
 var init_address = __esm(() => {
   init_base();
-  InvalidAddressError = class InvalidAddressError extends BaseError {
+  InvalidAddressError = class InvalidAddressError extends BaseError2 {
     constructor({ address }) {
       super(`Address "${address}" is invalid.`, {
         metaMessages: [
@@ -1228,9 +1939,9 @@ var init_slice = __esm(() => {
 });
 
 // node_modules/viem/_esm/utils/regex.js
-var integerRegex;
+var integerRegex2;
 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)?$/;
+  integerRegex2 = /^(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
@@ -1275,7 +1986,7 @@ function prepareParam({ param, value }) {
   }
   if (param.type.startsWith("uint") || param.type.startsWith("int")) {
     const signed = param.type.startsWith("int");
-    const [, , size2 = "256"] = integerRegex.exec(param.type) ?? [];
+    const [, , size2 = "256"] = integerRegex2.exec(param.type) ?? [];
     return encodeNumber(value, {
       signed,
       size: Number(size2)
@@ -1379,7 +2090,7 @@ function encodeBytes(value, { param }) {
 }
 function encodeBool(value) {
   if (typeof value !== "boolean")
-    throw new BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
+    throw new BaseError2(`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 }) {
@@ -1631,19 +2342,19 @@ var init_encodeFunctionData = __esm(() => {
 var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
 var init_cursor = __esm(() => {
   init_base();
-  NegativeOffsetError = class NegativeOffsetError extends BaseError {
+  NegativeOffsetError = class NegativeOffsetError extends BaseError2 {
     constructor({ offset }) {
       super(`Offset \`${offset}\` cannot be negative.`, {
         name: "NegativeOffsetError"
       });
     }
   };
-  PositionOutOfBoundsError = class PositionOutOfBoundsError extends BaseError {
+  PositionOutOfBoundsError = class PositionOutOfBoundsError extends BaseError2 {
     constructor({ length, position }) {
       super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
     }
   };
-  RecursiveReadLimitExceededError = class RecursiveReadLimitExceededError extends BaseError {
+  RecursiveReadLimitExceededError = class RecursiveReadLimitExceededError extends BaseError2 {
     constructor({ count, limit }) {
       super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
     }
@@ -8653,7 +9364,7 @@ var require_hash = __commonJS((exports2) => {
   hash2.ripemd160 = hash2.ripemd.ripemd160;
 });
 
-// node_modules/aes-js/index.js
+// node_modules/@ethersproject/json-wallets/node_modules/aes-js/index.js
 var require_aes_js = __commonJS((exports2, module2) => {
   (function(root) {
     function checkInt2(value) {
@@ -12775,10 +13486,10 @@ var require_lib = __commonJS((exports2) => {
   })(ErrorCode2 = exports2.ErrorCode || (exports2.ErrorCode = {}));
   var HEX2 = "0123456789abcdef";
   var Logger2 = function() {
-    function Logger3(version28) {
+    function Logger3(version29) {
       Object.defineProperty(this, "version", {
         enumerable: true,
-        value: version28,
+        value: version29,
         writable: false
       });
     }
@@ -13005,8 +13716,8 @@ var require_lib = __commonJS((exports2) => {
       }
       _logLevel2 = level;
     };
-    Logger3.from = function(version28) {
-      return new Logger3(version28);
+    Logger3.from = function(version29) {
+      return new Logger3(version29);
     };
     Logger3.errors = ErrorCode2;
     Logger3.levels = LogLevel2;
@@ -22120,7 +22831,7 @@ var require_utils3 = __commonJS((exports2) => {
 var exports_process = {};
 __export(exports_process, {
   versions: () => versions,
-  version: () => version28,
+  version: () => version29,
   umask: () => umask,
   title: () => title,
   removeListener: () => removeListener,
@@ -22177,7 +22888,7 @@ function nextTick(fun) {
     setTimeout(drainQueue, 0);
 }
 function noop() {}
-var queue, draining = false, currentQueue, queueIndex = -1, title = "browser", browser = true, env, argv, version28 = "", versions, on, addListener, once, off, removeListener, removeAllListeners, emit, prependListener, prependOnceListener, listeners = function(name) {
+var queue, draining = false, currentQueue, queueIndex = -1, title = "browser", browser = true, env, argv, version29 = "", versions, on, addListener, once, off, removeListener, removeAllListeners, emit, prependListener, prependOnceListener, listeners = function(name) {
   return [];
 }, binding = function(name) {
   throw new Error("process.binding is not supported in browser polyfill");
@@ -46195,6 +46906,7 @@ __export(exports_src, {
   gnosisTrx: () => gnosisTrx,
   getWormholeScanApiUrl: () => getWormholeScanApiUrl,
   getWormholeChainId: () => getWormholeChainId,
+  getMorphoPublicAllocatorAddress: () => getMorphoPublicAllocatorAddress,
   getGnosisTrxSimulationResult: () => getGnosisTrxSimulationResult,
   getExecutorApiUrl: () => getExecutorApiUrl,
   getCctpV2Domain: () => getCctpV2Domain,
@@ -46219,6 +46931,7 @@ __export(exports_src, {
   ensoSafeRouteSingleTrx: () => ensoSafeRouteSingleTrx,
   ensoRouterAbi: () => enso_router_abi_default,
   encodeTransceiverInstructions: () => encodeTransceiverInstructions,
+  encodeReallocateTo: () => encodeReallocateTo,
   encodeEnsoToken: () => encodeEnsoToken,
   depositToLendleTrx: () => depositToLendleTrx,
   depositSyrupVaultTrx: () => depositSyrupVaultTrx,
@@ -46246,6 +46959,7 @@ __export(exports_src, {
   calculateDeterministicVaultAddress: () => calculateDeterministicVaultAddress,
   buildWormholeTransferArgsFromAvatar: () => buildWormholeTransferArgsFromAvatar,
   buildRelayInstructions: () => buildRelayInstructions,
+  buildReallocateToCall: () => buildReallocateToCall,
   buildMonadDefaultTransceiverInstructions: () => buildMonadDefaultTransceiverInstructions,
   buildCCIPMessage: () => buildCCIPMessage,
   borrowMorphoBlueTrx: () => borrowMorphoBlueTrx,
@@ -46360,6 +47074,7 @@ __export(exports_src, {
   ReceiveMessageCalldata: () => ReceiveMessageCalldata,
   QuoteSendTrx: () => QuoteSendTrx,
   QuoteSendCalldata: () => QuoteSendCalldata,
+  PublicAllocatorReallocateToAbi: () => PublicAllocatorReallocateToAbi,
   Permit2Abi: () => permit2_abi_default,
   PauseVaultCalldata: () => PauseVaultCalldata,
   PERMIT2_ADDRESS_CANONICAL: () => PERMIT2_ADDRESS_CANONICAL,
@@ -46824,6 +47539,9 @@ var erc721_abi_default = [
     type: "function"
   }
 ];
+// node_modules/viem/_esm/index.js
+init_exports();
+
 // node_modules/viem/_esm/constants/address.js
 var zeroAddress = "0x0000000000000000000000000000000000000000";
 // node_modules/viem/_esm/index.js
@@ -46857,7 +47575,7 @@ var createCall = (call) => {
 var exports_ethers = {};
 __export(exports_ethers, {
   wordlists: () => wordlists,
-  version: () => version27,
+  version: () => version28,
   utils: () => exports_utils,
   providers: () => exports_lib4,
   logger: () => logger46,
@@ -46879,7 +47597,7 @@ __export(exports_ethers, {
 var import_bn = __toESM(require_bn());
 
 // node_modules/@ethersproject/logger/lib.esm/_version.js
-var version2 = "logger/5.7.0";
+var version3 = "logger/5.7.0";
 
 // node_modules/@ethersproject/logger/lib.esm/index.js
 var _permanentCensorErrors = false;
@@ -46944,10 +47662,10 @@ var ErrorCode;
 var HEX = "0123456789abcdef";
 
 class Logger {
-  constructor(version3) {
+  constructor(version4) {
     Object.defineProperty(this, "version", {
       enumerable: true,
-      value: version3,
+      value: version4,
       writable: false
     });
   }
@@ -47133,7 +47851,7 @@ class Logger {
   }
   static globalLogger() {
     if (!_globalLogger) {
-      _globalLogger = new Logger(version2);
+      _globalLogger = new Logger(version3);
     }
     return _globalLogger;
   }
@@ -47162,18 +47880,18 @@ class Logger {
     }
     _logLevel = level;
   }
-  static from(version3) {
-    return new Logger(version3);
+  static from(version4) {
+    return new Logger(version4);
   }
 }
 Logger.errors = ErrorCode;
 Logger.levels = LogLevel;
 
 // node_modules/@ethersproject/bytes/lib.esm/_version.js
-var version3 = "bytes/5.7.0";
+var version4 = "bytes/5.7.0";
 
 // node_modules/@ethersproject/bytes/lib.esm/index.js
-var logger = new Logger(version3);
+var logger = new Logger(version4);
 function isHexable(value) {
   return !!value.toHexString;
 }
@@ -47538,11 +48256,11 @@ function joinSignature(signature) {
 }
 
 // node_modules/@ethersproject/bignumber/lib.esm/_version.js
-var version4 = "bignumber/5.7.0";
+var version5 = "bignumber/5.7.0";
 
 // node_modules/@ethersproject/bignumber/lib.esm/bignumber.js
 var BN = import_bn.default.BN;
-var logger2 = new Logger(version4);
+var logger2 = new Logger(version5);
 var _constructorGuard = {};
 var MAX_SAFE = 9007199254740991;
 function isBigNumberish(value) {
@@ -47806,7 +48524,7 @@ function _base16To36(value) {
   return new BN(value, 16).toString(36);
 }
 // node_modules/@ethersproject/bignumber/lib.esm/fixednumber.js
-var logger3 = new Logger(version4);
+var logger3 = new Logger(version5);
 var _constructorGuard2 = {};
 var Zero = BigNumber.from(0);
 var NegativeOne = BigNumber.from(-1);
@@ -48145,7 +48863,7 @@ class FixedNumber {
 var ONE = FixedNumber.from(1);
 var BUMP = FixedNumber.from("0.5");
 // node_modules/@ethersproject/properties/lib.esm/_version.js
-var version5 = "properties/5.7.0";
+var version6 = "properties/5.7.0";
 
 // node_modules/@ethersproject/properties/lib.esm/index.js
 var __awaiter = function(thisArg, _arguments, P, generator) {
@@ -48175,7 +48893,7 @@ var __awaiter = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger4 = new Logger(version5);
+var logger4 = new Logger(version6);
 function defineReadOnly(object, name, value) {
   Object.defineProperty(object, name, {
     enumerable: true,
@@ -48283,10 +49001,10 @@ class Description {
 }
 
 // node_modules/@ethersproject/abi/lib.esm/_version.js
-var version6 = "abi/5.7.0";
+var version7 = "abi/5.7.0";
 
 // node_modules/@ethersproject/abi/lib.esm/fragments.js
-var logger5 = new Logger(version6);
+var logger5 = new Logger(version7);
 var _constructorGuard3 = {};
 var ModifiersBytes = { calldata: true, memory: true, storage: true };
 var ModifiersNest = { calldata: true, memory: true };
@@ -49092,7 +49810,7 @@ function splitNesting(value) {
 }
 
 // node_modules/@ethersproject/abi/lib.esm/coders/abstract-coder.js
-var logger6 = new Logger(version6);
+var logger6 = new Logger(version7);
 function checkResultErrors(result) {
   const errors = [];
   const checkErrors = function(path, object) {
@@ -49248,10 +49966,10 @@ __export(exports_lib, {
 });
 
 // node_modules/@ethersproject/rlp/lib.esm/_version.js
-var version7 = "rlp/5.7.0";
+var version8 = "rlp/5.7.0";
 
 // node_modules/@ethersproject/rlp/lib.esm/index.js
-var logger7 = new Logger(version7);
+var logger7 = new Logger(version8);
 function arrayifyInteger(value) {
   const result = [];
   while (value) {
@@ -49361,10 +50079,10 @@ function decode(data) {
 }
 
 // node_modules/@ethersproject/address/lib.esm/_version.js
-var version8 = "address/5.7.0";
+var version9 = "address/5.7.0";
 
 // node_modules/@ethersproject/address/lib.esm/index.js
-var logger8 = new Logger(version8);
+var logger8 = new Logger(version9);
 function getChecksumAddress(address) {
   if (!isHexString(address, 20)) {
     logger8.throwArgumentError("invalid address", "address", address);
@@ -49517,7 +50235,7 @@ class AnonymousCoder extends Coder {
 }
 
 // node_modules/@ethersproject/abi/lib.esm/coders/array.js
-var logger9 = new Logger(version6);
+var logger9 = new Logger(version7);
 function pack(writer, coders, values) {
   let arrayValues = null;
   if (Array.isArray(values)) {
@@ -49861,10 +50579,10 @@ class NumberCoder extends Coder {
 }
 
 // node_modules/@ethersproject/strings/lib.esm/_version.js
-var version9 = "strings/5.7.0";
+var version10 = "strings/5.7.0";
 
 // node_modules/@ethersproject/strings/lib.esm/utf8.js
-var logger10 = new Logger(version9);
+var logger10 = new Logger(version10);
 var UnicodeNormalizationForm;
 (function(UnicodeNormalizationForm2) {
   UnicodeNormalizationForm2["current"] = "";
@@ -50327,7 +51045,7 @@ class TupleCoder extends Coder {
 }
 
 // node_modules/@ethersproject/abi/lib.esm/abi-coder.js
-var logger11 = new Logger(version6);
+var logger11 = new Logger(version7);
 var paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
 var paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
 
@@ -50413,7 +51131,7 @@ function id(text) {
 }
 
 // node_modules/@ethersproject/hash/lib.esm/_version.js
-var version10 = "hash/5.7.0";
+var version11 = "hash/5.7.0";
 
 // node_modules/@ethersproject/base64/lib.esm/index.js
 var exports_lib3 = {};
@@ -50766,7 +51484,7 @@ function consume_emoji_reversed(cps, eaten) {
 }
 
 // node_modules/@ethersproject/hash/lib.esm/namehash.js
-var logger12 = new Logger(version10);
+var logger12 = new Logger(version11);
 var Zeros = new Uint8Array(32);
 Zeros.fill(0);
 function checkComponent(comp) {
@@ -50866,7 +51584,7 @@ var __awaiter2 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger13 = new Logger(version10);
+var logger13 = new Logger(version11);
 var padding = new Uint8Array(32);
 padding.fill(0);
 var NegativeOne3 = BigNumber.from(-1);
@@ -51261,7 +51979,7 @@ class TypedDataEncoder {
 }
 
 // node_modules/@ethersproject/abi/lib.esm/interface.js
-var logger14 = new Logger(version6);
+var logger14 = new Logger(version7);
 class LogDescription extends Description {
 }
 
@@ -51781,7 +52499,7 @@ class Interface {
 }
 
 // node_modules/@ethersproject/abstract-provider/lib.esm/_version.js
-var version11 = "abstract-provider/5.7.0";
+var version12 = "abstract-provider/5.7.0";
 
 // node_modules/@ethersproject/abstract-provider/lib.esm/index.js
 var __awaiter3 = function(thisArg, _arguments, P, generator) {
@@ -51811,7 +52529,7 @@ var __awaiter3 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger15 = new Logger(version11);
+var logger15 = new Logger(version12);
 
 class ForkEvent extends Description {
   static isForkEvent(value) {
@@ -51852,7 +52570,7 @@ class Provider {
 }
 
 // node_modules/@ethersproject/abstract-signer/lib.esm/_version.js
-var version12 = "abstract-signer/5.7.0";
+var version13 = "abstract-signer/5.7.0";
 
 // node_modules/@ethersproject/abstract-signer/lib.esm/index.js
 var __awaiter4 = function(thisArg, _arguments, P, generator) {
@@ -51882,7 +52600,7 @@ var __awaiter4 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger16 = new Logger(version12);
+var logger16 = new Logger(version13);
 var allowedTransactionKeys = [
   "accessList",
   "ccipReadEnabled",
@@ -53967,10 +54685,10 @@ var elliptic_1 = createCommonjsModule(function(module2, exports2) {
 var EC$1 = elliptic_1.ec;
 
 // node_modules/@ethersproject/signing-key/lib.esm/_version.js
-var version13 = "signing-key/5.7.0";
+var version14 = "signing-key/5.7.0";
 
 // node_modules/@ethersproject/signing-key/lib.esm/index.js
-var logger17 = new Logger(version13);
+var logger17 = new Logger(version14);
 var _curve = null;
 function getCurve() {
   if (!_curve) {
@@ -54046,10 +54764,10 @@ function computePublicKey(key2, compressed) {
 }
 
 // node_modules/@ethersproject/transactions/lib.esm/_version.js
-var version14 = "transactions/5.7.0";
+var version15 = "transactions/5.7.0";
 
 // node_modules/@ethersproject/transactions/lib.esm/index.js
-var logger18 = new Logger(version14);
+var logger18 = new Logger(version15);
 var TransactionTypes;
 (function(TransactionTypes2) {
   TransactionTypes2[TransactionTypes2["legacy"] = 0] = "legacy";
@@ -54397,7 +55115,7 @@ function parse(rawTransaction) {
 }
 
 // node_modules/@ethersproject/contracts/lib.esm/_version.js
-var version15 = "contracts/5.7.0";
+var version16 = "contracts/5.7.0";
 
 // node_modules/@ethersproject/contracts/lib.esm/index.js
 var __awaiter5 = function(thisArg, _arguments, P, generator) {
@@ -54427,7 +55145,7 @@ var __awaiter5 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger19 = new Logger(version15);
+var logger19 = new Logger(version16);
 var allowedTransactionKeys3 = {
   chainId: true,
   data: true,
@@ -55406,10 +56124,10 @@ var SupportedAlgorithm;
 })(SupportedAlgorithm || (SupportedAlgorithm = {}));
 
 // node_modules/@ethersproject/sha2/lib.esm/_version.js
-var version16 = "sha2/5.7.0";
+var version17 = "sha2/5.7.0";
 
 // node_modules/@ethersproject/sha2/lib.esm/sha2.js
-var logger20 = new Logger(version16);
+var logger20 = new Logger(version17);
 function ripemd160(data) {
   return "0x" + import_hash3.default.ripemd160().update(arrayify(data)).digest("hex");
 }
@@ -55465,11 +56183,11 @@ function pbkdf2(password, salt, iterations, keylen, hashAlgorithm) {
   return hexlify(DK);
 }
 // node_modules/@ethersproject/wordlists/lib.esm/_version.js
-var version17 = "wordlists/5.7.0";
+var version18 = "wordlists/5.7.0";
 
 // node_modules/@ethersproject/wordlists/lib.esm/wordlist.js
 var exportWordlist = false;
-var logger21 = new Logger(version17);
+var logger21 = new Logger(version18);
 
 class Wordlist {
   constructor(locale) {
@@ -55548,10 +56266,10 @@ var wordlists = {
 };
 
 // node_modules/@ethersproject/hdnode/lib.esm/_version.js
-var version18 = "hdnode/5.7.0";
+var version19 = "hdnode/5.7.0";
 
 // node_modules/@ethersproject/hdnode/lib.esm/index.js
-var logger22 = new Logger(version18);
+var logger22 = new Logger(version19);
 var N = BigNumber.from("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
 var MasterSecret = toUtf8Bytes("Bitcoin seed");
 var HardenedBit = 2147483648;
@@ -55825,10 +56543,10 @@ function getAccountPath(index) {
 }
 
 // node_modules/@ethersproject/random/lib.esm/_version.js
-var version19 = "random/5.7.0";
+var version20 = "random/5.7.0";
 
 // node_modules/@ethersproject/random/lib.esm/random.js
-var logger23 = new Logger(version19);
+var logger23 = new Logger(version20);
 function getGlobal() {
   if (typeof self !== "undefined") {
     return self;
@@ -55876,7 +56594,7 @@ function shuffled(array) {
 var import_aes_js = __toESM(require_aes_js());
 
 // node_modules/@ethersproject/json-wallets/lib.esm/_version.js
-var version20 = "json-wallets/5.7.0";
+var version21 = "json-wallets/5.7.0";
 
 // node_modules/@ethersproject/json-wallets/lib.esm/utils.js
 function looseArrayify(hexString) {
@@ -55931,7 +56649,7 @@ function uuidV4(randomBytes2) {
 }
 
 // node_modules/@ethersproject/json-wallets/lib.esm/crowdsale.js
-var logger24 = new Logger(version20);
+var logger24 = new Logger(version21);
 
 class CrowdsaleAccount extends Description {
   isCrowdsaleAccount(value) {
@@ -56034,7 +56752,7 @@ var __awaiter6 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger25 = new Logger(version20);
+var logger25 = new Logger(version21);
 function hasMnemonic(value) {
   return value != null && value.mnemonic && value.mnemonic.phrase;
 }
@@ -56319,7 +57037,7 @@ function decryptJsonWalletSync(json, password) {
 }
 
 // node_modules/@ethersproject/wallet/lib.esm/_version.js
-var version21 = "wallet/5.7.0";
+var version22 = "wallet/5.7.0";
 
 // node_modules/@ethersproject/wallet/lib.esm/index.js
 var __awaiter7 = function(thisArg, _arguments, P, generator) {
@@ -56349,7 +57067,7 @@ var __awaiter7 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger26 = new Logger(version21);
+var logger26 = new Logger(version22);
 function isAccount(value) {
   return value != null && isHexString(value.privateKey, 32) && value.address != null;
 }
@@ -56531,10 +57249,10 @@ __export(exports_lib4, {
 });
 
 // node_modules/@ethersproject/networks/lib.esm/_version.js
-var version22 = "networks/5.7.1";
+var version23 = "networks/5.7.1";
 
 // node_modules/@ethersproject/networks/lib.esm/index.js
-var logger27 = new Logger(version22);
+var logger27 = new Logger(version23);
 function isRenetworkable(value) {
   return value && typeof value.renetwork === "function";
 }
@@ -56753,7 +57471,7 @@ function getNetwork(network) {
 }
 
 // node_modules/@ethersproject/web/lib.esm/_version.js
-var version23 = "web/5.7.1";
+var version24 = "web/5.7.1";
 
 // node_modules/@ethersproject/web/lib.esm/geturl.js
 var __awaiter8 = function(thisArg, _arguments, P, generator) {
@@ -56867,7 +57585,7 @@ var __awaiter9 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger28 = new Logger(version23);
+var logger28 = new Logger(version24);
 function staller(duration) {
   return new Promise((resolve) => {
     setTimeout(resolve, duration);
@@ -57222,10 +57940,10 @@ function poll(func, options) {
 var import_bech32 = __toESM(require_bech32());
 
 // node_modules/@ethersproject/providers/lib.esm/_version.js
-var version24 = "providers/5.7.2";
+var version25 = "providers/5.7.2";
 
 // node_modules/@ethersproject/providers/lib.esm/formatter.js
-var logger29 = new Logger(version24);
+var logger29 = new Logger(version25);
 
 class Formatter {
   constructor() {
@@ -57660,7 +58378,7 @@ var __awaiter10 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger30 = new Logger(version24);
+var logger30 = new Logger(version25);
 var MAX_CCIP_REDIRECTS = 10;
 function checkTopic(topic) {
   if (topic == null) {
@@ -57955,17 +58673,17 @@ class Resolver {
     }
     if (coinInfo.prefix != null) {
       const length = bytes[1];
-      let version25 = bytes[0];
-      if (version25 === 0) {
+      let version26 = bytes[0];
+      if (version26 === 0) {
         if (length !== 20 && length !== 32) {
-          version25 = -1;
+          version26 = -1;
         }
       } else {
-        version25 = -1;
+        version26 = -1;
       }
-      if (version25 >= 0 && bytes.length === 2 + length && length >= 1 && length <= 75) {
+      if (version26 >= 0 && bytes.length === 2 + length && length >= 1 && length <= 75) {
         const words2 = import_bech32.default.toWords(bytes.slice(2));
-        words2.unshift(version25);
+        words2.unshift(version26);
         return import_bech32.default.encode(coinInfo.prefix, words2);
       }
     }
@@ -59448,7 +60166,7 @@ var __awaiter11 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger31 = new Logger(version24);
+var logger31 = new Logger(version25);
 var errorGas = ["call", "estimateGas"];
 function spelunk(value, requireData) {
   if (value == null) {
@@ -60078,7 +60796,7 @@ try {
     throw new Error("inject please");
   }
 } catch (error) {
-  const logger32 = new Logger(version24);
+  const logger32 = new Logger(version25);
   WS = function() {
     logger32.throwError("WebSockets not supported in this environment", Logger.errors.UNSUPPORTED_OPERATION, {
       operation: "new WebSocket()"
@@ -60114,7 +60832,7 @@ var __awaiter12 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger32 = new Logger(version24);
+var logger32 = new Logger(version25);
 var NextId = 1;
 
 class WebSocketProvider extends JsonRpcProvider {
@@ -60385,7 +61103,7 @@ var __awaiter13 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger33 = new Logger(version24);
+var logger33 = new Logger(version25);
 
 class StaticJsonRpcProvider extends JsonRpcProvider {
   detectNetwork() {
@@ -60447,7 +61165,7 @@ class UrlJsonRpcProvider extends StaticJsonRpcProvider {
 }
 
 // node_modules/@ethersproject/providers/lib.esm/alchemy-provider.js
-var logger34 = new Logger(version24);
+var logger34 = new Logger(version25);
 var defaultApiKey = "_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC";
 
 class AlchemyWebSocketProvider extends WebSocketProvider {
@@ -60522,7 +61240,7 @@ class AlchemyProvider extends UrlJsonRpcProvider {
 }
 
 // node_modules/@ethersproject/providers/lib.esm/ankr-provider.js
-var logger35 = new Logger(version24);
+var logger35 = new Logger(version25);
 var defaultApiKey2 = "9f7d929b018cdffb338517efa06f58359e86ff1ffd350bc889738523659e7972";
 function getHost(name) {
   switch (name) {
@@ -60602,7 +61320,7 @@ var __awaiter14 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger36 = new Logger(version24);
+var logger36 = new Logger(version25);
 
 class CloudflareProvider extends UrlJsonRpcProvider {
   static getApiKey(apiKey) {
@@ -60664,7 +61382,7 @@ var __awaiter15 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger37 = new Logger(version24);
+var logger37 = new Logger(version25);
 function getTransactionPostData(transaction) {
   const result = {};
   for (let key2 in transaction) {
@@ -61080,7 +61798,7 @@ var __awaiter16 = function(thisArg, _arguments, P, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var logger38 = new Logger(version24);
+var logger38 = new Logger(version25);
 function now() {
   return new Date().getTime();
 }
@@ -61584,7 +62302,7 @@ class FallbackProvider extends BaseProvider {
 var IpcProvider = null;
 
 // node_modules/@ethersproject/providers/lib.esm/infura-provider.js
-var logger39 = new Logger(version24);
+var logger39 = new Logger(version25);
 var defaultProjectId = "84842078b09946638c03157f83405213";
 
 class InfuraWebSocketProvider extends WebSocketProvider {
@@ -61755,7 +62473,7 @@ class JsonRpcBatchProvider extends JsonRpcProvider {
 }
 
 // node_modules/@ethersproject/providers/lib.esm/nodesmith-provider.js
-var logger40 = new Logger(version24);
+var logger40 = new Logger(version25);
 var defaultApiKey3 = "ETHERS_JS_SHARED";
 
 class NodesmithProvider extends UrlJsonRpcProvider {
@@ -61792,7 +62510,7 @@ class NodesmithProvider extends UrlJsonRpcProvider {
 }
 
 // node_modules/@ethersproject/providers/lib.esm/pocket-provider.js
-var logger41 = new Logger(version24);
+var logger41 = new Logger(version25);
 var defaultApplicationId = "62e1ad51b37b8e00394bda3b";
 
 class PocketProvider extends UrlJsonRpcProvider {
@@ -61860,7 +62578,7 @@ class PocketProvider extends UrlJsonRpcProvider {
 }
 
 // node_modules/@ethersproject/providers/lib.esm/web3-provider.js
-var logger42 = new Logger(version24);
+var logger42 = new Logger(version25);
 var _nextId = 1;
 function buildWeb3LegacyFetcher(provider, sendFunc) {
   const fetcher = "Web3LegacyFetcher";
@@ -61984,7 +62702,7 @@ class Web3Provider extends JsonRpcProvider {
 }
 
 // node_modules/@ethersproject/providers/lib.esm/index.js
-var logger43 = new Logger(version24);
+var logger43 = new Logger(version25);
 function getDefaultProvider(network, options) {
   if (network == null) {
     network = "homestead";
@@ -62131,14 +62849,14 @@ __export(exports_utils, {
 });
 
 // node_modules/@ethersproject/solidity/lib.esm/_version.js
-var version25 = "solidity/5.7.0";
+var version26 = "solidity/5.7.0";
 
 // node_modules/@ethersproject/solidity/lib.esm/index.js
 var regexBytes = new RegExp("^bytes([0-9]+)$");
 var regexNumber = new RegExp("^(u?int)([0-9]*)$");
 var regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
 var Zeros2 = "0000000000000000000000000000000000000000000000000000000000000000";
-var logger44 = new Logger(version25);
+var logger44 = new Logger(version26);
 function _pack(type, value, isArray) {
   switch (type) {
     case "address":
@@ -62216,10 +62934,10 @@ function sha2562(types, values) {
 }
 
 // node_modules/@ethersproject/units/lib.esm/_version.js
-var version26 = "units/5.7.0";
+var version27 = "units/5.7.0";
 
 // node_modules/@ethersproject/units/lib.esm/index.js
-var logger45 = new Logger(version26);
+var logger45 = new Logger(version27);
 var names = [
   "wei",
   "kwei",
@@ -62295,10 +63013,10 @@ function parseEther(ether) {
 }
 
 // node_modules/ethers/lib.esm/_version.js
-var version27 = "ethers/5.7.2";
+var version28 = "ethers/5.7.2";
 
 // node_modules/ethers/lib.esm/ethers.js
-var logger46 = new Logger(version27);
+var logger46 = new Logger(version28);
 
 // node_modules/ethers/lib.esm/index.js
 try {
@@ -62968,7 +63686,8 @@ var contractsRegistry_default = {
     wrappedNativeToken: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
     morpho: {
       morphoBlue: "0x6c247b1F6182318877311737BaC0844bAa518F5e",
-      vaultV1_0: "0x7c574174DA4b2be3f705c6244B4BfA0815a8B3Ed"
+      vaultV1_0: "0x7c574174DA4b2be3f705c6244B4BfA0815a8B3Ed",
+      publicAllocator: "0x769583Af5e9D03589F159EbEC31Cc2c23E8C355E"
     },
     poster: "0x000000000000cd17345801aa8147b8D3950260FF",
     cctp: {
@@ -63040,7 +63759,8 @@ var contractsRegistry_default = {
     wrappedNativeToken: "0x4200000000000000000000000000000000000006",
     morpho: {
       morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
-      vaultV1_0: "0xBEEFE94c8aD530842bfE7d8B397938fFc1cb83b2"
+      vaultV1_0: "0xBEEFE94c8aD530842bfE7d8B397938fFc1cb83b2",
+      publicAllocator: "0xA090dD1a701408Df1d4d0B85b716c87565f90467"
     },
     cctp: {
       tokenMessengerV2: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
@@ -63134,7 +63854,8 @@ var contractsRegistry_default = {
     wrappedNativeToken: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
     morpho: {
       morphoBlue: "0x1bF0c2541F820E775182832f06c0B7Fc27A25f67",
-      vaultV1_0: "0x781FB7F6d845E3bE129289833b04d43Aa8558c42"
+      vaultV1_0: "0x781FB7F6d845E3bE129289833b04d43Aa8558c42",
+      publicAllocator: "0xfac15aff53ADd2ff80C2962127C434E8615Df0d3"
     },
     cctp: {
       tokenMessengerV2: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
@@ -63213,6 +63934,10 @@ var contractsRegistry_default = {
     },
     ccip: {
       router: "0x34B03Cb9086d7D758AC55af71584F81A598759FE"
+    },
+    morpho: {
+      morphoBlue: "0x01b0Bd309AA75547f7a37Ad7B1219A898E67a83a",
+      publicAllocator: "0x842bEccF8eBC11006c4bE96DEfE09b60326D0495"
     }
   },
   optimism: {
@@ -63268,7 +63993,8 @@ var contractsRegistry_default = {
       aggregatorV6: "0x111111125421cA6dc452d289314280a0f8842A65"
     },
     morpho: {
-      morphoBlue: "0xce95AfbB8EA029495c66020883F87aaE8864AF92"
+      morphoBlue: "0xce95AfbB8EA029495c66020883F87aaE8864AF92",
+      publicAllocator: "0x0d68a97324E602E02799CD83B42D337207B40658"
     },
     cctp: {
       tokenMessengerV2: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
@@ -63404,7 +64130,8 @@ var contractsRegistry_default = {
     },
     morpho: {
       morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
-      vaultV1_0: "0xBEEFFF7e4EedD83A4a4aB53A68D03eC77C9a57a8"
+      vaultV1_0: "0xBEEFFF7e4EedD83A4a4aB53A68D03eC77C9a57a8",
+      publicAllocator: "0xfd32fA2ca22c76dD6E550706Ad913FC6CE91c75D"
     },
     lido: {
       steth: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
@@ -63544,7 +64271,8 @@ var contractsRegistry_default = {
     },
     permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
     morpho: {
-      morphoBlue: "0x8f5ae9CddB9f68de460C77730b018Ae7E04a140A"
+      morphoBlue: "0x8f5ae9CddB9f68de460C77730b018Ae7E04a140A",
+      publicAllocator: "0xB0c9a107fA17c779B3378210A7a593e88938C7C9"
     },
     cctp: {
       tokenMessengerV2: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
@@ -63653,7 +64381,8 @@ var contractsRegistry_default = {
       multisendUnwrapper: "0xB4Cd4bb764C089f20DA18700CE8bc5e49F369efD"
     },
     morpho: {
-      morphoBlue: "0xE741BC7c34758b4caE05062794E8Ae24978AF432"
+      morphoBlue: "0xE741BC7c34758b4caE05062794E8Ae24978AF432",
+      publicAllocator: "0xef9889B4e443DEd35FA0Bd060f2104Cca94e6A43"
     },
     cctp: {
       tokenMessengerV2: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
@@ -63760,7 +64489,11 @@ var contractsRegistry_default = {
     },
     multicall3: "0xcA11bde05977b3631167028862bE2a173976CA11",
     permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-    poster: "0x000000000000cd17345801aa8147b8D3950260FF"
+    poster: "0x000000000000cd17345801aa8147b8D3950260FF",
+    morpho: {
+      morphoBlue: "0xd24ECdD8C1e0E57a4E26B1a7bbeAa3e95466A569",
+      publicAllocator: "0x3Fe12193D178B76BaF4e23a083A64e49ACDE3188"
+    }
   },
   monad: {
     merkl: {
@@ -64030,8 +64763,8 @@ class MultisendBuilder {
       data
     });
   }
-  static new(chainId, version28 = "v1_4_1") {
-    return new MultisendBuilder(getAddressOrThrow(chainId, `gnosisSafe.${version28}.multisend`));
+  static new(chainId, version29 = "v1_4_1") {
+    return new MultisendBuilder(getAddressOrThrow(chainId, `gnosisSafe.${version29}.multisend`));
   }
 }
 // src/integrations/gnosis/safe.L2.abi.ts
@@ -76956,7 +77689,7 @@ var SwapRouter2 = /* @__PURE__ */ function() {
 SwapRouter2.INTERFACE = /* @__PURE__ */ new Interface(SwapRouter_default.abi);
 
 // node_modules/@uniswap/v4-sdk/dist/v4-sdk.esm.js
-var import_utils4 = __toESM(require_utils6());
+var import_utils6 = __toESM(require_utils6());
 var import_jsbi5 = __toESM(require_jsbi_umd());
 function _arrayLikeToArray3(r2, a) {
   (a == null || a > r2.length) && (a = r2.length);
@@ -77428,7 +78161,7 @@ var Hook = /* @__PURE__ */ function() {
     return !!(parseInt(address, 16) & 1 << hookFlagIndex[hookOption]);
   };
   Hook2._checkAddress = function _checkAddress(address) {
-    !import_utils4.isAddress(address) && invariant(false, "invalid address");
+    !import_utils6.isAddress(address) && invariant(false, "invalid address");
   };
   return Hook2;
 }();
@@ -77467,7 +78200,7 @@ var Pool3 = /* @__PURE__ */ function() {
     if (ticks === undefined) {
       ticks = NO_TICK_DATA_PROVIDER_DEFAULT3;
     }
-    !import_utils4.isAddress(hooks) && invariant(false, "Invalid hook address");
+    !import_utils6.isAddress(hooks) && invariant(false, "Invalid hook address");
     !(Number.isInteger(fee) && (fee === DYNAMIC_FEE_FLAG || fee < 1e6)) && invariant(false, "FEE");
     if (fee === DYNAMIC_FEE_FLAG) {
       !(Number(hooks) > 0) && invariant(false, "Dynamic fee pool requires a hook");
@@ -77489,7 +78222,7 @@ var Pool3 = /* @__PURE__ */ function() {
     this.poolId = Pool4.getPoolId(this.currency0, this.currency1, this.fee, this.tickSpacing, this.hooks);
   }
   Pool4.getPoolKey = function getPoolKey(currencyA, currencyB, fee, tickSpacing, hooks) {
-    !import_utils4.isAddress(hooks) && invariant(false, "Invalid hook address");
+    !import_utils6.isAddress(hooks) && invariant(false, "Invalid hook address");
     var _ref2 = sortsBefore(currencyA, currencyB) ? [currencyA, currencyB] : [currencyB, currencyA], currency0 = _ref2[0], currency1 = _ref2[1];
     var currency0Addr = currency0.isNative ? ADDRESS_ZERO3 : currency0.wrapped.address;
     var currency1Addr = currency1.isNative ? ADDRESS_ZERO3 : currency1.wrapped.address;
@@ -77505,7 +78238,7 @@ var Pool3 = /* @__PURE__ */ function() {
     var _ref3 = sortsBefore(currencyA, currencyB) ? [currencyA, currencyB] : [currencyB, currencyA], currency0 = _ref3[0], currency1 = _ref3[1];
     var currency0Addr = currency0.isNative ? ADDRESS_ZERO3 : currency0.wrapped.address;
     var currency1Addr = currency1.isNative ? ADDRESS_ZERO3 : currency1.wrapped.address;
-    return keccak2563(["bytes"], [import_utils4.defaultAbiCoder.encode(["address", "address", "uint24", "int24", "address"], [currency0Addr, currency1Addr, fee, tickSpacing, hooks])]);
+    return keccak2563(["bytes"], [import_utils6.defaultAbiCoder.encode(["address", "address", "uint24", "int24", "address"], [currency0Addr, currency1Addr, fee, tickSpacing, hooks])]);
   };
   var _proto = Pool4.prototype;
   _proto.involvesCurrency = function involvesCurrency(currency) {
@@ -78095,7 +78828,7 @@ var V4Planner = /* @__PURE__ */ function() {
     return this;
   };
   _proto.finalize = function finalize() {
-    return import_utils4.defaultAbiCoder.encode(["bytes", "bytes[]"], [this.actions, this.params]);
+    return import_utils6.defaultAbiCoder.encode(["bytes", "bytes[]"], [this.actions, this.params]);
   };
   return V4Planner2;
 }();
@@ -78103,7 +78836,7 @@ function currencyAddress(currency) {
   return currency.isNative ? ADDRESS_ZERO3 : currency.wrapped.address;
 }
 function createAction(action, parameters) {
-  var encodedInput = import_utils4.defaultAbiCoder.encode(V4_BASE_ACTIONS_ABI_DEFINITION[action].map(function(v) {
+  var encodedInput = import_utils6.defaultAbiCoder.encode(V4_BASE_ACTIONS_ABI_DEFINITION[action].map(function(v) {
     return v.type;
   }), parameters);
   return {
@@ -86745,7 +87478,7 @@ var silo_abi_default = [
   }
 ];
 // src/integrations/lagoonV1/lagoon.v1.ts
-var import_utils5 = __toESM(require_utils6());
+var import_utils7 = __toESM(require_utils6());
 var factoryInterface = new exports_ethers.utils.Interface(factory_abi_default);
 var vaultInterface = new exports_ethers.utils.Interface(vault_abi_default);
 var CreateVaultProxyCalldata = ({
@@ -86897,7 +87630,7 @@ var calculateDeterministicVaultAddress = ({
   wrappedNativeToken,
   initStruct
 }) => {
-  const initEncoded = import_utils5.defaultAbiCoder.encode(["tuple(address,string,string,address,address,address,address,address,uint16,uint16,bool,uint256)"], [
+  const initEncoded = import_utils7.defaultAbiCoder.encode(["tuple(address,string,string,address,address,address,address,address,uint16,uint16,bool,uint256)"], [
     [
       initStruct.underlying,
       initStruct.name,
@@ -86917,11 +87650,11 @@ var calculateDeterministicVaultAddress = ({
     "function initialize(bytes data, address feeRegistry, address wrappedNativeToken)"
   ]);
   const initCall = iface.encodeFunctionData("initialize", [initEncoded, registry, wrappedNativeToken]);
-  const constructorEncoded = import_utils5.defaultAbiCoder.encode(["address", "address", "address", "uint256", "bytes"], [initStruct.logic, registry, initStruct.initialOwner, initStruct.initialDelay, initCall]);
+  const constructorEncoded = import_utils7.defaultAbiCoder.encode(["address", "address", "address", "uint256", "bytes"], [initStruct.logic, registry, initStruct.initialOwner, initStruct.initialDelay, initCall]);
   const initCode = OPTIN_PROXY_CREATION_BYTECODE + constructorEncoded.slice(2);
-  const create2Inputs = import_utils5.solidityPack(["bytes1", "address", "bytes32", "bytes32"], ["0xff", factoryAddress, initStruct.salt, import_utils5.keccak256(initCode)]);
-  const computedAddress = `0x${import_utils5.keccak256(create2Inputs).slice(-40)}`;
-  return import_utils5.getAddress(computedAddress);
+  const create2Inputs = import_utils7.solidityPack(["bytes1", "address", "bytes32", "bytes32"], ["0xff", factoryAddress, initStruct.salt, import_utils7.keccak256(initCode)]);
+  const computedAddress = `0x${import_utils7.keccak256(create2Inputs).slice(-40)}`;
+  return import_utils7.getAddress(computedAddress);
 };
 // src/integrations/lendleV1/lendle.pool.abi.ts
 var lendle_pool_abi_default = [
@@ -93343,6 +94076,31 @@ var withdrawMorphoVaultAssetTrx = ({
 };
 var WithdrawMorphoVaultCalldata = RedeemMorphoVaultCalldata;
 var withdrawMorphoVaultTrx = redeemMorphoVaultTrx;
+// src/integrations/morphoPublicAllocator/morpho.public.allocator.abi.ts
+var PublicAllocatorReallocateToAbi = parseAbi([
+  "function reallocateTo(address vault, ((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint128 amount)[] withdrawals, (address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) supplyMarketParams) payable"
+]);
+
+// src/integrations/morphoPublicAllocator/morpho.public.allocator.ts
+var getMorphoPublicAllocatorAddress = (chainId) => {
+  return getAddressOrThrow(chainId, "morpho.publicAllocator");
+};
+var encodeReallocateTo = (params) => {
+  const { vault, withdrawals, supplyMarketParams } = params;
+  return encodeFunctionData({
+    abi: PublicAllocatorReallocateToAbi,
+    functionName: "reallocateTo",
+    args: [vault, withdrawals, supplyMarketParams]
+  });
+};
+var buildReallocateToCall = (params) => {
+  const { chainId, vault, withdrawals, supplyMarketParams, feeWei } = params;
+  return {
+    to: getMorphoPublicAllocatorAddress(chainId),
+    data: encodeReallocateTo({ vault, withdrawals, supplyMarketParams }),
+    value: feeWei
+  };
+};
 // src/integrations/merkl/merkl.distributor.abi.ts
 var merkl_distributor_abi_default = [
   { inputs: [], stateMutability: "nonpayable", type: "constructor" },
@@ -96246,16 +97004,16 @@ var decodeCctpV2Header = (message) => {
   if (length < HEADER_BYTE_LENGTH) {
     throw new Error(`CCTP decoder: header requires ${HEADER_BYTE_LENGTH} bytes, got ${length}`);
   }
-  const version29 = hexToNumber(sliceHex(bytes, OFF_VERSION, OFF_SOURCE_DOMAIN));
-  if (version29 !== CCTP_V2_HEADER_VERSION) {
-    throw new Error(`CCTP decoder: unknown header version ${version29} (expected ${CCTP_V2_HEADER_VERSION})`);
+  const version30 = hexToNumber(sliceHex(bytes, OFF_VERSION, OFF_SOURCE_DOMAIN));
+  if (version30 !== CCTP_V2_HEADER_VERSION) {
+    throw new Error(`CCTP decoder: unknown header version ${version30} (expected ${CCTP_V2_HEADER_VERSION})`);
   }
   const senderPadded = sliceHex(bytes, OFF_SENDER, OFF_RECIPIENT);
   const recipientPadded = sliceHex(bytes, OFF_RECIPIENT, OFF_DESTINATION_CALLER);
   const sender = getAddress(`0x${senderPadded.slice(2 + 24)}`);
   const recipient = getAddress(`0x${recipientPadded.slice(2 + 24)}`);
   return Object.freeze({
-    version: version29,
+    version: version30,
     sourceDomain: hexToNumber(sliceHex(bytes, OFF_SOURCE_DOMAIN, OFF_DEST_DOMAIN)),
     destinationDomain: hexToNumber(sliceHex(bytes, OFF_DEST_DOMAIN, OFF_NONCE)),
     nonce: sliceHex(bytes, OFF_NONCE, OFF_SENDER),
@@ -96273,15 +97031,15 @@ var decodeCctpV2BurnBody = (body) => {
   if (length < BURN_BODY_FIXED_BYTE_LENGTH) {
     throw new Error(`CCTP decoder: burn body requires ${BURN_BODY_FIXED_BYTE_LENGTH} bytes, got ${length}`);
   }
-  const version29 = hexToNumber(sliceHex(bytes, BODY_OFF_VERSION, BODY_OFF_BURN_TOKEN));
-  if (version29 !== CCTP_V2_BURN_BODY_VERSION) {
-    throw new Error(`CCTP decoder: unknown burn body version ${version29} (expected ${CCTP_V2_BURN_BODY_VERSION})`);
+  const version30 = hexToNumber(sliceHex(bytes, BODY_OFF_VERSION, BODY_OFF_BURN_TOKEN));
+  if (version30 !== CCTP_V2_BURN_BODY_VERSION) {
+    throw new Error(`CCTP decoder: unknown burn body version ${version30} (expected ${CCTP_V2_BURN_BODY_VERSION})`);
   }
   const burnTokenPadded = sliceHex(bytes, BODY_OFF_BURN_TOKEN, BODY_OFF_MINT_RECIPIENT);
   const mintRecipientPadded = sliceHex(bytes, BODY_OFF_MINT_RECIPIENT, BODY_OFF_AMOUNT);
   const messageSenderPadded = sliceHex(bytes, BODY_OFF_MESSAGE_SENDER, BODY_OFF_MAX_FEE);
   return Object.freeze({
-    version: version29,
+    version: version30,
     burnToken: getAddress(`0x${burnTokenPadded.slice(2 + 24)}`),
     mintRecipient: getAddress(`0x${mintRecipientPadded.slice(2 + 24)}`),
     amount: hexToBigInt(sliceHex(bytes, BODY_OFF_AMOUNT, BODY_OFF_MESSAGE_SENDER)),
@@ -96541,7 +97299,7 @@ __export(exports_external, {
 // node_modules/zod/v4/core/index.js
 var exports_core2 = {};
 __export(exports_core2, {
-  version: () => version29,
+  version: () => version30,
   util: () => exports_util2,
   treeifyError: () => treeifyError,
   toJSONSchema: () => toJSONSchema,
@@ -97861,10 +98619,10 @@ var nanoid = /^[a-zA-Z0-9_-]{21}$/;
 var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
 var extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
 var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
-var uuid = (version29) => {
-  if (!version29)
+var uuid = (version30) => {
+  if (!version30)
     return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
-  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version29}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version30}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
 };
 var uuid4 = /* @__PURE__ */ uuid(4);
 var uuid6 = /* @__PURE__ */ uuid(6);
@@ -98533,7 +99291,7 @@ class Doc {
 }
 
 // node_modules/zod/v4/core/versions.js
-var version29 = {
+var version30 = {
   major: 4,
   minor: 3,
   patch: 6
@@ -98545,7 +99303,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
   inst ?? (inst = {});
   inst._zod.def = def;
   inst._zod.bag = inst._zod.bag || {};
-  inst._zod.version = version29;
+  inst._zod.version = version30;
   const checks = [...inst._zod.def.checks ?? []];
   if (inst._zod.traits.has("$ZodCheck")) {
     checks.unshift(inst);
@@ -109790,10 +110548,10 @@ function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
     return schema ? z.any() : z.never();
   }
-  const version30 = detectVersion(schema, params?.defaultTarget);
+  const version31 = detectVersion(schema, params?.defaultTarget);
   const defs = schema.$defs || schema.definitions || {};
   const ctx = {
-    version: version30,
+    version: version31,
     defs,
     refs: new Map,
     processing: new Set,
@@ -111546,4 +112304,4 @@ var simulateOrThrow = async (env2) => {
   };
 };
 
-//# debugId=2606A99C24F749A164756E2164756E21
+//# debugId=CE4226A0C7169A0764756E2164756E21