@gearbox-protocol/sdk 9.14.1 → 9.15.1

package/dist/cjs/permissionless/utils/abi-encoder.js

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var abi_encoder_exports = {};
+__export(abi_encoder_exports, {
+  encodeFunctionParams: () => encodeFunctionParams
+});
+module.exports = __toCommonJS(abi_encoder_exports);
+var import_viem = require("viem");
+function encodeFunctionParams(params) {
+  const types = [];
+  const values = [];
+  for (const { type, value } of params) {
+    switch (type) {
+      case "address":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "bytes32":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "string":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "uint256":
+      case "int256":
+      case "uint32":
+        types.push({ type });
+        values.push(BigInt(value));
+        break;
+      case "uint8":
+        types.push({ type });
+        values.push(Number(value));
+        break;
+      case "bool":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "address[]":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "bytes32[]":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "string[]":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "uint256[]":
+      case "int256[]":
+      case "uint32[]":
+        types.push({ type });
+        values.push(value.map((v) => BigInt(v)));
+        break;
+      case "uint8[]":
+        types.push({ type });
+        values.push(value.map((v) => Number(v)));
+        break;
+      case "bool[]":
+        types.push({ type });
+        values.push(value);
+        break;
+    }
+  }
+  return (0, import_viem.encodeAbiParameters)(types, values);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  encodeFunctionParams
+});

package/dist/cjs/permissionless/utils/block-utils.js

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var block_utils_exports = {};
+__export(block_utils_exports, {
+  getBlockNumberByTimestamp: () => getBlockNumberByTimestamp
+});
+module.exports = __toCommonJS(block_utils_exports);
+async function getBlockNumberByTimestamp(client, targetTimestamp) {
+  const latestBlock = await client.getBlock({ blockTag: "latest" });
+  const latestBlockNumber = Number(latestBlock.number);
+  const latestTimestamp = Number(latestBlock.timestamp);
+  if (targetTimestamp >= latestTimestamp) {
+    return latestBlockNumber;
+  }
+  let left = 0;
+  let right = latestBlockNumber;
+  let closestBlock = latestBlockNumber;
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    const block = await client.getBlock({
+      blockNumber: BigInt(mid)
+    });
+    const blockTimestamp = Number(block.timestamp);
+    if (blockTimestamp === targetTimestamp) {
+      return mid;
+    }
+    if (blockTimestamp < targetTimestamp) {
+      left = mid + 1;
+    } else {
+      right = mid - 1;
+      closestBlock = mid;
+    }
+  }
+  return closestBlock;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBlockNumberByTimestamp
+});

package/dist/cjs/permissionless/utils/create2.js

