@chainflip/processor 2.0.2 → 2.0.4

package/dist/generate.cjs

@@ -0,0 +1,1078 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/codegen/generate.ts
+var generate_exports = {};
+__export(generate_exports, {
+  default: () => generate
+});
+module.exports = __toCommonJS(generate_exports);
+var fs5 = __toESM(require("fs/promises"), 1);
+var os = __toESM(require("os"), 1);
+var path5 = __toESM(require("path"), 1);
+
+// ../chainspec/src/cache.ts
+var import_rpc = require("@chainflip/rpc");
+var import_async = require("@chainflip/utils/async");
+var import_types = require("@polkadot/types");
+var fs = __toESM(require("fs/promises"), 1);
+var path = __toESM(require("path"), 1);
+var import_zod = require("zod");
+var import_meta = {};
+var cacheSchema = import_zod.z.record(
+  import_zod.z.object({
+    hash: import_zod.z.string(),
+    network: import_zod.z.enum(["mainnet", "perseverance", "sisyphos", "backspin", "localnet"])
+  })
+);
+var networkToRpcUrl = {
+  mainnet: "https://archive.mainnet.chainflip.io",
+  perseverance: "https://archive.perseverance.chainflip.io",
+  sisyphos: "https://archive.sisyphos.chainflip.io",
+  backspin: "https://rpc.backspin.chainflip.io",
+  localnet: "http://127.0.0.1:9944"
+};
+var SpecVersionCache = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  contents;
+  queue = new import_async.Queue();
+  async read() {
+    const contents = JSON.parse(
+      await fs.readFile(this.filePath, "utf8").catch(() => "{}")
+    );
+    this.contents ??= cacheSchema.parse(contents);
+    return this.contents;
+  }
+  async write(id, hash, network) {
+    return this.queue.enqueue(async () => {
+      const data = await this.read();
+      data[id] = { hash, network };
+      await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+      await fs.writeFile(this.filePath, JSON.stringify(data, null, 2));
+    });
+  }
+  async persistMetadata(specVersion, filePath, bytes) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, bytes);
+    for (const file of await fs.readdir(this.getDir())) {
+      if (file.startsWith(`${specVersion}-`) && file !== path.basename(filePath)) {
+        await fs.rm(path.join(this.getDir(), file)).catch(() => null);
+      }
+    }
+  }
+  async fetchSpecVersion(hash, network) {
+    const client = new import_rpc.HttpClient(networkToRpcUrl[network]);
+    const { specVersion } = await client.sendRequest("state_getRuntimeVersion", hash);
+    return specVersion;
+  }
+  async getVersion(hash, network) {
+    const data = await this.read();
+    const [version] = Object.entries(data).find(([, d]) => d.hash === hash && d.network === network) ?? [];
+    return version !== void 0 ? Number(version) : void 0;
+  }
+  async getMetadataAndVersion(network, maybeHash) {
+    let specVersion;
+    let hash;
+    const client = new import_rpc.HttpClient(networkToRpcUrl[network]);
+    if (maybeHash) {
+      hash = maybeHash;
+      specVersion = await this.getVersion(maybeHash, network);
+    } else {
+      hash = await client.sendRequest("chain_getBlockHash");
+    }
+    if (!specVersion) {
+      specVersion = await this.fetchSpecVersion(hash, network);
+      await this.write(specVersion, hash, network);
+    }
+    const filePath = path.join(this.getDir(), `${specVersion}-${hash.slice(2, 8)}.scale`);
+    let bytes = await fs.readFile(filePath).catch(() => null);
+    if (!bytes) {
+      const metadata2 = await client.sendRequest("state_getMetadata", hash);
+      bytes = Buffer.from(metadata2.slice(2), "hex");
+      await this.persistMetadata(specVersion, filePath, bytes);
+    }
+    const registry = new import_types.TypeRegistry();
+    const metadata = new import_types.Metadata(registry, bytes);
+    registry.setMetadata(metadata);
+    return { specVersion, metadata };
+  }
+  getDir() {
+    return path.dirname(this.filePath);
+  }
+};
+var specVersionCache = new SpecVersionCache(
+  path.join(
+    typeof __dirname !== "undefined" ? __dirname : import_meta.dirname,
+    "..",
+    "metadata",
+    "specVersion.json"
+  )
+);
+
+// ../chainspec/src/Compiler.ts
+var fs2 = __toESM(require("fs/promises"), 1);
+var path2 = __toESM(require("path"), 1);
+
+// ../chainspec/src/utils.ts
+var import_assert = __toESM(require("assert"), 1);
+var prettier = __toESM(require("prettier"), 1);
+function* diff(a, b, path6 = []) {
+  const addedKeys = new Set(
+    Object.keys(b).filter((key) => b[key] !== void 0).filter((key) => !a[key])
+  );
+  const removedKeys = new Set(
+    Object.keys(a).filter((key) => a[key] !== void 0).filter((key) => !b[key])
+  );
+  const commonKeys = new Set(
+    Object.keys(a).filter((key) => a[key] !== void 0).filter((key) => b[key])
+  );
+  addedKeys.delete("$name");
+  removedKeys.delete("$name");
+  commonKeys.delete("$name");
+  for (const key of addedKeys) {
+    yield { path: [...path6, key], type: "added" };
+  }
+  for (const key of removedKeys) {
+    yield { path: [...path6, key], type: "removed" };
+  }
+  for (const key of commonKeys) {
+    if (typeof a[key] === "object" && typeof b[key] === "object") {
+      yield* diff(a[key], b[key], [...path6, key]);
+    } else if (a[key] !== b[key]) {
+      yield { path: [...path6, key], type: "changed" };
+    }
+  }
+}
+var ChangelogGenerator = class {
+  addedOrRemovedPallets = {};
+  changedEvents = {};
+  addedOrRemovedEvents = {};
+  trackedFieldChanges = /* @__PURE__ */ new Set();
+  add({ path: path6, type }) {
+    if (path6.length === 1) {
+      (0, import_assert.default)(type === "added" || type === "removed");
+      this.addedOrRemovedPallets[path6[0]] = type;
+    } else if (path6.length === 2) {
+      const name = `${path6[0]}.${path6[1]}`;
+      (0, import_assert.default)(type === "added" || type === "removed");
+      this.addedOrRemovedEvents[name] = type;
+    } else {
+      const [pallet, event, , field] = path6;
+      const id = `${pallet}.${event}.${field}`;
+      if (this.trackedFieldChanges.has(id)) return;
+      this.trackedFieldChanges.add(id);
+      (this.changedEvents[`${pallet}.${event}`] ??= []).push({ field, type, path: path6 });
+    }
+  }
+  toString() {
+    const lines = [];
+    const pallets = Object.keys(this.addedOrRemovedPallets).sort();
+    if (pallets.length) {
+      lines.push("New or removed pallets:");
+      for (const pallet of pallets) {
+        lines.push(`  ${pallet}: ${this.addedOrRemovedPallets[pallet]}`);
+      }
+      lines.push("");
+    }
+    const events = Object.keys(this.addedOrRemovedEvents).concat(Object.keys(this.changedEvents)).sort();
+    let currentPallet = "";
+    for (const event of events) {
+      const [pallet, name] = event.split(".");
+      if (pallet !== currentPallet) {
+        if (currentPallet) lines.push("");
+        currentPallet = pallet;
+        lines.push(`${pallet}:`);
+      }
+      if (event in this.addedOrRemovedEvents) {
+        lines.push(`  - ${name}: ${this.addedOrRemovedEvents[event]}`);
+      } else {
+        lines.push(`  - ${name}:`);
+        const fields = this.changedEvents[event].map(
+          ({ field, type, path: path6 }) => `    - ${field}: ${type} (${path6.filter((v) => v !== "value" && v !== "values" && v !== "fields").join(".")})`
+        );
+        lines.push(...fields);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+var diffSpecs = (a, b) => {
+  const changedOrAddedEvents = /* @__PURE__ */ new Set();
+  const changelog = new ChangelogGenerator();
+  for (const change of diff(a, b)) {
+    changelog.add(change);
+    const [pallet, event, field] = change.path;
+    if (event && (field || change.type === "added")) {
+      changedOrAddedEvents.add(`${pallet}.${event}`);
+    } else if (change.type === "added") {
+      Object.keys(b[pallet]).map((e) => `${pallet}.${e}`).forEach((ev) => changedOrAddedEvents.add(ev));
+    }
+  }
+  return { changedOrAddedEvents, changelog: changelog.toString() };
+};
+var formatCode = (code) => prettier.format(code, {
+  parser: "typescript",
+  singleQuote: true,
+  trailingComma: "all",
+  printWidth: 100
+});
+
+// ../chainspec/src/Compiler.ts
+var Compiler = class {
+  constructor(Parser2, CodeGenerator3, generatedDir, specVersionCache2 = specVersionCache) {
+    this.Parser = Parser2;
+    this.CodeGenerator = CodeGenerator3;
+    this.generatedDir = generatedDir;
+    this.specVersionCache = specVersionCache2;
+  }
+  async retrieveMetadata() {
+    const info = await this.specVersionCache.read();
+    const opts = Object.values(info).map((i) => ({
+      ...i,
+      generatedDir: this.generatedDir
+    }));
+    const metadataForHashes = (await Promise.all(
+      opts.map((o) => new this.Parser(o, this.specVersionCache).fetchAndParseSpec())
+    )).sort((a, b) => a.specVersion.compare(b.specVersion));
+    return metadataForHashes;
+  }
+  async compile(cb) {
+    let previousMetadata = {};
+    let acc;
+    let previousSpecVersion;
+    for (const { metadata, specVersion } of await this.retrieveMetadata()) {
+      const specDir = path2.join(this.generatedDir, specVersion.toString());
+      await fs2.rm(specDir, { recursive: true, force: true });
+      const { changedOrAddedEvents, changelog } = diffSpecs(previousMetadata, metadata);
+      const generator = new this.CodeGenerator({ trackedItems: changedOrAddedEvents });
+      for (const module2 of generator.generate(metadata)) {
+        await module2.writeFile(specDir, module2.isCommon() ? changelog : void 0);
+      }
+      acc = await cb?.(acc, {
+        new: { metadata, specVersion },
+        old: {
+          metadata: previousMetadata,
+          specVersion: previousSpecVersion
+        }
+      });
+      previousMetadata = metadata;
+      previousSpecVersion = specVersion;
+    }
+    return acc;
+  }
+};
+
+// ../chainspec/src/BaseCodeGenerator.ts
+var import_assertion = require("@chainflip/utils/assertion");
+var import_string = require("@chainflip/utils/string");
+var fs3 = __toESM(require("fs/promises"), 1);
+var path3 = __toESM(require("path"), 1);
+var CodegenResult = class {
+  constructor(code, dependencies = []) {
+    this.code = code;
+    this.dependencies = dependencies;
+  }
+  declarationType = "const";
+  toString() {
+    return this.code;
+  }
+  asType() {
+    this.declarationType = "type";
+    return this;
+  }
+};
+var Identifier = class extends CodegenResult {
+  constructor(identifier, pkg = "common") {
+    super(identifier);
+    this.pkg = pkg;
+  }
+  getDependencies() {
+    return [this];
+  }
+  [Symbol.toStringTag]() {
+    return "Identifier";
+  }
+};
+var Code = class extends CodegenResult {
+  getDependencies() {
+    return this.dependencies.flatMap((d) => d.getDependencies());
+  }
+  [Symbol.toStringTag]() {
+    return "Code";
+  }
+};
+var Module = class {
+  constructor(name, exports2, globalImports, pallet) {
+    this.name = name;
+    this.exports = exports2;
+    this.globalImports = globalImports;
+    this.pallet = pallet;
+  }
+  isCommon() {
+    return this.name === "common";
+  }
+  toString() {
+    const generated = [];
+    const dependencies = {};
+    for (const [identifier, type] of this.exports.entries()) {
+      const exportDeps = type.getDependencies();
+      for (const ident of exportDeps) {
+        if (ident.pkg === this.name) continue;
+        dependencies[ident.pkg] ??= /* @__PURE__ */ new Map();
+        dependencies[ident.pkg].set(ident.toString(), ident);
+      }
+      generated.push(`export ${type.declarationType} ${identifier} = ${type.toString()};`);
+      generated.push("");
+    }
+    return [
+      ...this.globalImports,
+      ...Object.entries(dependencies).map(([pkg, depsSet]) => {
+        const pkgPath = pkg === "common" ? "../common" : pkg;
+        const deps = [...depsSet.entries()].sort(([a], [b]) => a.toLowerCase() < b.toLowerCase() ? -1 : 1).map(([name, type]) => type.declarationType === "const" ? name : `type ${name}`);
+        const names = deps.length === 1 && deps[0].startsWith("*") ? deps[0] : `{ ${deps.join(", ")} }`;
+        return `import ${names} from '${pkgPath}';`;
+      }),
+      "",
+      ...generated
+    ].join("\n");
+  }
+  toFormattedString() {
+    return formatCode(this.toString());
+  }
+  async writeFile(specDir, changelog) {
+    const outDir = this.pallet ? path3.join(specDir, (0, import_string.uncapitalize)(this.pallet)) : specDir;
+    await fs3.mkdir(outDir, { recursive: true });
+    await fs3.writeFile(
+      path3.join(outDir, (0, import_string.uncapitalize)(`${this.name}.ts`)),
+      await this.toFormattedString(),
+      "utf8"
+    );
+    if (changelog) await fs3.writeFile(path3.join(outDir, "CHANGELOG.md"), changelog, "utf8");
+  }
+};
+var CodeGenerator = class {
+  registry = {
+    types: /* @__PURE__ */ new Map()
+  };
+  trackedItems;
+  constructor({ trackedItems } = {}) {
+    if (trackedItems) this.trackedItems = new Set(trackedItems);
+  }
+  generateResolvedType(def) {
+    switch (def.type) {
+      case "array":
+        return this.generateArray(def);
+      case "enum":
+        return this.generateEnum(def);
+      case "map":
+        return this.generateMap(def);
+      case "option":
+        return this.generateOption(def);
+      case "primitive":
+        return this.generatePrimitive(def);
+      case "range":
+        return this.generateRange(def);
+      case "struct":
+        return this.generateStruct(def);
+      case "tuple":
+        return this.generateTuple(def);
+      default:
+        return (0, import_assertion.unreachable)(def, `Unsupported type: ${def.type}`);
+    }
+  }
+  generateItem(itemName, def) {
+    return this.generateResolvedType(def);
+  }
+  getName(palletName, itemName) {
+    return this.getParserName(palletName, itemName);
+  }
+  getGlobalImports() {
+    return [];
+  }
+  getFileName(palletName, itemName) {
+    return itemName;
+  }
+  *generate(def) {
+    const unhandledItems = new Set(this.trackedItems);
+    const generatedItems = /* @__PURE__ */ new Set();
+    for (const [palletName, items] of Object.entries(def)) {
+      for (const [itemName, item] of Object.entries(items)) {
+        const parserName = this.getParserName(palletName, itemName);
+        if (this.trackedItems && !unhandledItems.delete(parserName)) continue;
+        generatedItems.add(parserName);
+        let generatedCode;
+        try {
+          generatedCode = this.generateItem(itemName, item);
+        } catch (e) {
+          console.error(`failed to parse: ${parserName}`);
+          console.error(JSON.stringify(item, null, 2));
+          console.error(e);
+          throw e;
+        }
+        const name = this.getName(palletName, itemName);
+        yield new Module(
+          this.getFileName(palletName, itemName),
+          /* @__PURE__ */ new Map([[name, generatedCode]]),
+          this.getGlobalImports(),
+          palletName
+        );
+      }
+    }
+    if (unhandledItems.size !== 0) {
+      console.error("Unhandled items:", unhandledItems);
+      throw new Error("Not all items were generated");
+    }
+    if (generatedItems.size === 0) return;
+    yield new Module("common", new Map(this.registry.types), this.getGlobalImports());
+  }
+};
+
+// src/codegen/Parser.ts
+var import_string3 = require("@chainflip/utils/string");
+var import_types3 = require("@polkadot/types");
+var import_assert3 = __toESM(require("assert"), 1);
+
+// ../chainspec/src/BaseParser.ts
+var import_guard = require("@chainflip/utils/guard");
+var import_string2 = require("@chainflip/utils/string");
+var import_types2 = require("@polkadot/types/types");
+var import_assert2 = __toESM(require("assert"), 1);
+var fs4 = __toESM(require("fs/promises"), 1);
+var path4 = __toESM(require("path"), 1);
+
+// ../chainspec/src/SpecVersion.ts
+var SpecVersion = class {
+  constructor(integerVersion) {
+    this.integerVersion = integerVersion;
+    const stringVersion = integerVersion.toString();
+    const versionLength = stringVersion.length;
+    const partLength = Math.ceil(versionLength / 3);
+    const paddedVersion = stringVersion.padStart(partLength * 3, "0");
+    this.major = parseInt(paddedVersion.slice(0, partLength), 10);
+    this.minor = parseInt(paddedVersion.slice(partLength, partLength * 2), 10);
+    this.patch = parseInt(paddedVersion.slice(partLength * 2), 10);
+  }
+  major;
+  minor;
+  patch;
+  compare(other) {
+    if (this.major < other.major) return -1;
+    if (this.major > other.major) return 1;
+    if (this.minor < other.minor) return -1;
+    if (this.minor > other.minor) return 1;
+    if (this.patch < other.patch) return -1;
+    if (this.patch > other.patch) return 1;
+    return 0;
+  }
+  toString() {
+    return this.integerVersion.toString();
+  }
+  toFormatted() {
+    return `${this.major}.${this.minor}.${this.patch}`;
+  }
+};
+
+// ../chainspec/src/BaseParser.ts
+var hasName = (obj) => obj.name !== void 0;
+var hasSubs = (type, count) => Array.isArray(type.sub) && (count === void 0 || type.sub.length === count);
+var hasSub = (type) => !Array.isArray(type.sub) && type.sub !== void 0;
+var isSi = (type) => type.info === import_types2.TypeDefInfo.Si && /^Lookup\d+$/.test(type.type);
+var BaseParser = class {
+  constructor(opts, specVersionCache2) {
+    this.specVersionCache = specVersionCache2;
+    this.hash = opts.hash;
+    this.network = opts.network ?? "backspin";
+    this.generatedDir = opts.generatedDir;
+  }
+  hash;
+  network;
+  generatedDir;
+  metadata;
+  specVersion;
+  currentPallet;
+  shouldParsePallet(_palletName) {
+    return true;
+  }
+  shouldParseItem(_palletName, _itemName) {
+    return true;
+  }
+  resolveType(type) {
+    const metadata = this.getMetadataSync();
+    switch (type.info) {
+      case import_types2.TypeDefInfo.Enum: {
+        (0, import_assert2.default)(hasSubs(type));
+        (0, import_assert2.default)(type.lookupName, "Enum type must have a lookupName");
+        const result = {
+          type: "enum",
+          $name: (0, import_string2.uncapitalize)(type.lookupName),
+          values: []
+        };
+        for (const sub of type.sub) {
+          result.values[sub.index] = {
+            name: sub.name,
+            value: this.resolveType(sub)
+          };
+        }
+        return result;
+      }
+      case import_types2.TypeDefInfo.Struct: {
+        (0, import_assert2.default)(hasSubs(type));
+        const result = {
+          type: "struct",
+          $name: type.lookupName ?? this.genericNamespace(type.namespace),
+          fields: {}
+        };
+        for (const sub of type.sub) {
+          result.fields[sub.name] = this.resolveType(sub);
+        }
+        return result;
+      }
+      case import_types2.TypeDefInfo.Si:
+        (0, import_assert2.default)(isSi(type));
+        return this.resolveType(metadata.registry.lookup.getTypeDef(type.type));
+      case import_types2.TypeDefInfo.Compact:
+        (0, import_assert2.default)(hasSub(type));
+        return this.resolveType(type.sub);
+      case import_types2.TypeDefInfo.Null:
+        return { type: "primitive", value: "null" };
+      case import_types2.TypeDefInfo.Plain:
+        return { type: "primitive", value: type.type };
+      case import_types2.TypeDefInfo.BTreeSet:
+      case import_types2.TypeDefInfo.Vec:
+      case import_types2.TypeDefInfo.VecFixed:
+        (0, import_assert2.default)(hasSub(type));
+        return {
+          type: "array",
+          value: this.resolveType(type.sub),
+          length: type.length
+        };
+      case import_types2.TypeDefInfo.Tuple:
+        (0, import_assert2.default)(hasSubs(type));
+        return {
+          type: "tuple",
+          values: type.sub.map((t) => this.resolveType(t))
+        };
+      case import_types2.TypeDefInfo.Option:
+        (0, import_assert2.default)(hasSub(type));
+        return {
+          type: "option",
+          value: this.resolveType(type.sub)
+        };
+      case import_types2.TypeDefInfo.Result:
+        (0, import_assert2.default)(hasSubs(type));
+        return {
+          type: "enum",
+          $name: (0, import_string2.uncapitalize)(type.typeName),
+          values: [
+            {
+              name: "Ok",
+              value: this.resolveType(type.sub[0])
+            },
+            {
+              name: "Err",
+              value: this.resolveType(type.sub[1])
+            }
+          ]
+        };
+      case import_types2.TypeDefInfo.Range:
+        (0, import_assert2.default)(hasSub(type));
+        return {
+          type: "range",
+          value: this.resolveType(type.sub)
+        };
+      case import_types2.TypeDefInfo.BTreeMap:
+        (0, import_assert2.default)(hasSubs(type, 2));
+        return {
+          type: "map",
+          key: this.resolveType(type.sub[0]),
+          value: this.resolveType(type.sub[1])
+        };
+      default:
+        throw new Error(`Unhandled type: ${type.info}`);
+    }
+  }
+  getPalletName() {
+    (0, import_assert2.default)(this.currentPallet, "Pallet not set");
+    return this.currentPallet;
+  }
+  genericNamespace(namespace) {
+    if (!namespace) return namespace;
+    if (namespace.startsWith("pallet_cf_ingress_egress")) {
+      const chain = /^(.+)IngressEgress$/.exec(this.getPalletName())[1];
+      return namespace.replace(
+        "pallet_cf_ingress_egress",
+        `pallet_cf_${chain.toLowerCase()}_ingress_egress`
+      );
+    }
+    if (namespace.startsWith("cf_chains")) {
+      const chain = /^(.+)IngressEgress$/.exec(this.getPalletName())?.[1];
+      if (chain) {
+        return namespace.replace("cf_chains", `cf_${chain.toLowerCase()}_chain`);
+      }
+    }
+    return namespace;
+  }
+  tryResolveType(type) {
+    try {
+      return this.resolveType(type);
+    } catch (error) {
+      console.error("failed to parse type:");
+      console.error(type);
+      console.error(error);
+      throw error;
+    }
+  }
+  parseMetadata() {
+    const metadata = this.getMetadataSync();
+    return Object.fromEntries(
+      metadata.asV14.pallets.map((pallet) => {
+        const palletMetadata = this.getItems(pallet);
+        if (!palletMetadata) return null;
+        const items = metadata.registry.lookup.getTypeDef(palletMetadata.type);
+        const palletName = pallet.name.toString();
+        if (!this.shouldParsePallet(palletName)) return null;
+        (0, import_assert2.default)(hasSubs(items));
+        return [palletName, items];
+      }).filter(import_guard.isNotNullish).map(([palletName, items]) => {
+        const itemsAndTypes = items.sub.filter(hasName).filter((item) => this.shouldParseItem(palletName, item.name)).map((item) => {
+          this.currentPallet = palletName;
+          return [item.name, this.tryResolveType(item)];
+        });
+        if (!itemsAndTypes.length) return null;
+        return [palletName, Object.fromEntries(itemsAndTypes)];
+      }).filter(import_guard.isNotNullish)
+    );
+  }
+  async fetchMetadataAndSpecVersion() {
+    if (this.metadata && this.specVersion) {
+      return { metadata: this.metadata, specVersion: this.specVersion };
+    }
+    const { specVersion, metadata } = await this.specVersionCache.getMetadataAndVersion(
+      this.network,
+      this.hash
+    );
+    this.specVersion = specVersion;
+    this.metadata = metadata;
+    return { specVersion, metadata };
+  }
+  getMetadataSync() {
+    (0, import_assert2.default)(this.metadata, "Metadata not available");
+    return this.metadata;
+  }
+  async getSpecVersion() {
+    let { specVersion } = this;
+    if (!specVersion) specVersion = (await this.fetchMetadataAndSpecVersion()).specVersion;
+    return specVersion;
+  }
+  async fetchAndParseSpec() {
+    const specVersion = new SpecVersion(await this.getSpecVersion());
+    const outfile = path4.join(this.generatedDir, `types-${specVersion.toString()}.json`);
+    let parsedMetadata = await fs4.readFile(outfile, "utf8").then((data) => JSON.parse(data)).catch(() => null);
+    if (!parsedMetadata) {
+      parsedMetadata = this.parseMetadata();
+      await fs4.mkdir(path4.dirname(outfile), { recursive: true });
+      await fs4.writeFile(outfile, JSON.stringify(parsedMetadata, null, 2));
+    }
+    return { metadata: parsedMetadata, specVersion };
+  }
+};
+
+// src/codegen/Parser.ts
+var hasSubs2 = (type, count) => Array.isArray(type.sub) && (count === void 0 || type.sub.length === count);
+var hasSub2 = (type) => !Array.isArray(type.sub) && type.sub !== void 0;
+var isSi2 = (type) => type.info === import_types3.TypeDefInfo.Si && /^Lookup\d+$/.test(type.type);
+var isPrimitiveType = (type) => type.type === "primitive";
+var Parser = class extends BaseParser {
+  getItems(pallet) {
+    return pallet.events.isSome ? pallet.events.unwrap() : null;
+  }
+  resolveType(type) {
+    const metadata = this.getMetadataSync();
+    switch (type.info) {
+      case import_types3.TypeDefInfo.Enum: {
+        (0, import_assert3.default)(hasSubs2(type));
+        (0, import_assert3.default)(type.lookupName, "Enum type must have a lookupName");
+        const result = {
+          type: "enum",
+          // inserts the pallet name to make it distinct, e.g. `CfPalletIngressEgress...` => `CfPalletSolanaIngressEgress...`
+          $name: (0, import_string3.uncapitalize)(type.lookupName).replace("IngressEgress", this.getPalletName()),
+          values: []
+        };
+        for (const sub of type.sub) {
+          result.values[sub.index] = {
+            name: sub.name,
+            value: this.resolveType(sub)
+          };
+        }
+        return result;
+      }
+      case import_types3.TypeDefInfo.Struct: {
+        (0, import_assert3.default)(hasSubs2(type));
+        let name = type.lookupName ?? this.genericNamespace(type.namespace);
+        if (name && this.getPalletName() !== "Environment") {
+          name = name.replace("IngressEgress", this.getPalletName());
+        }
+        const result = {
+          type: "struct",
+          $name: name,
+          fields: {}
+        };
+        for (const sub of type.sub) {
+          result.fields[sub.name] = this.resolveType(sub);
+        }
+        return result;
+      }
+      case import_types3.TypeDefInfo.Si:
+        (0, import_assert3.default)(isSi2(type));
+        return this.resolveType(metadata.registry.lookup.getTypeDef(type.type));
+      case import_types3.TypeDefInfo.Compact:
+        (0, import_assert3.default)(hasSub2(type));
+        return this.resolveType(type.sub);
+      case import_types3.TypeDefInfo.Null:
+        return { type: "primitive", value: "null" };
+      case import_types3.TypeDefInfo.Plain:
+        return { type: "primitive", value: type.type };
+      case import_types3.TypeDefInfo.BTreeSet:
+      case import_types3.TypeDefInfo.Vec:
+      case import_types3.TypeDefInfo.VecFixed:
+        (0, import_assert3.default)(hasSub2(type));
+        return {
+          type: "array",
+          value: this.resolveType(type.sub),
+          length: type.length
+        };
+      case import_types3.TypeDefInfo.Tuple:
+        (0, import_assert3.default)(hasSubs2(type));
+        return {
+          type: "tuple",
+          values: type.sub.map((t) => this.resolveType(t))
+        };
+      case import_types3.TypeDefInfo.Option:
+        (0, import_assert3.default)(hasSub2(type));
+        return {
+          type: "option",
+          value: this.resolveType(type.sub)
+        };
+      case import_types3.TypeDefInfo.Result:
+        (0, import_assert3.default)(hasSubs2(type));
+        return {
+          type: "enum",
+          $name: (0, import_string3.uncapitalize)(type.typeName),
+          values: [
+            {
+              name: "Ok",
+              value: this.resolveType(type.sub[0])
+            },
+            {
+              name: "Err",
+              value: this.resolveType(type.sub[1])
+            }
+          ]
+        };
+      case import_types3.TypeDefInfo.Range:
+        (0, import_assert3.default)(hasSub2(type));
+        return {
+          type: "range",
+          value: this.resolveType(type.sub)
+        };
+      case import_types3.TypeDefInfo.RangeInclusive:
+        (0, import_assert3.default)(hasSub2(type));
+        return {
+          type: "range",
+          value: this.resolveType(type.sub)
+        };
+      case import_types3.TypeDefInfo.BTreeMap:
+        (0, import_assert3.default)(hasSubs2(type, 2));
+        return {
+          type: "map",
+          key: this.resolveType(type.sub[0]),
+          value: this.resolveType(type.sub[1])
+        };
+      default:
+        console.error(type);
+        throw new Error(`Unhandled type: ${type.info}`);
+    }
+  }
+};
+
+// src/codegen/CodeGenerator.ts
+var nameToIdentifier = (name) => name.replace(/(?:::|_)(.)/g, (_, c) => c.toUpperCase()).replace(/^./, (c) => c.toLowerCase());
+var isNull = (type) => type.type === "primitive" && type.value === "null";
+var hexString = new Code(
+  "z.string().refine((v): v is `0x${string}` => /^0x[\\da-f]*$/i.test(v), { message: 'Invalid hex string' })"
+);
+var numericString = new Code(
+  "z.string().refine((v) => /^\\d+$/.test(v), { message: 'Invalid numeric string' })"
+);
+var numberOrHex = new Code(
+  "z.union([z.number(), hexString, numericString]).transform((n) => BigInt(n))"
+);
+var accountId = new Code(
+  "z.union([hexString, z.string().regex(/^[0-9a-f]+$/).transform<`0x${string}`>((v) => `0x${v}`)]).transform((value) => ss58.encode({ data: value, ss58Format: 2112 }) as `cF${string}`)",
+  [new Identifier("* as ss58", "@chainflip/utils/ss58")]
+);
+var simpleEnum = new Code(
+  "<U extends string, T extends readonly [U, ...U[]]>(values: T) => z.object({ __kind: z.enum(values) }).transform(({ __kind }) => __kind!)"
+);
+var shortChainToLongChain = {
+  Arb: "Arbitrum",
+  Btc: "Bitcoin",
+  Eth: "Ethereum",
+  Dot: "Polkadot",
+  Sol: "Solana",
+  Hub: "Assethub"
+};
+var addressTransforms = {
+  Arb: null,
+  Btc: "Buffer.from(value.slice(2), 'hex').toString('utf8')",
+  Dot: "ss58.encode({ data: value, ss58Format: 0 })",
+  Eth: null,
+  Sol: "base58.encode(hexToBytes(value))",
+  Hub: "ss58.encode({ data: value, ss58Format: 0 })"
+};
+var addressImports = {
+  Arb: null,
+  Btc: null,
+  Dot: [["* as ss58", "@chainflip/utils/ss58"]],
+  Eth: null,
+  Sol: [
+    ["* as base58", "@chainflip/utils/base58"],
+    ["hexToBytes", "@chainflip/utils/bytes"]
+  ],
+  Hub: [["* as ss58", "@chainflip/utils/ss58"]]
+};
+function assertIsKnownChain(value) {
+  if (!(value in shortChainToLongChain)) throw new Error(`unknown chain: "${value}"`);
+}
+var CodeGenerator2 = class extends CodeGenerator {
+  generateEncodedAddressEnum(def) {
+    this.registry.types.set("hexString", hexString);
+    const dependencies = [];
+    const chains = /* @__PURE__ */ new Set();
+    const unionMembers = def.values.map((v) => {
+      assertIsKnownChain(v.name);
+      chains.add(v.name);
+      addressImports[v.name]?.forEach((i) => dependencies.push(new Identifier(...i)));
+      return `'${v.name}'`;
+    });
+    const generated = `z.object({ __kind: z.enum([${unionMembers.join(",")}]), value: hexString })
+      .transform(({ __kind, value }) => {
+        switch (__kind) {
+          ${chains.values().toArray().map(
+      (a) => `case '${a}':
+                  return { chain: '${shortChainToLongChain[a]}', address: ${addressTransforms[a] ?? "value"} } as const;`
+    ).join("\n")}
+          default: throw new Error('Unknown chain');
+        }
+      })`;
+    this.registry.types.set(def.$name, new Code(generated, dependencies));
+    return new Identifier(def.$name);
+  }
+  generatePrimitive(def) {
+    switch (def.value) {
+      case "i8":
+      case "u8":
+      case "i16":
+      case "u16":
+      case "i32":
+      case "u32":
+      case "Percent":
+      case "Permill":
+        return new Code("z.number()");
+      case "u64":
+      case "u128":
+      case "U256":
+        this.registry.types.set("numericString", numericString);
+        this.registry.types.set("hexString", hexString);
+        this.registry.types.set("numberOrHex", numberOrHex);
+        return new Identifier("numberOrHex");
+      case "AccountId32":
+        this.registry.types.set("hexString", hexString);
+        this.registry.types.set("accountId", accountId);
+        return new Identifier("accountId");
+      case "H160":
+      case "H256":
+        this.registry.types.set("hexString", hexString);
+        return new Identifier("hexString");
+      case "Call":
+        return new Code("z.unknown()");
+      case "Bytes":
+        this.registry.types.set("hexString", hexString);
+        return new Identifier("hexString");
+      case "bool":
+        return new Code("z.boolean()");
+      case "null":
+        return new Code("z.null()");
+    }
+    throw new Error(`Unsupported primitive: ${def.value}`);
+  }
+  generateEnum(def) {
+    if (this.registry.types.has(def.$name)) return new Identifier(def.$name);
+    if (def.$name === "cfChainsAddressEncodedAddress") {
+      return this.generateEncodedAddressEnum(def);
+    }
+    const isSimple = def.values.every((v) => isNull(v.value));
+    const values = def.values.filter((n) => !n.name.startsWith("__Unused"));
+    let generated;
+    const dependencies = [];
+    if (isSimple) {
+      this.registry.types.set("simpleEnum", simpleEnum);
+      generated = `simpleEnum([${values.map((v) => `'${v.name}'`).join(", ")}])`;
+    } else {
+      const members = values.map((v) => {
+        if (isNull(v.value)) {
+          return `z.object({ __kind: z.literal('${v.name}') })`;
+        }
+        if (v.value.type === "struct" && v.value.$name === void 0) {
+          const value2 = this.generateStruct({
+            ...v.value,
+            additionalFields: {
+              __kind: `z.literal('${v.name}')`
+            }
+          });
+          dependencies.push(value2);
+          return value2.toString();
+        }
+        const value = this.generateResolvedType(v.value);
+        dependencies.push(value);
+        return `z.object({ __kind: z.literal('${v.name}'), value: ${value.toString()} })`;
+      });
+      if (members.length === 1) {
+        [generated] = members;
+      } else {
+        generated = `z.discriminatedUnion('__kind', [${members.join(", ")}])`;
+      }
+    }
+    this.registry.types.set(def.$name, new Code(generated, dependencies));
+    return new Identifier(def.$name);
+  }
+  generateStruct(def) {
+    const structIdent = def.$name && nameToIdentifier(def.$name);
+    if (structIdent && this.registry.types.has(structIdent)) {
+      return new Identifier(structIdent);
+    }
+    const dependencies = [];
+    const code = new Code(
+      `z.object({ ${Object.entries(def.additionalFields ?? {}).map(([key, value]) => `${key}: ${value}`).concat(
+        Object.entries(def.fields).filter(([, value]) => !isNull(value)).map(([key, value]) => {
+          const resolvedType = this.generateResolvedType(value);
+          dependencies.push(resolvedType);
+          if (resolvedType instanceof Identifier) {
+            const identifier = resolvedType.toString();
+            if (identifier === key) return key;
+            return `${key}: ${identifier}`;
+          }
+          return `${key}: ${resolvedType.toString()}`;
+        })
+      ).join(", ")} })`,
+      dependencies
+    );
+    if (!structIdent) return code;
+    this.registry.types.set(structIdent, code);
+    return new Identifier(structIdent);
+  }
+  generateArray(def) {
+    if (def.length) {
+      if (isPrimitiveType(def.value) && def.value.value === "u8") {
+        this.registry.types.set("hexString", hexString);
+        return new Identifier("hexString");
+      }
+      const resolvedType2 = this.generateResolvedType(def.value);
+      const dependencies2 = Array.from({ length: def.length }, () => resolvedType2);
+      return new Code(`z.tuple([${dependencies2.join(", ")}])`, [resolvedType2]);
+    }
+    const resolvedType = this.generateResolvedType(def.value);
+    const dependencies = resolvedType instanceof Identifier ? [resolvedType] : [...resolvedType.dependencies];
+    return new Code(`z.array(${resolvedType.toString()})`, dependencies);
+  }
+  generateTuple(def) {
+    const dependencies = def.values.map((t) => {
+      const resolvedType = this.generateResolvedType(t);
+      return resolvedType;
+    });
+    return new Code(`z.tuple([${dependencies.join(", ")}])`, dependencies);
+  }
+  generateOption(def) {
+    const resolvedType = this.generateResolvedType(def.value);
+    return new Code(`${resolvedType.toString()}.nullish()`, [resolvedType]);
+  }
+  generateRange(def) {
+    const resolvedType = this.generateResolvedType(def.value);
+    return new Code(
+      `z.object({ start: ${resolvedType.toString()}, end: ${resolvedType.toString()} })`,
+      [resolvedType]
+    );
+  }
+  generateMap(def) {
+    const keyType = this.generateResolvedType(def.key);
+    const valueType = this.generateResolvedType(def.value);
+    return new Code(`z.array(z.tuple([${keyType.toString()}, ${valueType.toString()}]))`, [
+      keyType,
+      valueType
+    ]);
+  }
+  getParserName(palletName, itemName) {
+    return `${palletName}.${itemName}`;
+  }
+  getName(palletName, itemName) {
+    return `${palletName}::${itemName}`.replace(/(?:::|_)(.)/g, (_, c) => c.toUpperCase()).replace(/^./, (c) => c.toLowerCase());
+  }
+  getGlobalImports() {
+    return ["import { z } from 'zod';"];
+  }
+};
+
+// src/codegen/generate.ts
+async function generate(outputDir) {
+  const specVersion = 0;
+  class InMemorySpecVersionCache extends SpecVersionCache {
+    constructor() {
+      super("");
+    }
+    async persistMetadata(_specVersion, _filePath, _bytes) {
+    }
+    async write(_id, _hash, _network) {
+    }
+    fetchSpecVersion(_hash, _network) {
+      return Promise.resolve(specVersion);
+    }
+    read() {
+      return Promise.resolve({ [specVersion]: { network: "localnet" } });
+    }
+  }
+  await fs5.rm(outputDir, { recursive: true, force: true });
+  await fs5.mkdir(outputDir, { recursive: true });
+  const tmpdir2 = await fs5.mkdtemp(path5.join(os.tmpdir(), "codgen-"));
+  await new Compiler(Parser, CodeGenerator2, tmpdir2, new InMemorySpecVersionCache()).compile();
+  await fs5.rename(path5.join(tmpdir2, specVersion.toString()), outputDir);
+  await fs5.rm(tmpdir2, { recursive: true, force: true });
+}