@zoralabs/protocol-deployments 0.1.10 → 0.1.11

package/dist/index.cjs

@@ -3,6 +3,9 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,13 +20,1585 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/abitype/dist/esm/regex.js
+function execTyped(regex, string) {
+  const match = regex.exec(string);
+  return match?.groups;
+}
+var init_regex = __esm({
+  "../../node_modules/abitype/dist/esm/regex.js"() {
+    "use strict";
+  }
+});
+
+// ../../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({
+  "../../node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
+    "use strict";
+    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({
+  "../../node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
+    "use strict";
+    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)})` : ""}`;
+  else if (abiItem.type === "event")
+    return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
+  else if (abiItem.type === "error")
+    return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
+  else if (abiItem.type === "constructor")
+    return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
+  else if (abiItem.type === "fallback")
+    return "fallback()";
+  return "receive() external payable";
+}
+var init_formatAbiItem = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
+    "use strict";
+    init_formatAbiParameters();
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/exports/index.js
+var init_exports = __esm({
+  "../../node_modules/abitype/dist/esm/exports/index.js"() {
+    "use strict";
+    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({
+  "node_modules/viem/_esm/utils/abi/formatAbiItem.js"() {
+    "use strict";
+    init_abi();
+  }
+});
+
+// node_modules/viem/_esm/utils/data/isHex.js
+function isHex(value, { strict = true } = {}) {
+  if (!value)
+    return false;
+  if (typeof value !== "string")
+    return false;
+  return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
+}
+var init_isHex = __esm({
+  "node_modules/viem/_esm/utils/data/isHex.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/viem/_esm/utils/data/size.js
+function size(value) {
+  if (isHex(value, { strict: false }))
+    return Math.ceil((value.length - 2) / 2);
+  return value.length;
+}
+var init_size = __esm({
+  "node_modules/viem/_esm/utils/data/size.js"() {
+    "use strict";
+    init_isHex();
+  }
+});
+
+// node_modules/viem/_esm/errors/version.js
+var version;
+var init_version = __esm({
+  "node_modules/viem/_esm/errors/version.js"() {
+    "use strict";
+    version = "2.9.18";
+  }
+});
+
+// node_modules/viem/_esm/errors/utils.js
+var getVersion;
+var init_utils = __esm({
+  "node_modules/viem/_esm/errors/utils.js"() {
+    "use strict";
+    init_version();
+    getVersion = () => `viem@${version}`;
+  }
+});
+
+// node_modules/viem/_esm/errors/base.js
+function walk(err, fn) {
+  if (fn?.(err))
+    return err;
+  if (err && typeof err === "object" && "cause" in err)
+    return walk(err.cause, fn);
+  return fn ? null : err;
+}
+var BaseError;
+var init_base = __esm({
+  "node_modules/viem/_esm/errors/base.js"() {
+    "use strict";
+    init_utils();
+    BaseError = class _BaseError extends Error {
+      constructor(shortMessage, args = {}) {
+        super();
+        Object.defineProperty(this, "details", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "docsPath", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "metaMessages", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "shortMessage", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "ViemError"
+        });
+        Object.defineProperty(this, "version", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: getVersion()
+        });
+        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;
+        this.message = [
+          shortMessage || "An error occurred.",
+          "",
+          ...args.metaMessages ? [...args.metaMessages, ""] : [],
+          ...docsPath ? [
+            `Docs: https://viem.sh${docsPath}${args.docsSlug ? `#${args.docsSlug}` : ""}`
+          ] : [],
+          ...details ? [`Details: ${details}`] : [],
+          `Version: ${this.version}`
+        ].join("\n");
+        if (args.cause)
+          this.cause = args.cause;
+        this.details = details;
+        this.docsPath = docsPath;
+        this.metaMessages = args.metaMessages;
+        this.shortMessage = shortMessage;
+      }
+      walk(fn) {
+        return walk(this, fn);
+      }
+    };
+  }
+});
+
+// node_modules/viem/_esm/errors/abi.js
+var AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiItemAmbiguityError, InvalidAbiEncodingTypeError, InvalidArrayError, InvalidDefinitionTypeError;
+var init_abi = __esm({
+  "node_modules/viem/_esm/errors/abi.js"() {
+    "use strict";
+    init_formatAbiItem2();
+    init_size();
+    init_base();
+    AbiEncodingArrayLengthMismatchError = class extends BaseError {
+      constructor({ expectedLength, givenLength, type }) {
+        super([
+          `ABI encoding array length mismatch for type ${type}.`,
+          `Expected length: ${expectedLength}`,
+          `Given length: ${givenLength}`
+        ].join("\n"));
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "AbiEncodingArrayLengthMismatchError"
+        });
+      }
+    };
+    AbiEncodingBytesSizeMismatchError = class extends BaseError {
+      constructor({ expectedSize, value }) {
+        super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`);
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "AbiEncodingBytesSizeMismatchError"
+        });
+      }
+    };
+    AbiEncodingLengthMismatchError = class extends BaseError {
+      constructor({ expectedLength, givenLength }) {
+        super([
+          "ABI encoding params/values length mismatch.",
+          `Expected length (params): ${expectedLength}`,
+          `Given length (values): ${givenLength}`
+        ].join("\n"));
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "AbiEncodingLengthMismatchError"
+        });
+      }
+    };
+    AbiItemAmbiguityError = class 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."
+          ]
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "AbiItemAmbiguityError"
+        });
+      }
+    };
+    InvalidAbiEncodingTypeError = class extends BaseError {
+      constructor(type, { docsPath }) {
+        super([
+          `Type "${type}" is not a valid encoding type.`,
+          "Please provide a valid ABI type."
+        ].join("\n"), { docsPath });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "InvalidAbiEncodingType"
+        });
+      }
+    };
+    InvalidArrayError = class extends BaseError {
+      constructor(value) {
+        super([`Value "${value}" is not a valid array.`].join("\n"));
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "InvalidArrayError"
+        });
+      }
+    };
+    InvalidDefinitionTypeError = class extends BaseError {
+      constructor(type) {
+        super([
+          `"${type}" is not a valid definition type.`,
+          'Valid types: "function", "event", "error"'
+        ].join("\n"));
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "InvalidDefinitionTypeError"
+        });
+      }
+    };
+  }
+});
+
+// node_modules/viem/_esm/errors/data.js
+var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
+var init_data = __esm({
+  "node_modules/viem/_esm/errors/data.js"() {
+    "use strict";
+    init_base();
+    SliceOffsetOutOfBoundsError = class extends BaseError {
+      constructor({ offset, position, size: size2 }) {
+        super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size2}).`);
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "SliceOffsetOutOfBoundsError"
+        });
+      }
+    };
+    SizeExceedsPaddingSizeError = class extends BaseError {
+      constructor({ size: size2, targetSize, type }) {
+        super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`);
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "SizeExceedsPaddingSizeError"
+        });
+      }
+    };
+  }
+});
+
+// node_modules/viem/_esm/utils/data/pad.js
+function pad(hexOrBytes, { dir, size: size2 = 32 } = {}) {
+  if (typeof hexOrBytes === "string")
+    return padHex(hexOrBytes, { dir, size: size2 });
+  return padBytes(hexOrBytes, { dir, size: size2 });
+}
+function padHex(hex_, { dir, size: size2 = 32 } = {}) {
+  if (size2 === null)
+    return hex_;
+  const hex = hex_.replace("0x", "");
+  if (hex.length > size2 * 2)
+    throw new SizeExceedsPaddingSizeError({
+      size: Math.ceil(hex.length / 2),
+      targetSize: size2,
+      type: "hex"
+    });
+  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size2 * 2, "0")}`;
+}
+function padBytes(bytes2, { dir, size: size2 = 32 } = {}) {
+  if (size2 === null)
+    return bytes2;
+  if (bytes2.length > size2)
+    throw new SizeExceedsPaddingSizeError({
+      size: bytes2.length,
+      targetSize: size2,
+      type: "bytes"
+    });
+  const paddedBytes = new Uint8Array(size2);
+  for (let i = 0; i < size2; i++) {
+    const padEnd = dir === "right";
+    paddedBytes[padEnd ? i : size2 - i - 1] = bytes2[padEnd ? i : bytes2.length - i - 1];
+  }
+  return paddedBytes;
+}
+var init_pad = __esm({
+  "node_modules/viem/_esm/utils/data/pad.js"() {
+    "use strict";
+    init_data();
+  }
+});
+
+// node_modules/viem/_esm/errors/encoding.js
+var IntegerOutOfRangeError, SizeOverflowError;
+var init_encoding = __esm({
+  "node_modules/viem/_esm/errors/encoding.js"() {
+    "use strict";
+    init_base();
+    IntegerOutOfRangeError = class extends BaseError {
+      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})`}`);
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "IntegerOutOfRangeError"
+        });
+      }
+    };
+    SizeOverflowError = class extends BaseError {
+      constructor({ givenSize, maxSize }) {
+        super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`);
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "SizeOverflowError"
+        });
+      }
+    };
+  }
+});
+
+// node_modules/viem/_esm/utils/encoding/fromHex.js
+function assertSize(hexOrBytes, { size: size2 }) {
+  if (size(hexOrBytes) > size2)
+    throw new SizeOverflowError({
+      givenSize: size(hexOrBytes),
+      maxSize: size2
+    });
+}
+var init_fromHex = __esm({
+  "node_modules/viem/_esm/utils/encoding/fromHex.js"() {
+    "use strict";
+    init_encoding();
+    init_size();
+  }
+});
+
+// node_modules/viem/_esm/utils/encoding/toHex.js
+function toHex(value, opts = {}) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToHex(value, opts);
+  if (typeof value === "string") {
+    return stringToHex(value, opts);
+  }
+  if (typeof value === "boolean")
+    return boolToHex(value, opts);
+  return bytesToHex(value, opts);
+}
+function boolToHex(value, opts = {}) {
+  const hex = `0x${Number(value)}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { size: opts.size });
+  }
+  return hex;
+}
+function bytesToHex(value, opts = {}) {
+  let string = "";
+  for (let i = 0; i < value.length; i++) {
+    string += hexes[value[i]];
+  }
+  const hex = `0x${string}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { dir: "right", size: opts.size });
+  }
+  return hex;
+}
+function numberToHex(value_, opts = {}) {
+  const { signed, size: size2 } = opts;
+  const value = BigInt(value_);
+  let maxValue;
+  if (size2) {
+    if (signed)
+      maxValue = (1n << BigInt(size2) * 8n - 1n) - 1n;
+    else
+      maxValue = 2n ** (BigInt(size2) * 8n) - 1n;
+  } else if (typeof value_ === "number") {
+    maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+  }
+  const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
+  if (maxValue && value > maxValue || value < minValue) {
+    const suffix = typeof value_ === "bigint" ? "n" : "";
+    throw new IntegerOutOfRangeError({
+      max: maxValue ? `${maxValue}${suffix}` : void 0,
+      min: `${minValue}${suffix}`,
+      signed,
+      size: size2,
+      value: `${value_}${suffix}`
+    });
+  }
+  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size2 * 8)) + BigInt(value) : value).toString(16)}`;
+  if (size2)
+    return pad(hex, { size: size2 });
+  return hex;
+}
+function stringToHex(value_, opts = {}) {
+  const value = encoder.encode(value_);
+  return bytesToHex(value, opts);
+}
+var hexes, encoder;
+var init_toHex = __esm({
+  "node_modules/viem/_esm/utils/encoding/toHex.js"() {
+    "use strict";
+    init_encoding();
+    init_pad();
+    init_fromHex();
+    hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+    encoder = /* @__PURE__ */ new TextEncoder();
+  }
+});
+
+// node_modules/viem/_esm/utils/encoding/toBytes.js
+function toBytes(value, opts = {}) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToBytes(value, opts);
+  if (typeof value === "boolean")
+    return boolToBytes(value, opts);
+  if (isHex(value))
+    return hexToBytes(value, opts);
+  return stringToBytes(value, opts);
+}
+function boolToBytes(value, opts = {}) {
+  const bytes2 = new Uint8Array(1);
+  bytes2[0] = Number(value);
+  if (typeof opts.size === "number") {
+    assertSize(bytes2, { size: opts.size });
+    return pad(bytes2, { size: opts.size });
+  }
+  return bytes2;
+}
+function charCodeToBase16(char) {
+  if (char >= charCodeMap.zero && char <= charCodeMap.nine)
+    return char - charCodeMap.zero;
+  if (char >= charCodeMap.A && char <= charCodeMap.F)
+    return char - (charCodeMap.A - 10);
+  if (char >= charCodeMap.a && char <= charCodeMap.f)
+    return char - (charCodeMap.a - 10);
+  return void 0;
+}
+function hexToBytes(hex_, opts = {}) {
+  let hex = hex_;
+  if (opts.size) {
+    assertSize(hex, { size: opts.size });
+    hex = pad(hex, { dir: "right", size: opts.size });
+  }
+  let hexString = hex.slice(2);
+  if (hexString.length % 2)
+    hexString = `0${hexString}`;
+  const length = hexString.length / 2;
+  const bytes2 = new Uint8Array(length);
+  for (let index = 0, j = 0; index < length; index++) {
+    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
+    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+    if (nibbleLeft === void 0 || nibbleRight === void 0) {
+      throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+    }
+    bytes2[index] = nibbleLeft * 16 + nibbleRight;
+  }
+  return bytes2;
+}
+function numberToBytes(value, opts) {
+  const hex = numberToHex(value, opts);
+  return hexToBytes(hex);
+}
+function stringToBytes(value, opts = {}) {
+  const bytes2 = encoder2.encode(value);
+  if (typeof opts.size === "number") {
+    assertSize(bytes2, { size: opts.size });
+    return pad(bytes2, { dir: "right", size: opts.size });
+  }
+  return bytes2;
+}
+var encoder2, charCodeMap;
+var init_toBytes = __esm({
+  "node_modules/viem/_esm/utils/encoding/toBytes.js"() {
+    "use strict";
+    init_base();
+    init_isHex();
+    init_pad();
+    init_fromHex();
+    init_toHex();
+    encoder2 = /* @__PURE__ */ new TextEncoder();
+    charCodeMap = {
+      zero: 48,
+      nine: 57,
+      A: 65,
+      F: 70,
+      a: 97,
+      f: 102
+    };
+  }
+});
+
+// ../../node_modules/@noble/hashes/esm/_assert.js
+function number(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error(`Wrong positive integer: ${n}`);
+}
+function bytes(b, ...lengths) {
+  if (!(b instanceof Uint8Array))
+    throw new Error("Expected Uint8Array");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+}
+function exists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function output(out, instance) {
+  bytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+  }
+}
+var init_assert = __esm({
+  "../../node_modules/@noble/hashes/esm/_assert.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/@noble/hashes/esm/_u64.js
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  let Ah = new Uint32Array(lst.length);
+  let Al = new Uint32Array(lst.length);
+  for (let i = 0; i < lst.length; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
+var init_u64 = __esm({
+  "../../node_modules/@noble/hashes/esm/_u64.js"() {
+    "use strict";
+    U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+    _32n = /* @__PURE__ */ BigInt(32);
+    rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+    rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+    rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+    rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+  }
+});
+
+// ../../node_modules/@noble/hashes/esm/utils.js
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes2(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  if (!u8a(data))
+    throw new Error(`expected Uint8Array, got ${typeof data}`);
+  return data;
+}
+function wrapConstructor(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+function wrapXOFConstructorWithOpts(hashCons) {
+  const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
+  const tmp = hashCons({});
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  return hashC;
+}
+var u8a, u32, isLE, Hash, toStr;
+var init_utils2 = __esm({
+  "../../node_modules/@noble/hashes/esm/utils.js"() {
+    "use strict";
+    u8a = (a) => a instanceof Uint8Array;
+    u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+    isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+    if (!isLE)
+      throw new Error("Non little-endian hardware is not supported");
+    Hash = class {
+      // Safe version that clones internal state
+      clone() {
+        return this._cloneInto();
+      }
+    };
+    toStr = {}.toString;
+  }
+});
+
+// ../../node_modules/@noble/hashes/esm/sha3.js
+function keccakP(s, rounds = 24) {
+  const B = new Uint32Array(5 * 2);
+  for (let round = 24 - rounds; round < 24; round++) {
+    for (let x = 0; x < 10; x++)
+      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0; x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0; y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0; t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0; y < 50; y += 10) {
+      for (let x = 0; x < 10; x++)
+        B[x] = s[y + x];
+      for (let x = 0; x < 10; x++)
+        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
+  }
+  B.fill(0);
+}
+var SHA3_PI, SHA3_ROTL, _SHA3_IOTA, _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake, shake128, shake256;
+var init_sha3 = __esm({
+  "../../node_modules/@noble/hashes/esm/sha3.js"() {
+    "use strict";
+    init_assert();
+    init_u64();
+    init_utils2();
+    [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];
+    _0n = /* @__PURE__ */ BigInt(0);
+    _1n = /* @__PURE__ */ BigInt(1);
+    _2n = /* @__PURE__ */ BigInt(2);
+    _7n = /* @__PURE__ */ BigInt(7);
+    _256n = /* @__PURE__ */ BigInt(256);
+    _0x71n = /* @__PURE__ */ BigInt(113);
+    for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+      [x, y] = [y, (2 * x + 3 * y) % 5];
+      SHA3_PI.push(2 * (5 * y + x));
+      SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+      let t = _0n;
+      for (let j = 0; j < 7; j++) {
+        R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+        if (R & _2n)
+          t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+      }
+      _SHA3_IOTA.push(t);
+    }
+    [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
+    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 = class _Keccak extends Hash {
+      // NOTE: we accept arguments in bytes instead of bits here.
+      constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+        super();
+        this.blockLen = blockLen;
+        this.suffix = suffix;
+        this.outputLen = outputLen;
+        this.enableXOF = enableXOF;
+        this.rounds = rounds;
+        this.pos = 0;
+        this.posOut = 0;
+        this.finished = false;
+        this.destroyed = false;
+        number(outputLen);
+        if (0 >= this.blockLen || this.blockLen >= 200)
+          throw new Error("Sha3 supports only keccak-f1600 function");
+        this.state = new Uint8Array(200);
+        this.state32 = u32(this.state);
+      }
+      keccak() {
+        keccakP(this.state32, this.rounds);
+        this.posOut = 0;
+        this.pos = 0;
+      }
+      update(data) {
+        exists(this);
+        const { blockLen, state } = this;
+        data = toBytes2(data);
+        const len = data.length;
+        for (let pos = 0; pos < len; ) {
+          const take = Math.min(blockLen - this.pos, len - pos);
+          for (let i = 0; i < take; i++)
+            state[this.pos++] ^= data[pos++];
+          if (this.pos === blockLen)
+            this.keccak();
+        }
+        return this;
+      }
+      finish() {
+        if (this.finished)
+          return;
+        this.finished = true;
+        const { state, suffix, pos, blockLen } = this;
+        state[pos] ^= suffix;
+        if ((suffix & 128) !== 0 && pos === blockLen - 1)
+          this.keccak();
+        state[blockLen - 1] ^= 128;
+        this.keccak();
+      }
+      writeInto(out) {
+        exists(this, false);
+        bytes(out);
+        this.finish();
+        const bufferOut = this.state;
+        const { blockLen } = this;
+        for (let pos = 0, len = out.length; pos < len; ) {
+          if (this.posOut >= blockLen)
+            this.keccak();
+          const take = Math.min(blockLen - this.posOut, len - pos);
+          out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+          this.posOut += take;
+          pos += take;
+        }
+        return out;
+      }
+      xofInto(out) {
+        if (!this.enableXOF)
+          throw new Error("XOF is not possible for this instance");
+        return this.writeInto(out);
+      }
+      xof(bytes2) {
+        number(bytes2);
+        return this.xofInto(new Uint8Array(bytes2));
+      }
+      digestInto(out) {
+        output(out, this);
+        if (this.finished)
+          throw new Error("digest() was already called");
+        this.writeInto(out);
+        this.destroy();
+        return out;
+      }
+      digest() {
+        return this.digestInto(new Uint8Array(this.outputLen));
+      }
+      destroy() {
+        this.destroyed = true;
+        this.state.fill(0);
+      }
+      _cloneInto(to) {
+        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+        to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+        to.state32.set(this.state32);
+        to.pos = this.pos;
+        to.posOut = this.posOut;
+        to.finished = this.finished;
+        to.rounds = rounds;
+        to.suffix = suffix;
+        to.outputLen = outputLen;
+        to.enableXOF = enableXOF;
+        to.destroyed = this.destroyed;
+        return to;
+      }
+    };
+    gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
+    sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
+    sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
+    sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
+    sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
+    keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
+    keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
+    keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
+    keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
+    genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
+    shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
+    shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
+  }
+});
+
+// node_modules/viem/_esm/utils/hash/keccak256.js
+function keccak256(value, to_) {
+  const to = to_ || "hex";
+  const bytes2 = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
+  if (to === "bytes")
+    return bytes2;
+  return toHex(bytes2);
+}
+var init_keccak256 = __esm({
+  "node_modules/viem/_esm/utils/hash/keccak256.js"() {
+    "use strict";
+    init_sha3();
+    init_isHex();
+    init_toBytes();
+    init_toHex();
+  }
+});
+
+// node_modules/viem/_esm/utils/hash/hashSignature.js
+function hashSignature(sig) {
+  return hash(sig);
+}
+var hash;
+var init_hashSignature = __esm({
+  "node_modules/viem/_esm/utils/hash/hashSignature.js"() {
+    "use strict";
+    init_toBytes();
+    init_keccak256();
+    hash = (value) => keccak256(toBytes(value));
+  }
+});
+
+// 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({
+  "node_modules/viem/_esm/utils/hash/normalizeSignature.js"() {
+    "use strict";
+    init_base();
+  }
+});
+
+// node_modules/viem/_esm/utils/hash/toSignature.js
+var toSignature;
+var init_toSignature = __esm({
+  "node_modules/viem/_esm/utils/hash/toSignature.js"() {
+    "use strict";
+    init_exports();
+    init_normalizeSignature();
+    toSignature = (def) => {
+      const def_ = (() => {
+        if (typeof def === "string")
+          return def;
+        return formatAbiItem(def);
+      })();
+      return normalizeSignature(def_);
+    };
+  }
+});
+
+// node_modules/viem/_esm/utils/hash/toSignatureHash.js
+function toSignatureHash(fn) {
+  return hashSignature(toSignature(fn));
+}
+var init_toSignatureHash = __esm({
+  "node_modules/viem/_esm/utils/hash/toSignatureHash.js"() {
+    "use strict";
+    init_hashSignature();
+    init_toSignature();
+  }
+});
+
+// node_modules/viem/_esm/utils/hash/toEventSelector.js
+var toEventSelector;
+var init_toEventSelector = __esm({
+  "node_modules/viem/_esm/utils/hash/toEventSelector.js"() {
+    "use strict";
+    init_toSignatureHash();
+    toEventSelector = toSignatureHash;
+  }
+});
+
+// node_modules/viem/_esm/errors/address.js
+var InvalidAddressError;
+var init_address = __esm({
+  "node_modules/viem/_esm/errors/address.js"() {
+    "use strict";
+    init_base();
+    InvalidAddressError = class extends BaseError {
+      constructor({ address }) {
+        super(`Address "${address}" is invalid.`, {
+          metaMessages: [
+            "- Address must be a hex value of 20 bytes (40 hex characters).",
+            "- Address must match its checksum counterpart."
+          ]
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "InvalidAddressError"
+        });
+      }
+    };
+  }
+});
+
+// node_modules/viem/_esm/utils/lru.js
+var LruMap;
+var init_lru = __esm({
+  "node_modules/viem/_esm/utils/lru.js"() {
+    "use strict";
+    LruMap = class extends Map {
+      constructor(size2) {
+        super();
+        Object.defineProperty(this, "maxSize", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        this.maxSize = size2;
+      }
+      set(key, value) {
+        super.set(key, value);
+        if (this.maxSize && this.size > this.maxSize)
+          this.delete(this.keys().next().value);
+        return this;
+      }
+    };
+  }
+});
+
+// node_modules/viem/_esm/utils/address/getAddress.js
+function checksumAddress(address_, chainId) {
+  const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
+  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 (hash2[i >> 1] >> 4 >= 8 && address[i]) {
+      address[i] = address[i].toUpperCase();
+    }
+    if ((hash2[i >> 1] & 15) >= 8 && address[i + 1]) {
+      address[i + 1] = address[i + 1].toUpperCase();
+    }
+  }
+  return `0x${address.join("")}`;
+}
+var init_getAddress = __esm({
+  "node_modules/viem/_esm/utils/address/getAddress.js"() {
+    "use strict";
+    init_toBytes();
+    init_keccak256();
+  }
+});
+
+// node_modules/viem/_esm/utils/address/isAddress.js
+function isAddress(address, options) {
+  const { strict = true } = options ?? {};
+  if (isAddressCache.has(address))
+    return isAddressCache.get(address);
+  const result = (() => {
+    if (!addressRegex.test(address))
+      return false;
+    if (address.toLowerCase() === address)
+      return true;
+    if (strict)
+      return checksumAddress(address) === address;
+    return true;
+  })();
+  isAddressCache.set(address, result);
+  return result;
+}
+var addressRegex, isAddressCache;
+var init_isAddress = __esm({
+  "node_modules/viem/_esm/utils/address/isAddress.js"() {
+    "use strict";
+    init_lru();
+    init_getAddress();
+    addressRegex = /^0x[a-fA-F0-9]{40}$/;
+    isAddressCache = /* @__PURE__ */ new LruMap(8192);
+  }
+});
+
+// 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", ""), "")}`;
+}
+var init_concat = __esm({
+  "node_modules/viem/_esm/utils/data/concat.js"() {
+    "use strict";
+  }
+});
+
+// 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({
+      offset: start,
+      position: "start",
+      size: size(value)
+    });
+}
+function assertEndOffset(value, start, end) {
+  if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
+    throw new SliceOffsetOutOfBoundsError({
+      offset: end,
+      position: "end",
+      size: size(value)
+    });
+  }
+}
+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)}`;
+  if (strict)
+    assertEndOffset(value, start, end);
+  return value;
+}
+var init_slice = __esm({
+  "node_modules/viem/_esm/utils/data/slice.js"() {
+    "use strict";
+    init_data();
+    init_isHex();
+    init_size();
+  }
+});
+
+// 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");
+    return encodeNumber(value, { signed });
+  }
+  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 !== parseInt(paramSize))
+    throw new AbiEncodingBytesSizeMismatchError({
+      expectedSize: 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 }) {
+  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 ? (
+    // Return `null` if the array is dynamic.
+    [matches[2] ? Number(matches[2]) : null, matches[1]]
+  ) : void 0;
+}
+var init_encodeAbiParameters = __esm({
+  "node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
+    "use strict";
+    init_abi();
+    init_address();
+    init_base();
+    init_isAddress();
+    init_concat();
+    init_pad();
+    init_size();
+    init_slice();
+    init_toHex();
+  }
+});
+
+// node_modules/viem/_esm/utils/hash/toFunctionSelector.js
+var toFunctionSelector;
+var init_toFunctionSelector = __esm({
+  "node_modules/viem/_esm/utils/hash/toFunctionSelector.js"() {
+    "use strict";
+    init_slice();
+    init_toSignatureHash();
+    toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
+  }
+});
+
+// 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 void 0;
+  if (abiItems.length === 1)
+    return abiItems[0];
+  let matchedAbiItem = void 0;
+  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,
+          // Pop off `[]` or `[M]` from end of type
+          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({
+  "node_modules/viem/_esm/utils/abi/getAbiItem.js"() {
+    "use strict";
+    init_abi();
+    init_isHex();
+    init_isAddress();
+    init_toEventSelector();
+    init_toFunctionSelector();
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  PremintConfigVersion: () => PremintConfigVersion,
   contracts1155: () => __exports,
+  encodePremintConfig: () => encodePremintConfig,
   erc20MinterABI: () => erc20MinterABI,
   erc20MinterAddress: () => erc20MinterAddress,
   erc20MinterConfig: () => erc20MinterConfig,
+  iPremintDefinitionsABI: () => iPremintDefinitionsABI,
   iUnwrapAndForwardActionABI: () => iUnwrapAndForwardActionABI,
   mints: () => mints_exports,
   mintsEthUnwrapperAndCallerABI: () => mintsEthUnwrapperAndCallerABI,
@@ -31,6 +1606,7 @@ __export(src_exports, {
   mintsEthUnwrapperAndCallerConfig: () => mintsEthUnwrapperAndCallerConfig,
   mintsSafeTransferBatchTypedDataDefinition: () => mintsSafeTransferBatchTypedDataDefinition,
   mintsSafeTransferTypedDataDefinition: () => mintsSafeTransferTypedDataDefinition,
+  premintTypedDataDefinition: () => premintTypedDataDefinition,
   premintV1TypedDataDefinition: () => premintV1TypedDataDefinition,
   premintV2TypedDataDefinition: () => premintV2TypedDataDefinition,
   protocolRewardsABI: () => protocolRewardsABI,
@@ -70,6 +1646,48 @@ var erc20MinterABI = [
     name: "acceptOwnership",
     outputs: []
   },
+  {
+    stateMutability: "view",
+    type: "function",
+    inputs: [
+      {
+        name: "config",
+        internalType: "struct IERC20Minter.PremintSalesConfig",
+        type: "tuple",
+        components: [
+          { name: "duration", internalType: "uint64", type: "uint64" },
+          {
+            name: "maxTokensPerAddress",
+            internalType: "uint64",
+            type: "uint64"
+          },
+          { name: "pricePerToken", internalType: "uint256", type: "uint256" },
+          { name: "fundsRecipient", internalType: "address", type: "address" },
+          { name: "currency", internalType: "address", type: "address" }
+        ]
+      }
+    ],
+    name: "buildSalesConfigForPremint",
+    outputs: [
+      {
+        name: "",
+        internalType: "struct IERC20Minter.SalesConfig",
+        type: "tuple",
+        components: [
+          { name: "saleStart", internalType: "uint64", type: "uint64" },
+          { name: "saleEnd", internalType: "uint64", type: "uint64" },
+          {
+            name: "maxTokensPerAddress",
+            internalType: "uint64",
+            type: "uint64"
+          },
+          { name: "pricePerToken", internalType: "uint256", type: "uint256" },
+          { name: "fundsRecipient", internalType: "address", type: "address" },
+          { name: "currency", internalType: "address", type: "address" }
+        ]
+      }
+    ]
+  },
   {
     stateMutability: "nonpayable",
     type: "function",
@@ -223,7 +1841,7 @@ var erc20MinterABI = [
         internalType: "address",
         type: "address"
       },
-      { name: "owner", internalType: "address", type: "address" },
+      { name: "_owner", internalType: "address", type: "address" },
       { name: "_rewardPct", internalType: "uint256", type: "uint256" },
       { name: "_ethReward", internalType: "uint256", type: "uint256" }
     ],
@@ -389,6 +2007,20 @@ var erc20MinterABI = [
     name: "setERC20MinterConfig",
     outputs: []
   },
+  {
+    stateMutability: "nonpayable",
+    type: "function",
+    inputs: [
+      { name: "tokenId", internalType: "uint256", type: "uint256" },
+      {
+        name: "encodedPremintSalesConfig",
+        internalType: "bytes",
+        type: "bytes"
+      }
+    ],
+    name: "setPremintSale",
+    outputs: []
+  },
   {
     stateMutability: "nonpayable",
     type: "function",
@@ -688,6 +2320,14 @@ var erc20MinterABI = [
     name: "INITIALIZABLE_CONTRACT_IS_NOT_INITIALIZING"
   },
   { type: "error", inputs: [], name: "InvalidCurrency" },
+  {
+    type: "error",
+    inputs: [
+      { name: "expectedValue", internalType: "uint256", type: "uint256" },
+      { name: "actualValue", internalType: "uint256", type: "uint256" }
+    ],
+    name: "InvalidETHValue"
+  },
   { type: "error", inputs: [], name: "InvalidValue" },
   { type: "error", inputs: [], name: "ONLY_OWNER" },
   { type: "error", inputs: [], name: "ONLY_PENDING_OWNER" },
@@ -717,12 +2357,111 @@ var erc20MinterAddress = {
   421614: "0x777777E8850d8D6d98De2B5f64fae401F96eFF31",
   7777777: "0x777777E8850d8D6d98De2B5f64fae401F96eFF31",
   11155111: "0x777777E8850d8D6d98De2B5f64fae401F96eFF31",
-  999999999: "0x777777E8850d8D6d98De2B5f64fae401F96eFF31"
+  999999999: "0x8Ec7f068A77fa5FC1925110f82381374BA054Ff2"
 };
 var erc20MinterConfig = {
   address: erc20MinterAddress,
   abi: erc20MinterABI
 };
+var iPremintDefinitionsABI = [
+  {
+    stateMutability: "nonpayable",
+    type: "function",
+    inputs: [
+      {
+        name: "",
+        internalType: "struct TokenCreationConfig",
+        type: "tuple",
+        components: [
+          { name: "tokenURI", internalType: "string", type: "string" },
+          { name: "maxSupply", internalType: "uint256", type: "uint256" },
+          {
+            name: "maxTokensPerAddress",
+            internalType: "uint64",
+            type: "uint64"
+          },
+          { name: "pricePerToken", internalType: "uint96", type: "uint96" },
+          { name: "mintStart", internalType: "uint64", type: "uint64" },
+          { name: "mintDuration", internalType: "uint64", type: "uint64" },
+          {
+            name: "royaltyMintSchedule",
+            internalType: "uint32",
+            type: "uint32"
+          },
+          { name: "royaltyBPS", internalType: "uint32", type: "uint32" },
+          {
+            name: "royaltyRecipient",
+            internalType: "address",
+            type: "address"
+          },
+          {
+            name: "fixedPriceMinter",
+            internalType: "address",
+            type: "address"
+          }
+        ]
+      }
+    ],
+    name: "tokenConfigV1Definition",
+    outputs: []
+  },
+  {
+    stateMutability: "nonpayable",
+    type: "function",
+    inputs: [
+      {
+        name: "",
+        internalType: "struct TokenCreationConfigV2",
+        type: "tuple",
+        components: [
+          { name: "tokenURI", internalType: "string", type: "string" },
+          { name: "maxSupply", internalType: "uint256", type: "uint256" },
+          {
+            name: "maxTokensPerAddress",
+            internalType: "uint64",
+            type: "uint64"
+          },
+          { name: "pricePerToken", internalType: "uint96", type: "uint96" },
+          { name: "mintStart", internalType: "uint64", type: "uint64" },
+          { name: "mintDuration", internalType: "uint64", type: "uint64" },
+          { name: "royaltyBPS", internalType: "uint32", type: "uint32" },
+          { name: "payoutRecipient", internalType: "address", type: "address" },
+          {
+            name: "fixedPriceMinter",
+            internalType: "address",
+            type: "address"
+          },
+          { name: "createReferral", internalType: "address", type: "address" }
+        ]
+      }
+    ],
+    name: "tokenConfigV2Definition",
+    outputs: []
+  },
+  {
+    stateMutability: "nonpayable",
+    type: "function",
+    inputs: [
+      {
+        name: "",
+        internalType: "struct TokenCreationConfigV3",
+        type: "tuple",
+        components: [
+          { name: "tokenURI", internalType: "string", type: "string" },
+          { name: "maxSupply", internalType: "uint256", type: "uint256" },
+          { name: "royaltyBPS", internalType: "uint32", type: "uint32" },
+          { name: "payoutRecipient", internalType: "address", type: "address" },
+          { name: "createReferral", internalType: "address", type: "address" },
+          { name: "mintStart", internalType: "uint64", type: "uint64" },
+          { name: "minter", internalType: "address", type: "address" },
+          { name: "premintSalesConfig", internalType: "bytes", type: "bytes" }
+        ]
+      }
+    ],
+    name: "tokenConfigV3Definition",
+    outputs: []
+  }
+];
 var iUnwrapAndForwardActionABI = [
   {
     stateMutability: "payable",
@@ -824,6 +2563,7 @@ var mintsEthUnwrapperAndCallerABI = [
   { type: "error", inputs: [], name: "UnknownUserAction" }
 ];
 var mintsEthUnwrapperAndCallerAddress = {
+  84532: "0xb0994EB9520C98C97e1F3953a5964535C2bd271A",
   7777777: "0xb0994EB9520C98C97e1F3953a5964535C2bd271A",
   999999999: "0xb0994EB9520C98C97e1F3953a5964535C2bd271A"
 };
@@ -1254,6 +2994,19 @@ var zoraCreator1155FactoryImplABI = [
     name: "deterministicContractAddress",
     outputs: [{ name: "", internalType: "address", type: "address" }]
   },
+  {
+    stateMutability: "view",
+    type: "function",
+    inputs: [
+      { name: "msgSender", internalType: "address", type: "address" },
+      { name: "newContractURI", internalType: "string", type: "string" },
+      { name: "name", internalType: "string", type: "string" },
+      { name: "contractAdmin", internalType: "address", type: "address" },
+      { name: "setupActions", internalType: "bytes[]", type: "bytes[]" }
+    ],
+    name: "deterministicContractAddressWithSetupActions",
+    outputs: [{ name: "", internalType: "address", type: "address" }]
+  },
   {
     stateMutability: "view",
     type: "function",
@@ -1579,7 +3332,7 @@ var zoraCreator1155FactoryImplAddress = {
   8453: "0x777777C338d93e2C7adf08D102d45CA7CC4Ed021",
   42161: "0x777777C338d93e2C7adf08D102d45CA7CC4Ed021",
   81457: "0x777777C338d93e2C7adf08D102d45CA7CC4Ed021",
-  84532: "0x8cfbF874A12b346115003532119C29f6B56719CB",
+  84532: "0x777777C338d93e2C7adf08D102d45CA7CC4Ed021",
   421614: "0x777777C338d93e2C7adf08D102d45CA7CC4Ed021",
   7777777: "0x777777C338d93e2C7adf08D102d45CA7CC4Ed021",
   11155111: "0x777777C338d93e2C7adf08D102d45CA7CC4Ed021",
@@ -3010,6 +4763,13 @@ var zoraCreator1155PremintExecutorImplABI = [
     name: "contractName",
     outputs: [{ name: "", internalType: "string", type: "string" }]
   },
+  {
+    stateMutability: "pure",
+    type: "function",
+    inputs: [],
+    name: "contractVersion",
+    outputs: [{ name: "", internalType: "string", type: "string" }]
+  },
   {
     stateMutability: "view",
     type: "function",
@@ -3028,6 +4788,29 @@ var zoraCreator1155PremintExecutorImplABI = [
     name: "getContractAddress",
     outputs: [{ name: "", internalType: "address", type: "address" }]
   },
+  {
+    stateMutability: "view",
+    type: "function",
+    inputs: [
+      {
+        name: "contractConfig",
+        internalType: "struct ContractWithAdditionalAdminsCreationConfig",
+        type: "tuple",
+        components: [
+          { name: "contractAdmin", internalType: "address", type: "address" },
+          { name: "contractURI", internalType: "string", type: "string" },
+          { name: "contractName", internalType: "string", type: "string" },
+          {
+            name: "additionalAdmins",
+            internalType: "address[]",
+            type: "address[]"
+          }
+        ]
+      }
+    ],
+    name: "getContractWithAdditionalAdminsAddress",
+    outputs: [{ name: "", internalType: "address", type: "address" }]
+  },
   {
     stateMutability: "view",
     type: "function",
@@ -3059,6 +4842,26 @@ var zoraCreator1155PremintExecutorImplABI = [
     name: "isAuthorizedToCreatePremint",
     outputs: [{ name: "isAuthorized", internalType: "bool", type: "bool" }]
   },
+  {
+    stateMutability: "view",
+    type: "function",
+    inputs: [
+      { name: "signer", internalType: "address", type: "address" },
+      {
+        name: "premintContractConfigContractAdmin",
+        internalType: "address",
+        type: "address"
+      },
+      { name: "contractAddress", internalType: "address", type: "address" },
+      {
+        name: "additionalAdmins",
+        internalType: "address[]",
+        type: "address[]"
+      }
+    ],
+    name: "isAuthorizedToCreatePremintWithAdditionalAdmins",
+    outputs: [{ name: "isAuthorized", internalType: "bool", type: "bool" }]
+  },
   {
     stateMutability: "view",
     type: "function",
@@ -3149,61 +4952,39 @@ var zoraCreator1155PremintExecutorImplABI = [
     outputs: [{ name: "", internalType: "address", type: "address" }]
   },
   {
-    stateMutability: "nonpayable",
+    stateMutability: "payable",
     type: "function",
     inputs: [
       {
         name: "contractConfig",
-        internalType: "struct ContractCreationConfig",
+        internalType: "struct ContractWithAdditionalAdminsCreationConfig",
         type: "tuple",
         components: [
           { name: "contractAdmin", internalType: "address", type: "address" },
           { name: "contractURI", internalType: "string", type: "string" },
-          { name: "contractName", internalType: "string", type: "string" }
+          { name: "contractName", internalType: "string", type: "string" },
+          {
+            name: "additionalAdmins",
+            internalType: "address[]",
+            type: "address[]"
+          }
         ]
       },
+      { name: "premintCollection", internalType: "address", type: "address" },
       {
-        name: "premintConfig",
-        internalType: "struct Erc20PremintConfigV1",
+        name: "encodedPremintConfig",
+        internalType: "struct PremintConfigEncoded",
         type: "tuple",
         components: [
-          {
-            name: "tokenConfig",
-            internalType: "struct Erc20TokenCreationConfigV1",
-            type: "tuple",
-            components: [
-              { name: "tokenURI", internalType: "string", type: "string" },
-              { name: "maxSupply", internalType: "uint256", type: "uint256" },
-              { name: "royaltyBPS", internalType: "uint32", type: "uint32" },
-              {
-                name: "payoutRecipient",
-                internalType: "address",
-                type: "address"
-              },
-              {
-                name: "createReferral",
-                internalType: "address",
-                type: "address"
-              },
-              { name: "erc20Minter", internalType: "address", type: "address" },
-              { name: "mintStart", internalType: "uint64", type: "uint64" },
-              { name: "mintDuration", internalType: "uint64", type: "uint64" },
-              {
-                name: "maxTokensPerAddress",
-                internalType: "uint64",
-                type: "uint64"
-              },
-              { name: "currency", internalType: "address", type: "address" },
-              {
-                name: "pricePerToken",
-                internalType: "uint256",
-                type: "uint256"
-              }
-            ]
-          },
           { name: "uid", internalType: "uint32", type: "uint32" },
           { name: "version", internalType: "uint32", type: "uint32" },
-          { name: "deleted", internalType: "bool", type: "bool" }
+          { name: "deleted", internalType: "bool", type: "bool" },
+          { name: "tokenConfig", internalType: "bytes", type: "bytes" },
+          {
+            name: "premintConfigVersion",
+            internalType: "bytes32",
+            type: "bytes32"
+          }
         ]
       },
       { name: "signature", internalType: "bytes", type: "bytes" },
@@ -3225,10 +5006,10 @@ var zoraCreator1155PremintExecutorImplABI = [
       { name: "firstMinter", internalType: "address", type: "address" },
       { name: "signerContract", internalType: "address", type: "address" }
     ],
-    name: "premintErc20V1",
+    name: "premint",
     outputs: [
       {
-        name: "result",
+        name: "premintResult",
         internalType: "struct PremintResult",
         type: "tuple",
         components: [
@@ -3329,7 +5110,7 @@ var zoraCreator1155PremintExecutorImplABI = [
     name: "premintV1",
     outputs: [
       {
-        name: "result",
+        name: "",
         internalType: "struct PremintResult",
         type: "tuple",
         components: [
@@ -3417,97 +5198,7 @@ var zoraCreator1155PremintExecutorImplABI = [
     name: "premintV2",
     outputs: [
       {
-        name: "result",
-        internalType: "struct PremintResult",
-        type: "tuple",
-        components: [
-          { name: "contractAddress", internalType: "address", type: "address" },
-          { name: "tokenId", internalType: "uint256", type: "uint256" },
-          { name: "createdNewContract", internalType: "bool", type: "bool" }
-        ]
-      }
-    ]
-  },
-  {
-    stateMutability: "payable",
-    type: "function",
-    inputs: [
-      {
-        name: "contractConfig",
-        internalType: "struct ContractCreationConfig",
-        type: "tuple",
-        components: [
-          { name: "contractAdmin", internalType: "address", type: "address" },
-          { name: "contractURI", internalType: "string", type: "string" },
-          { name: "contractName", internalType: "string", type: "string" }
-        ]
-      },
-      {
-        name: "premintConfig",
-        internalType: "struct PremintConfigV2",
-        type: "tuple",
-        components: [
-          {
-            name: "tokenConfig",
-            internalType: "struct TokenCreationConfigV2",
-            type: "tuple",
-            components: [
-              { name: "tokenURI", internalType: "string", type: "string" },
-              { name: "maxSupply", internalType: "uint256", type: "uint256" },
-              {
-                name: "maxTokensPerAddress",
-                internalType: "uint64",
-                type: "uint64"
-              },
-              { name: "pricePerToken", internalType: "uint96", type: "uint96" },
-              { name: "mintStart", internalType: "uint64", type: "uint64" },
-              { name: "mintDuration", internalType: "uint64", type: "uint64" },
-              { name: "royaltyBPS", internalType: "uint32", type: "uint32" },
-              {
-                name: "payoutRecipient",
-                internalType: "address",
-                type: "address"
-              },
-              {
-                name: "fixedPriceMinter",
-                internalType: "address",
-                type: "address"
-              },
-              {
-                name: "createReferral",
-                internalType: "address",
-                type: "address"
-              }
-            ]
-          },
-          { name: "uid", internalType: "uint32", type: "uint32" },
-          { name: "version", internalType: "uint32", type: "uint32" },
-          { name: "deleted", internalType: "bool", type: "bool" }
-        ]
-      },
-      { name: "signature", internalType: "bytes", type: "bytes" },
-      { name: "quantityToMint", internalType: "uint256", type: "uint256" },
-      {
-        name: "mintArguments",
-        internalType: "struct MintArguments",
-        type: "tuple",
-        components: [
-          { name: "mintRecipient", internalType: "address", type: "address" },
-          { name: "mintComment", internalType: "string", type: "string" },
-          {
-            name: "mintRewardsRecipients",
-            internalType: "address[]",
-            type: "address[]"
-          }
-        ]
-      },
-      { name: "firstMinter", internalType: "address", type: "address" },
-      { name: "signerContract", internalType: "address", type: "address" }
-    ],
-    name: "premintV2WithSignerContract",
-    outputs: [
-      {
-        name: "result",
+        name: "",
         internalType: "struct PremintResult",
         type: "tuple",
         components: [
@@ -4005,6 +5696,7 @@ var zoraCreator1155PremintExecutorImplAddress = {
   8453: "0x7777773606e7e46C8Ba8B98C08f5cD218e31d340",
   42161: "0x7777773606e7e46C8Ba8B98C08f5cD218e31d340",
   81457: "0x7777773606e7e46C8Ba8B98C08f5cD218e31d340",
+  84532: "0x7777773606e7e46C8Ba8B98C08f5cD218e31d340",
   421614: "0x7777773606e7e46C8Ba8B98C08f5cD218e31d340",
   7777777: "0x7777773606e7e46C8Ba8B98C08f5cD218e31d340",
   11155111: "0x7777773606e7e46C8Ba8B98C08f5cD218e31d340",
@@ -5408,6 +7100,7 @@ var zoraMints1155ABI = [
   { type: "error", inputs: [], name: "TokenNotMintable" }
 ];
 var zoraMints1155Address = {
+  84532: "0x7777777d57c1C6e472fa379b7b3B6c6ba3835073",
   7777777: "0x7777777d57c1C6e472fa379b7b3B6c6ba3835073",
   999999999: "0x7777777d57c1C6e472fa379b7b3B6c6ba3835073"
 };
@@ -5422,7 +7115,7 @@ var zoraMintsManagerImplABI = [
     inputs: [
       {
         name: "_premintExecutor",
-        internalType: "contract IZoraCreator1155PremintExecutorV2",
+        internalType: "contract IZoraCreator1155PremintExecutorAllVersions",
         type: "address"
       }
     ]
@@ -5500,6 +7193,73 @@ var zoraMintsManagerImplABI = [
     name: "collect",
     outputs: []
   },
+  {
+    stateMutability: "payable",
+    type: "function",
+    inputs: [
+      {
+        name: "contractConfig",
+        internalType: "struct ContractWithAdditionalAdminsCreationConfig",
+        type: "tuple",
+        components: [
+          { name: "contractAdmin", internalType: "address", type: "address" },
+          { name: "contractURI", internalType: "string", type: "string" },
+          { name: "contractName", internalType: "string", type: "string" },
+          {
+            name: "additionalAdmins",
+            internalType: "address[]",
+            type: "address[]"
+          }
+        ]
+      },
+      { name: "tokenContract", internalType: "address", type: "address" },
+      {
+        name: "premintConfig",
+        internalType: "struct PremintConfigEncoded",
+        type: "tuple",
+        components: [
+          { name: "uid", internalType: "uint32", type: "uint32" },
+          { name: "version", internalType: "uint32", type: "uint32" },
+          { name: "deleted", internalType: "bool", type: "bool" },
+          { name: "tokenConfig", internalType: "bytes", type: "bytes" },
+          {
+            name: "premintConfigVersion",
+            internalType: "bytes32",
+            type: "bytes32"
+          }
+        ]
+      },
+      { name: "signature", internalType: "bytes", type: "bytes" },
+      {
+        name: "mintArguments",
+        internalType: "struct MintArguments",
+        type: "tuple",
+        components: [
+          { name: "mintRecipient", internalType: "address", type: "address" },
+          { name: "mintComment", internalType: "string", type: "string" },
+          {
+            name: "mintRewardsRecipients",
+            internalType: "address[]",
+            type: "address[]"
+          }
+        ]
+      },
+      { name: "signerContract", internalType: "address", type: "address" }
+    ],
+    name: "collectPremint",
+    outputs: [
+      {
+        name: "result",
+        internalType: "struct PremintResult",
+        type: "tuple",
+        components: [
+          { name: "contractAddress", internalType: "address", type: "address" },
+          { name: "tokenId", internalType: "uint256", type: "uint256" },
+          { name: "createdNewContract", internalType: "bool", type: "bool" }
+        ]
+      }
+    ]
+  },
   {
     stateMutability: "payable",
     type: "function",
@@ -6235,6 +7995,7 @@ var zoraMintsManagerImplABI = [
   { type: "error", inputs: [], name: "premintSignerContractNotAContract" }
 ];
 var zoraMintsManagerImplAddress = {
+  84532: "0x77777770cA269366c7208aFcF36FE2C6F7f7608B",
   7777777: "0x77777770cA269366c7208aFcF36FE2C6F7f7608B",
   999999999: "0x77777770cA269366c7208aFcF36FE2C6F7f7608B"
 };
@@ -6243,15 +8004,29 @@ var zoraMintsManagerImplConfig = {
   abi: zoraMintsManagerImplABI
 };
 
+// node_modules/viem/_esm/index.js
+init_encodeAbiParameters();
+init_getAbiItem();
+init_toHex();
+init_keccak256();
+
+// src/types.ts
+var PremintConfigVersion = /* @__PURE__ */ ((PremintConfigVersion2) => {
+  PremintConfigVersion2["V1"] = "1";
+  PremintConfigVersion2["V2"] = "2";
+  PremintConfigVersion2["V3"] = "3";
+  return PremintConfigVersion2;
+})(PremintConfigVersion || {});
+
 // src/typedData.ts
 var premintTypedDataDomain = ({
   chainId,
-  version,
+  version: version2,
   creator1155Contract: verifyingContract
 }) => ({
   chainId,
   name: "Preminter",
-  version,
+  version: version2,
   verifyingContract
 });
 var premintV1TypedDataType = {
@@ -6278,6 +8053,58 @@ var premintV1TypedDataType = {
     { name: "fixedPriceMinter", type: "address" }
   ]
 };
+var encodeTokenConfigV1 = (config) => {
+  const abiItem = getAbiItem({
+    abi: iPremintDefinitionsABI,
+    name: "tokenConfigV1Definition"
+  });
+  return encodeAbiParameters(abiItem.inputs, [config]);
+};
+var encodeTokenConfigV2 = (config) => {
+  const abiItem = getAbiItem({
+    abi: iPremintDefinitionsABI,
+    name: "tokenConfigV2Definition"
+  });
+  return encodeAbiParameters(abiItem.inputs, [config]);
+};
+var encodeTokenConfigV3 = (config) => {
+  const abiItem = getAbiItem({
+    abi: iPremintDefinitionsABI,
+    name: "tokenConfigV3Definition"
+  });
+  return encodeAbiParameters(abiItem.inputs, [config]);
+};
+var encodeTokenConfig = ({
+  tokenConfig,
+  premintConfigVersion
+}) => {
+  if (premintConfigVersion === "1" /* V1 */) {
+    return encodeTokenConfigV1(tokenConfig);
+  }
+  if (premintConfigVersion === "2" /* V2 */) {
+    return encodeTokenConfigV2(tokenConfig);
+  }
+  if (premintConfigVersion === "3" /* V3 */) {
+    return encodeTokenConfigV3(tokenConfig);
+  }
+  throw new Error("Invalid PremintConfigVersion: " + premintConfigVersion);
+};
+var encodePremintConfig = ({
+  premintConfig,
+  premintConfigVersion
+}) => {
+  const encodedTokenConfig = encodeTokenConfig({
+    premintConfigVersion,
+    tokenConfig: premintConfig.tokenConfig
+  });
+  return {
+    deleted: premintConfig.deleted,
+    uid: premintConfig.uid,
+    version: premintConfig.version,
+    premintConfigVersion: keccak256(toHex(premintConfigVersion)),
+    tokenConfig: encodedTokenConfig
+  };
+};
 var premintV1TypedDataDefinition = ({
   chainId,
   creator1155Contract,
@@ -6287,7 +8114,7 @@ var premintV1TypedDataDefinition = ({
   primaryType: "CreatorAttribution",
   domain: premintTypedDataDomain({
     chainId,
-    version: "1",
+    version: "1" /* V1 */,
     creator1155Contract
   }),
   message
@@ -6325,11 +8152,32 @@ var premintV2TypedDataDefinition = ({
   primaryType: "CreatorAttribution",
   domain: premintTypedDataDomain({
     chainId,
-    version: "2",
+    version: "2" /* V2 */,
     creator1155Contract
   }),
   message
 });
+var premintTypedDataDefinition = ({
+  verifyingContract,
+  chainId,
+  premintConfigVersion: version2,
+  premintConfig
+}) => {
+  if (version2 === "1" /* V1 */)
+    return premintV1TypedDataDefinition({
+      chainId,
+      creator1155Contract: verifyingContract,
+      message: premintConfig
+    });
+  if (version2 === "2" /* V2 */) {
+    return premintV2TypedDataDefinition({
+      chainId,
+      creator1155Contract: verifyingContract,
+      message: premintConfig
+    });
+  }
+  throw new Error(`Invalid version ${version2}`);
+};
 var permitSafeTransferTypedDataType = {
   PermitSafeTransfer: [
     { name: "owner", type: "address" },
@@ -6440,8 +8288,8 @@ var chainConfigs = {
     PROTOCOL_REWARDS: "0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B"
   },
   84532: {
-    FACTORY_OWNER: "0x12125c8a52B8E4ed1A28e1f964023b4477f11300",
-    MINT_FEE_RECIPIENT: "0x12125c8a52B8E4ed1A28e1f964023b4477f11300",
+    FACTORY_OWNER: "0x5F14C23983c9e0840Dc60dA880349622f0785420",
+    MINT_FEE_RECIPIENT: "0x5F14C23983c9e0840Dc60dA880349622f0785420",
     PROTOCOL_REWARDS: "0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B"
   },
   421614: {
@@ -6555,18 +8403,18 @@ var addresses = {
     timestamp: 1709235955
   },
   84532: {
-    CONTRACT_1155_IMPL: "0x8237F421357F87a23ed0CFf3a5586172F210A21B",
-    CONTRACT_1155_IMPL_VERSION: "2.7.3",
-    FACTORY_IMPL: "0x932A29Dbfc1B8c3BdfC763eF53F113486A5b5E7D",
-    FACTORY_PROXY: "0x8cfbF874A12b346115003532119C29f6B56719CB",
+    CONTRACT_1155_IMPL: "0x2C49E95303734eE3826307783d5fDD180B2131D3",
+    CONTRACT_1155_IMPL_VERSION: "2.9.0",
+    FACTORY_IMPL: "0xB2696570215c3158eB1D218FB1a3DF92a418B034",
+    FACTORY_PROXY: "0x777777C338d93e2C7adf08D102d45CA7CC4Ed021",
     FIXED_PRICE_SALE_STRATEGY: "0xd34872BE0cdb6b09d45FCa067B07f04a1A9aE1aE",
     MERKLE_MINT_SALE_STRATEGY: "0x3E8524770adD176bE381a0529E09f1c6c3502A5a",
-    PREMINTER_IMPL: "",
-    PREMINTER_PROXY: "",
+    PREMINTER_IMPL: "0xD754417BDABFCc3a3997B9A15E9F6922a8131Ac1",
+    PREMINTER_PROXY: "0x7777773606e7e46C8Ba8B98C08f5cD218e31d340",
     REDEEM_MINTER_FACTORY: "0x805E0a08dE70f85C01F7848370d5e3fc08aAd0ea",
-    UPGRADE_GATE: "0x0ABdD5AA61E9107519DB7cD626442B905284B7eb",
+    UPGRADE_GATE: "0xbC50029836A59A4E5e1Bb8988272F46ebA0F9900",
     ERC20_MINTER: "0x777777E8850d8D6d98De2B5f64fae401F96eFF31",
-    timestamp: 1706663694
+    timestamp: 1713468185
   },
   421614: {
     CONTRACT_1155_IMPL: "0xc288fe9B145fC31D9aFBa771d0FeB986F6eb49e3",
@@ -6626,16 +8474,16 @@ var addresses = {
   999999999: {
     CONTRACT_1155_IMPL: "0xaDf7F654d8E416aaD85d4f06fDf4cA3D05BDA1A1",
     CONTRACT_1155_IMPL_VERSION: "2.9.0",
-    FACTORY_IMPL: "0xE8219ad920ab6ae21aF2d3831df4B18d96d23F5a",
+    ERC20_MINTER: "0x8Ec7f068A77fa5FC1925110f82381374BA054Ff2",
+    FACTORY_IMPL: "0x7228C5BE6093cf57BC085aaFFB18D0b7886f0651",
     FACTORY_PROXY: "0x777777C338d93e2C7adf08D102d45CA7CC4Ed021",
     FIXED_PRICE_SALE_STRATEGY: "0x6d28164C3CE04A190D5F9f0f8881fc807EAD975A",
     MERKLE_MINT_SALE_STRATEGY: "0x5e5fD4b758076BAD940db0284b711A67E8a3B88c",
-    PREMINTER_IMPL: "0x1840606A43AC211Ffd548BE727563D863bfCF707",
+    PREMINTER_IMPL: "0xdABa152A152a14844E627444B55a543beF7c4365",
     PREMINTER_PROXY: "0x7777773606e7e46C8Ba8B98C08f5cD218e31d340",
     REDEEM_MINTER_FACTORY: "0x25cFb6dd9cDE8425e781d6718a29Ccbca3F038d6",
     UPGRADE_GATE: "0x0000000000000000000000000000000000000000",
-    ERC20_MINTER: "0x777777E8850d8D6d98De2B5f64fae401F96eFF31",
-    timestamp: 1712339316
+    timestamp: 1715977010
   }
 };
 
@@ -6670,6 +8518,7 @@ var chainConfigs2 = {
     PROXY_ADMIN: "0x02539E813cA450C2c7334e885423f4A899a063Fe",
     MINTS_OWNER: "0x02539E813cA450C2c7334e885423f4A899a063Fe"
   },
+  84532: { PROXY_ADMIN: "0x5F14C23983c9e0840Dc60dA880349622f0785420" },
   7777777: {
     PROXY_ADMIN: "0xdEA20c96253dc2d64897D2b8d27A8d935dE74955",
     MINTS_OWNER: "0xEcfc2ee50409E459c554a2b0376F882Ce916D853"
@@ -6684,6 +8533,11 @@ var chainConfigs2 = {
   }
 };
 var addresses2 = {
+  84532: {
+    MINTS_ETH_UNWRAPPER_AND_CALLER: "0x0000000000000000000000000000000000000000",
+    MINTS_MANAGER_IMPL: "0x32C49770cC95F6A606Ae5a22A0a70e8F8ff64C75",
+    MINTS_MANAGER_IMPL_VERSION: "0.1.3"
+  },
   7777777: {
     MINTS_ETH_UNWRAPPER_AND_CALLER: "0xb0994EB9520C98C97e1F3953a5964535C2bd271A",
     MINTS_MANAGER_IMPL: "0x978685ad10B829F17e6c2C6E8EeABd7dFDdC1678",
@@ -6691,16 +8545,19 @@ var addresses2 = {
   },
   999999999: {
     MINTS_ETH_UNWRAPPER_AND_CALLER: "0xb0994EB9520C98C97e1F3953a5964535C2bd271A",
-    MINTS_MANAGER_IMPL: "0x978685ad10B829F17e6c2C6E8EeABd7dFDdC1678",
-    MINTS_MANAGER_IMPL_VERSION: "0.1.2"
+    MINTS_MANAGER_IMPL: "0x65690B699591aDE72b30aa10B0c34BB78cAc61c0",
+    MINTS_MANAGER_IMPL_VERSION: "0.1.3"
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  PremintConfigVersion,
   contracts1155,
+  encodePremintConfig,
   erc20MinterABI,
   erc20MinterAddress,
   erc20MinterConfig,
+  iPremintDefinitionsABI,
   iUnwrapAndForwardActionABI,
   mints,
   mintsEthUnwrapperAndCallerABI,
@@ -6708,6 +8565,7 @@ var addresses2 = {
   mintsEthUnwrapperAndCallerConfig,
   mintsSafeTransferBatchTypedDataDefinition,
   mintsSafeTransferTypedDataDefinition,
+  premintTypedDataDefinition,
   premintV1TypedDataDefinition,
   premintV2TypedDataDefinition,
   protocolRewardsABI,
@@ -6736,4 +8594,9 @@ var addresses2 = {
   zoraMintsManagerImplAddress,
   zoraMintsManagerImplConfig
 });
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
 //# sourceMappingURL=index.cjs.map