@@ -0,0 +1,113 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var create2_exports = {};
+__export(create2_exports, {
+  PUBLIC_CREATE2_FACTORY: () => PUBLIC_CREATE2_FACTORY,
+  checkCreate2Deployment: () => checkCreate2Deployment,
+  checkCreate2DeploymentAddress: () => checkCreate2DeploymentAddress,
+  createCreate2DeployRawTx: () => createCreate2DeployRawTx,
+  deployUsingPublicCreate2: () => deployUsingPublicCreate2,
+  getCreate2AddressPublicFactory: () => getCreate2AddressPublicFactory,
+  getCreate2DeploymentAddress: () => getCreate2DeploymentAddress,
+  handleSalt: () => handleSalt
+});
+module.exports = __toCommonJS(create2_exports);
+var import_abitype = require("abitype");
+var import_viem = require("viem");
+const PUBLIC_CREATE2_FACTORY = "0x4e59b44847b379578588920ca78fbf26c0b4956c";
+function handleSalt(salt) {
+  if (salt.slice(0, 2) !== "0x" || salt.length !== 66) {
+    salt = (0, import_viem.stringToHex)(salt, { size: 32 });
+  }
+  return salt;
+}
+async function deployUsingPublicCreate2(sponsor, bytecode, salt) {
+  const callData = `${handleSalt(salt)}${bytecode.replace("0x", "")}`;
+  const hash = await sponsor.sendTransaction({
+    to: PUBLIC_CREATE2_FACTORY,
+    data: callData,
+    account: sponsor.account,
+    chain: sponsor.chain
+  });
+  return hash;
+}
+async function getCreate2AddressPublicFactory(salt, bytecode) {
+  return (0, import_viem.getCreate2Address)({
+    from: PUBLIC_CREATE2_FACTORY,
+    salt: handleSalt(salt),
+    bytecode
+  });
+}
+function createCreate2DeployRawTx(bytecode, salt) {
+  const callData = `${handleSalt(salt)}${bytecode.replace("0x", "")}`;
+  const deterministicDeployerAbi = [
+    {
+      payable: true,
+      stateMutability: "payable",
+      type: "fallback"
+    }
+  ];
+  const signature = (0, import_abitype.formatAbiItem)(deterministicDeployerAbi[0]);
+  const contractMethod = {
+    name: "fallback",
+    inputs: [],
+    payable: true
+  };
+  const rawTx = {
+    to: PUBLIC_CREATE2_FACTORY,
+    value: "0",
+    signature,
+    callData,
+    contractMethod,
+    contractInputsValues: {},
+    description: ""
+  };
+  return rawTx;
+}
+function getCreate2DeploymentAddress(bytecode, salt) {
+  return (0, import_viem.getCreate2Address)({
+    from: PUBLIC_CREATE2_FACTORY,
+    salt: handleSalt(salt),
+    bytecode
+  });
+}
+async function checkCreate2Deployment(client, bytecode, salt) {
+  const address = getCreate2DeploymentAddress(bytecode, salt);
+  const code = await client.getCode({ address });
+  return code !== void 0;
+}
+async function checkCreate2DeploymentAddress(client, bytecode, salt) {
+  const address = getCreate2DeploymentAddress(bytecode, salt);
+  const code = await client.getCode({ address });
+  if (code !== void 0) {
+    return [true, address];
+  }
+  return [false, address];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PUBLIC_CREATE2_FACTORY,
+  checkCreate2Deployment,
+  checkCreate2DeploymentAddress,
+  createCreate2DeployRawTx,
+  deployUsingPublicCreate2,
+  getCreate2AddressPublicFactory,
+  getCreate2DeploymentAddress,
+  handleSalt
+});

package/dist/cjs/permissionless/utils/format.js

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var format_exports = {};
+__export(format_exports, {
+  convertPercent: () => convertPercent,
+  deepJsonParse: () => deepJsonParse,
+  formatBytecodeSize: () => formatBytecodeSize,
+  formatBytecodeVersion: () => formatBytecodeVersion,
+  formatTimestamp: () => formatTimestamp,
+  shortenHash: () => shortenHash,
+  significantTrunc: () => significantTrunc
+});
+module.exports = __toCommonJS(format_exports);
+var import_utils = require("../../sdk/utils/index.js");
+function formatBytecodeSize(size) {
+  return `${(size / 1024).toFixed(2)} KB`;
+}
+function formatBytecodeVersion(version) {
+  if (version === 0) return "-";
+  const major = Math.floor(version / 100);
+  const minor = Math.floor(version % 100 / 10);
+  const patch = version % 10;
+  return `v${major}.${minor}.${patch}`;
+}
+function formatTimestamp(timestamp) {
+  return new Date(timestamp * 1e3).toLocaleString("en-GB", {
+    dateStyle: "short",
+    timeStyle: "short"
+  });
+}
+function shortenHash(hash, chars = 4) {
+  if (!hash) return "";
+  const start = hash.slice(0, chars + 2);
+  const end = hash.slice(-chars);
+  return `${start}...${end}`;
+}
+function convertPercent(percent) {
+  return Math.floor(percent * 100);
+}
+function significantTrunc(x) {
+  if (x === 0) return "0";
+  if (x >= 1) return x.toFixed(0);
+  const str = x.toPrecision(2);
+  if (str.includes("e")) {
+    const value = Number(str);
+    return value.toFixed(20).replace(/\.?0+$/, "");
+  }
+  return str.replace(/\.?0+$/, "");
+}
+function deepJsonParse(value) {
+  if (typeof value === "string") {
+    try {
+      const parsed = (0, import_utils.json_parse)(value);
+      if (parsed === value) return value;
+      return deepJsonParse(parsed);
+    } catch {
+      return value;
+    }
+  }
+  if (Array.isArray(value)) {
+    return value.map(deepJsonParse);
+  }
+  if (typeof value === "object" && value !== null) {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = deepJsonParse(v);
+    }
+    return result;
+  }
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertPercent,
+  deepJsonParse,
+  formatBytecodeSize,
+  formatBytecodeVersion,
+  formatTimestamp,
+  shortenHash,
+  significantTrunc
+});

package/dist/cjs/permissionless/utils/governance/batch.js

@@ -0,0 +1,114 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var batch_exports = {};
+__export(batch_exports, {
+  calculateChecksum: () => calculateChecksum,
+  convertRawTxToSafeMultisigTx: () => convertRawTxToSafeMultisigTx,
+  getSafeBatch: () => getSafeBatch,
+  getSafeBatches: () => getSafeBatches
+});
+module.exports = __toCommonJS(batch_exports);
+var import_viem = require("viem");
+function convertRawTxToSafeMultisigTx(tx) {
+  const { to, value, contractMethod, contractInputsValues } = tx;
+  return {
+    to,
+    value: `${value}`,
+    data: tx.callData,
+    contractMethod,
+    contractInputsValues: Object.entries(contractInputsValues).reduce(
+      (acc, [key, value2]) => {
+        acc[key] = typeof value2 === "object" ? JSON.stringify(
+          value2,
+          (_, v) => typeof v === "bigint" ? v.toString() : v
+        ) : `${value2}`;
+        return acc;
+      },
+      {}
+    )
+  };
+}
+function stringifyReplacer(_, value) {
+  return value === void 0 ? null : `${value}`;
+}
+function serializeJSONObject(json) {
+  if (Array.isArray(json)) {
+    return `[${json.map((el) => serializeJSONObject(el)).join(",")}]`;
+  }
+  if (typeof json === "object" && json !== null) {
+    let acc = "";
+    const keys = Object.keys(json).sort();
+    acc += `{${JSON.stringify(keys, stringifyReplacer)}`;
+    for (const key of keys) {
+      acc += `${serializeJSONObject(json[key])},`;
+    }
+    return `${acc}}`;
+  }
+  return `${JSON.stringify(json, stringifyReplacer)}`;
+}
+function calculateChecksum(multisigBatch) {
+  const serialized = serializeJSONObject({
+    ...multisigBatch,
+    meta: { ...multisigBatch.meta, name: null }
+  });
+  return (0, import_viem.keccak256)((0, import_viem.toBytes)(serialized));
+}
+function getSafeBatch(args) {
+  const { chainId, safeAddress, name, txs: transactions } = args;
+  const batchInfo = {
+    version: "1.0",
+    chainId: `${chainId}`,
+    createdAt: Date.now(),
+    safeAddress,
+    meta: {
+      name,
+      description: name,
+      txBuilderVersion: "1.16.0",
+      createdFromSafeAddress: safeAddress,
+      createdFromOwnerAddress: ""
+    },
+    transactions
+  };
+  const batch = {
+    ...batchInfo,
+    meta: {
+      ...batchInfo.meta,
+      checksum: calculateChecksum(batchInfo)
+    }
+  };
+  return batch;
+}
+function getSafeBatches(args) {
+  const { batches, name } = args;
+  return batches.map((txs, index) => {
+    const batchName = `${name}-#${index}`;
+    return getSafeBatch({
+      ...args,
+      name: batchName,
+      txs
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateChecksum,
+  convertRawTxToSafeMultisigTx,
+  getSafeBatch,
+  getSafeBatches
+});

package/dist/cjs/permissionless/utils/governance/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var governance_exports = {};
+module.exports = __toCommonJS(governance_exports);
+__reExport(governance_exports, require("./batch.js"), module.exports);
+__reExport(governance_exports, require("./timelock-txs.js"), module.exports);
+__reExport(governance_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./batch.js"),
+  ...require("./timelock-txs.js"),
+  ...require("./types.js")
+});

package/dist/cjs/permissionless/utils/governance/timelock-txs.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var timelock_txs_exports = {};
+__export(timelock_txs_exports, {
+  convertQueueBatchToExecuteTx: () => convertQueueBatchToExecuteTx
+});
+module.exports = __toCommonJS(timelock_txs_exports);
+var import_governor = require("../../../abi/governance/governor.js");
+var import_utils = require("../../../sdk/utils/index.js");
+var import_batch = require("./batch.js");
+function convertQueueBatchToExecuteTx(queueBatch) {
+  const executionBatch = queueBatch.filter((tx) => tx.contractMethod.name === "queueTransaction").map((tx) => ({
+    ...tx.contractInputsValues,
+    value: BigInt(tx.contractInputsValues.value),
+    eta: BigInt(tx.contractInputsValues.eta)
+  }));
+  return (0, import_batch.convertRawTxToSafeMultisigTx)(
+    (0, import_utils.createRawTx)(queueBatch[0].to, {
+      functionName: "executeBatch",
+      args: [executionBatch],
+      abi: import_governor.governorAbi
+    })
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertQueueBatchToExecuteTx
+});

package/dist/cjs/permissionless/utils/governance/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/permissionless/utils/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./abi-decoder.js"), module.exports);
+__reExport(utils_exports, require("./abi-encoder.js"), module.exports);
+__reExport(utils_exports, require("./block-utils.js"), module.exports);
+__reExport(utils_exports, require("./create2.js"), module.exports);
+__reExport(utils_exports, require("./format.js"), module.exports);
+__reExport(utils_exports, require("./governance/index.js"), module.exports);
+__reExport(utils_exports, require("./literals.js"), module.exports);
+__reExport(utils_exports, require("./price-update/index.js"), module.exports);
+__reExport(utils_exports, require("./signature.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./abi-decoder.js"),
+  ...require("./abi-encoder.js"),
+  ...require("./block-utils.js"),
+  ...require("./create2.js"),
+  ...require("./format.js"),
+  ...require("./governance/index.js"),
+  ...require("./literals.js"),
+  ...require("./price-update/index.js"),
+  ...require("./signature.js")
+});

package/dist/cjs/permissionless/utils/literals.js

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var literals_exports = {};
+__export(literals_exports, {
+  BYTECODE_REPOSITORY: () => BYTECODE_REPOSITORY,
+  CROSS_CHAIN_GOVERNANCE: () => CROSS_CHAIN_GOVERNANCE,
+  CROSS_CHAIN_MULTISIG: () => CROSS_CHAIN_MULTISIG,
+  INSTANCE_MANAGER: () => INSTANCE_MANAGER,
+  MARKET_CONFIGURATOR_FACTORY: () => MARKET_CONFIGURATOR_FACTORY,
+  PRICE_FEED_STORE: () => PRICE_FEED_STORE,
+  TOKEN_COMPRESSOR: () => TOKEN_COMPRESSOR
+});
+module.exports = __toCommonJS(literals_exports);
+const CROSS_CHAIN_GOVERNANCE = "CROSS_CHAIN_GOVERNANCE";
+const BYTECODE_REPOSITORY = "BYTECODE_REPOSITORY";
+const INSTANCE_MANAGER = "INSTANCE_MANAGER";
+const TOKEN_COMPRESSOR = "GLOBAL::TOKEN_COMPRESSOR";
+const CROSS_CHAIN_MULTISIG = "CROSS_CHAIN_MULTISIG";
+const PRICE_FEED_STORE = "PRICE_FEED_STORE";
+const MARKET_CONFIGURATOR_FACTORY = "MARKET_CONFIGURATOR_FACTORY";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BYTECODE_REPOSITORY,
+  CROSS_CHAIN_GOVERNANCE,
+  CROSS_CHAIN_MULTISIG,
+  INSTANCE_MANAGER,
+  MARKET_CONFIGURATOR_FACTORY,
+  PRICE_FEED_STORE,
+  TOKEN_COMPRESSOR
+});