@codama/renderers-rust 1.1.1 → 1.1.2

package/dist/index.node.mjs

@@ -76,13 +76,13 @@ import {
   getAllDefinedTypes,
   getAllInstructionsWithSubs,
   getAllPrograms,
-  isNode as isNode4,
-  isNodeFilter,
+  isNode as isNode5,
+  isNodeFilter as isNodeFilter2,
   pascalCase as pascalCase4,
   resolveNestedTypeNode as resolveNestedTypeNode2,
-  snakeCase as snakeCase3,
+  snakeCase as snakeCase4,
   structTypeNodeFromInstructionArgumentNodes,
-  VALUE_NODES
+  VALUE_NODES as VALUE_NODES2
 } from "@codama/nodes";
 import { RenderMap } from "@codama/renderers-core";
 import {
@@ -93,7 +93,7 @@ import {
   recordLinkablesOnFirstVisitVisitor,
   recordNodeStackVisitor,
   staticVisitor,
-  visit as visit3
+  visit as visit4
 } from "@codama/visitors-core";
 
 // src/getTypeManifestVisitor.ts
@@ -102,17 +102,17 @@ import {
   arrayTypeNode,
   definedTypeNode,
   fixedCountNode,
-  isNode as isNode2,
+  isNode as isNode4,
   numberTypeNode,
   parseDocs,
-  pascalCase as pascalCase2,
+  pascalCase as pascalCase3,
   prefixedCountNode,
   REGISTERED_TYPE_NODE_KINDS,
   remainderCountNode,
   resolveNestedTypeNode,
-  snakeCase as snakeCase2
+  snakeCase as snakeCase3
 } from "@codama/nodes";
-import { extendVisitor, mergeVisitor, pipe, visit } from "@codama/visitors-core";
+import { extendVisitor, mergeVisitor, pipe, visit as visit3 } from "@codama/visitors-core";
 
 // src/utils/codecs.ts
 import { getBase16Encoder, getBase58Encoder, getBase64Encoder, getUtf8Encoder } from "@solana/codecs-strings";
@@ -130,6 +130,204 @@ function getBytesFromBytesValueNode(node) {
   }
 }
 
+// src/utils/discriminatorConstant.ts
+import {
+  camelCase,
+  isNode as isNode2,
+  isNodeFilter,
+  snakeCase,
+  VALUE_NODES
+} from "@codama/nodes";
+import { visit as visit2 } from "@codama/visitors-core";
+
+// src/renderValueNodeVisitor.ts
+import {
+  arrayValueNode,
+  bytesValueNode,
+  isNode,
+  numberValueNode,
+  pascalCase
+} from "@codama/nodes";
+import { visit } from "@codama/visitors-core";
+function renderValueNode(value, getImportFrom, useStr = false) {
+  return visit(value, renderValueNodeVisitor(getImportFrom, useStr));
+}
+function renderValueNodeVisitor(getImportFrom, useStr = false) {
+  return {
+    visitArrayValue(node) {
+      const list = node.items.map((v) => visit(v, this));
+      return {
+        imports: new ImportMap().mergeWith(...list.map((c) => c.imports)),
+        render: `[${list.map((c) => c.render).join(", ")}]`
+      };
+    },
+    visitBooleanValue(node) {
+      return {
+        imports: new ImportMap(),
+        render: JSON.stringify(node.boolean)
+      };
+    },
+    visitBytesValue(node) {
+      const bytes = getBytesFromBytesValueNode(node);
+      const numbers = Array.from(bytes).map(numberValueNode);
+      return visit(arrayValueNode(numbers), this);
+    },
+    visitConstantValue(node) {
+      if (isNode(node.value, "bytesValueNode")) {
+        return visit(node.value, this);
+      }
+      if (isNode(node.type, "stringTypeNode") && isNode(node.value, "stringValueNode")) {
+        return visit(bytesValueNode(node.type.encoding, node.value.string), this);
+      }
+      if (isNode(node.type, "numberTypeNode") && isNode(node.value, "numberValueNode")) {
+        const numberManifest = visit(node.value, this);
+        const { format, endian } = node.type;
+        const byteFunction = endian === "le" ? "to_le_bytes" : "to_be_bytes";
+        numberManifest.render = `${numberManifest.render}${format}.${byteFunction}()`;
+        return numberManifest;
+      }
+      throw new Error("Unsupported constant value type.");
+    },
+    visitEnumValue(node) {
+      const imports = new ImportMap();
+      const enumName = pascalCase(node.enum.name);
+      const variantName = pascalCase(node.variant);
+      const importFrom = getImportFrom(node.enum);
+      imports.add(`${importFrom}::${enumName}`);
+      if (!node.value) {
+        return { imports, render: `${enumName}::${variantName}` };
+      }
+      const enumValue = visit(node.value, this);
+      const fields = enumValue.render;
+      return {
+        imports: imports.mergeWith(enumValue.imports),
+        render: `${enumName}::${variantName} ${fields}`
+      };
+    },
+    visitMapEntryValue(node) {
+      const mapKey = visit(node.key, this);
+      const mapValue = visit(node.value, this);
+      return {
+        imports: mapKey.imports.mergeWith(mapValue.imports),
+        render: `[${mapKey.render}, ${mapValue.render}]`
+      };
+    },
+    visitMapValue(node) {
+      const map = node.entries.map((entry) => visit(entry, this));
+      const imports = new ImportMap().add("std::collection::HashMap");
+      return {
+        imports: imports.mergeWith(...map.map((c) => c.imports)),
+        render: `HashMap::from([${map.map((c) => c.render).join(", ")}])`
+      };
+    },
+    visitNoneValue() {
+      return {
+        imports: new ImportMap(),
+        render: "None"
+      };
+    },
+    visitNumberValue(node) {
+      return {
+        imports: new ImportMap(),
+        render: node.number.toString()
+      };
+    },
+    visitPublicKeyValue(node) {
+      return {
+        imports: new ImportMap().add("solana_pubkey"),
+        render: `pubkey!("${node.publicKey}")`
+      };
+    },
+    visitSetValue(node) {
+      const set = node.items.map((v) => visit(v, this));
+      const imports = new ImportMap().add("std::collection::HashSet");
+      return {
+        imports: imports.mergeWith(...set.map((c) => c.imports)),
+        render: `HashSet::from([${set.map((c) => c.render).join(", ")}])`
+      };
+    },
+    visitSomeValue(node) {
+      const child = visit(node.value, this);
+      return {
+        ...child,
+        render: `Some(${child.render})`
+      };
+    },
+    visitStringValue(node) {
+      return {
+        imports: new ImportMap(),
+        render: useStr ? `${JSON.stringify(node.string)}` : `String::from(${JSON.stringify(node.string)})`
+      };
+    },
+    visitStructFieldValue(node) {
+      const structValue = visit(node.value, this);
+      return {
+        imports: structValue.imports,
+        render: `${node.name}: ${structValue.render}`
+      };
+    },
+    visitStructValue(node) {
+      const struct = node.fields.map((field) => visit(field, this));
+      return {
+        imports: new ImportMap().mergeWith(...struct.map((c) => c.imports)),
+        render: `{ ${struct.map((c) => c.render).join(", ")} }`
+      };
+    },
+    visitTupleValue(node) {
+      const tuple = node.items.map((v) => visit(v, this));
+      return {
+        imports: new ImportMap().mergeWith(...tuple.map((c) => c.imports)),
+        render: `(${tuple.map((c) => c.render).join(", ")})`
+      };
+    }
+  };
+}
+
+// src/utils/discriminatorConstant.ts
+function mergeFragments(fragments, merge) {
+  const imports = fragments.reduce((acc, frag) => acc.mergeWith(frag.imports), new ImportMap());
+  const render2 = merge(fragments.map((frag) => frag.render));
+  return { imports, render: render2 };
+}
+function getDiscriminatorConstants(scope) {
+  const fragments = scope.discriminatorNodes.map((node) => getDiscriminatorConstant(node, scope)).filter(Boolean);
+  return mergeFragments(fragments, (r) => r.join("\n\n"));
+}
+function getDiscriminatorConstant(discriminatorNode, scope) {
+  switch (discriminatorNode.kind) {
+    case "constantDiscriminatorNode":
+      return getConstantDiscriminatorConstant(discriminatorNode, scope);
+    case "fieldDiscriminatorNode":
+      return getFieldDiscriminatorConstant(discriminatorNode, scope);
+    default:
+      return null;
+  }
+}
+function getConstantDiscriminatorConstant(discriminatorNode, scope) {
+  const { discriminatorNodes, getImportFrom, prefix, typeManifestVisitor } = scope;
+  const index = discriminatorNodes.filter(isNodeFilter("constantDiscriminatorNode")).indexOf(discriminatorNode);
+  const suffix = index <= 0 ? "" : `_${index + 1}`;
+  const name = camelCase(`${prefix}_discriminator${suffix}`);
+  const typeManifest = visit2(discriminatorNode.constant.type, typeManifestVisitor);
+  const value = renderValueNode(discriminatorNode.constant.value, getImportFrom);
+  return getConstant(name, typeManifest, value);
+}
+function getFieldDiscriminatorConstant(discriminatorNode, scope) {
+  const { fields, prefix, getImportFrom, typeManifestVisitor } = scope;
+  const field = fields.find((f) => f.name === discriminatorNode.name);
+  if (!field || !field.defaultValue || !isNode2(field.defaultValue, VALUE_NODES)) {
+    return null;
+  }
+  const name = camelCase(`${prefix}_${discriminatorNode.name}`);
+  const typeManifest = visit2(field.type, typeManifestVisitor);
+  const value = renderValueNode(field.defaultValue, getImportFrom);
+  return getConstant(name, typeManifest, value);
+}
+function getConstant(name, typeManifest, value) {
+  const type = { imports: typeManifest.imports, render: typeManifest.type };
+  return mergeFragments([type, value], ([t, v]) => `pub const ${snakeCase(name).toUpperCase()}: ${t} = ${v};`);
+}
+
 // src/utils/linkOverrides.ts
 import { CODAMA_ERROR__UNEXPECTED_NODE_KIND, CodamaError } from "@codama/errors";
 function getImportFromFactory(overrides) {
@@ -176,7 +374,7 @@ function getImportFromFactory(overrides) {
 // src/utils/render.ts
 import { dirname as pathDirname, join } from "path";
 import { fileURLToPath } from "url";
-import { camelCase, kebabCase, pascalCase, snakeCase, titleCase } from "@codama/nodes";
+import { camelCase as camelCase2, kebabCase, pascalCase as pascalCase2, snakeCase as snakeCase2, titleCase } from "@codama/nodes";
 import nunjucks from "nunjucks";
 function rustDocblock(docs) {
   if (docs.length <= 0) return "";
@@ -188,9 +386,9 @@ var render = (template, context, options) => {
   const dirname = true ? pathDirname(fileURLToPath(import.meta.url)) : __dirname;
   const templates = false ? join(dirname, "..", "..", "public", "templates") : join(dirname, "templates");
   const env = nunjucks.configure(templates, { autoescape: false, trimBlocks: true, ...options });
-  env.addFilter("pascalCase", pascalCase);
-  env.addFilter("camelCase", camelCase);
-  env.addFilter("snakeCase", snakeCase);
+  env.addFilter("pascalCase", pascalCase2);
+  env.addFilter("camelCase", camelCase2);
+  env.addFilter("snakeCase", snakeCase2);
   env.addFilter("kebabCase", kebabCase);
   env.addFilter("titleCase", titleCase);
   env.addFilter("rustDocblock", rustDocblock);
@@ -200,8 +398,8 @@ var render = (template, context, options) => {
 // src/utils/traitOptions.ts
 import {
   assertIsNode,
-  camelCase as camelCase2,
-  isNode,
+  camelCase as camelCase3,
+  isNode as isNode3,
   isScalarEnum
 } from "@codama/nodes";
 var DEFAULT_TRAIT_OPTIONS = {
@@ -233,7 +431,7 @@ function getTraitsFromNode(node, userOptions = {}) {
     return { imports: new ImportMap(), render: "" };
   }
   const sanitizedOverrides = Object.fromEntries(
-    Object.entries(options.overrides).map(([key, value]) => [camelCase2(key), value])
+    Object.entries(options.overrides).map(([key, value]) => [camelCase3(key), value])
   );
   const nodeOverrides = sanitizedOverrides[node.name];
   const allTraits = nodeOverrides === void 0 ? getDefaultTraits(nodeType, options) : nodeOverrides;
@@ -255,9 +453,9 @@ function getTraitsFromNode(node, userOptions = {}) {
   return { imports, render: traitLines.join("") };
 }
 function getNodeType(node) {
-  if (isNode(node, ["accountNode", "instructionNode"])) return "struct";
-  if (isNode(node.type, "structTypeNode")) return "struct";
-  if (isNode(node.type, "enumTypeNode")) {
+  if (isNode3(node, ["accountNode", "instructionNode"])) return "struct";
+  if (isNode3(node.type, "structTypeNode")) return "struct";
+  if (isNode3(node.type, "enumTypeNode")) {
     return isScalarEnum(node.type) ? "scalarEnum" : "dataEnum";
   }
   return "alias";
@@ -322,8 +520,8 @@ function getTypeManifestVisitor(options) {
     ),
     (v) => extendVisitor(v, {
       visitAccount(account, { self }) {
-        parentName = pascalCase2(account.name);
-        const manifest = visit(account.data, self);
+        parentName = pascalCase3(account.name);
+        const manifest = visit3(account.data, self);
         const traits = getTraitsFromNode2(account);
         manifest.imports.mergeWith(traits.imports);
         parentName = null;
@@ -333,14 +531,14 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitArrayType(arrayType, { self }) {
-        const childManifest = visit(arrayType.item, self);
-        if (isNode2(arrayType.count, "fixedCountNode")) {
+        const childManifest = visit3(arrayType.item, self);
+        if (isNode4(arrayType.count, "fixedCountNode")) {
           return {
             ...childManifest,
             type: `[${childManifest.type}; ${arrayType.count.value}]`
           };
         }
-        if (isNode2(arrayType.count, "remainderCountNode")) {
+        if (isNode4(arrayType.count, "remainderCountNode")) {
           childManifest.imports.add("kaigan::types::RemainderVec");
           return {
             ...childManifest,
@@ -397,19 +595,19 @@ function getTypeManifestVisitor(options) {
           arraySize = prefixedCountNode(parentSize);
         }
         const arrayType = arrayTypeNode(numberTypeNode("u8"), arraySize);
-        return visit(arrayType, self);
+        return visit3(arrayType, self);
       },
       visitDefinedType(definedType, { self }) {
-        parentName = pascalCase2(definedType.name);
-        const manifest = visit(definedType.type, self);
+        parentName = pascalCase3(definedType.name);
+        const manifest = visit3(definedType.type, self);
         const traits = getTraitsFromNode2(definedType);
         manifest.imports.mergeWith(traits.imports);
         parentName = null;
-        const renderedType = isNode2(definedType.type, ["enumTypeNode", "structTypeNode"]) ? manifest.type : `pub type ${pascalCase2(definedType.name)} = ${manifest.type};`;
+        const renderedType = isNode4(definedType.type, ["enumTypeNode", "structTypeNode"]) ? manifest.type : `pub type ${pascalCase3(definedType.name)} = ${manifest.type};`;
         return { ...manifest, type: `${traits.render}${renderedType}` };
       },
       visitDefinedTypeLink(node) {
-        const pascalCaseDefinedType = pascalCase2(node.name);
+        const pascalCaseDefinedType = pascalCase3(node.name);
         const importFrom = getImportFrom(node);
         return {
           imports: new ImportMap().add(`${importFrom}::${pascalCaseDefinedType}`),
@@ -418,7 +616,7 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitEnumEmptyVariantType(enumEmptyVariantType) {
-        const name = pascalCase2(enumEmptyVariantType.name);
+        const name = pascalCase3(enumEmptyVariantType.name);
         return {
           imports: new ImportMap(),
           nestedStructs: [],
@@ -426,14 +624,14 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitEnumStructVariantType(enumStructVariantType, { self }) {
-        const name = pascalCase2(enumStructVariantType.name);
+        const name = pascalCase3(enumStructVariantType.name);
         const originalParentName = parentName;
         if (!originalParentName) {
           throw new Error("Enum struct variant type must have a parent name.");
         }
         inlineStruct = true;
-        parentName = pascalCase2(originalParentName) + name;
-        const typeManifest = visit(enumStructVariantType.struct, self);
+        parentName = pascalCase3(originalParentName) + name;
+        const typeManifest = visit3(enumStructVariantType.struct, self);
         inlineStruct = false;
         parentName = originalParentName;
         return {
@@ -442,13 +640,13 @@ function getTypeManifestVisitor(options) {
         };
       },
       visitEnumTupleVariantType(enumTupleVariantType, { self }) {
-        const name = pascalCase2(enumTupleVariantType.name);
+        const name = pascalCase3(enumTupleVariantType.name);
         const originalParentName = parentName;
         if (!originalParentName) {
           throw new Error("Enum struct variant type must have a parent name.");
         }
-        parentName = pascalCase2(originalParentName) + name;
-        const childManifest = visit(enumTupleVariantType.tuple, self);
+        parentName = pascalCase3(originalParentName) + name;
+        const childManifest = visit3(enumTupleVariantType.tuple, self);
         parentName = originalParentName;
         let derive = "";
         if (childManifest.type === "(Pubkey)") {
@@ -466,25 +664,25 @@ function getTypeManifestVisitor(options) {
         if (!originalParentName) {
           throw new Error("Enum type must have a parent name.");
         }
-        const variants = enumType.variants.map((variant) => visit(variant, self));
+        const variants = enumType.variants.map((variant) => visit3(variant, self));
         const variantNames = variants.map((variant) => variant.type).join("\n");
         const mergedManifest = mergeManifests(variants);
         return {
           ...mergedManifest,
-          type: `pub enum ${pascalCase2(originalParentName)} {
+          type: `pub enum ${pascalCase3(originalParentName)} {
 ${variantNames}
 }`
         };
       },
       visitFixedSizeType(fixedSizeType, { self }) {
         parentSize = fixedSizeType.size;
-        const manifest = visit(fixedSizeType.type, self);
+        const manifest = visit3(fixedSizeType.type, self);
         parentSize = null;
         return manifest;
       },
       visitMapType(mapType, { self }) {
-        const key = visit(mapType.key, self);
-        const value = visit(mapType.value, self);
+        const key = visit3(mapType.key, self);
+        const value = visit3(mapType.value, self);
         const mergedManifest = mergeManifests([key, value]);
         mergedManifest.imports.add("std::collections::HashMap");
         return {
@@ -510,7 +708,7 @@ ${variantNames}
         };
       },
       visitOptionType(optionType, { self }) {
-        const childManifest = visit(optionType.item, self);
+        const childManifest = visit3(optionType.item, self);
         const optionPrefix = resolveNestedTypeNode(optionType.prefix);
         if (optionPrefix.format === "u8" && optionPrefix.endian === "le") {
           return {
@@ -531,7 +729,7 @@ ${variantNames}
         throw new CodamaError2(CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE, { kind: node.kind, node });
       },
       visitSetType(setType, { self }) {
-        const childManifest = visit(setType.item, self);
+        const childManifest = visit3(setType.item, self);
         childManifest.imports.add("std::collections::HashSet");
         return {
           ...childManifest,
@@ -540,7 +738,7 @@ ${variantNames}
       },
       visitSizePrefixType(sizePrefixType, { self }) {
         parentSize = resolveNestedTypeNode(sizePrefixType.prefix);
-        const manifest = visit(sizePrefixType.type, self);
+        const manifest = visit3(sizePrefixType.type, self);
         parentSize = null;
         return manifest;
       },
@@ -559,7 +757,7 @@ ${variantNames}
             type: `[u8; ${parentSize}]`
           };
         }
-        if (isNode2(parentSize, "numberTypeNode") && parentSize.endian === "le") {
+        if (isNode4(parentSize, "numberTypeNode") && parentSize.endian === "le") {
           switch (parentSize.format) {
             case "u32":
               return {
@@ -590,14 +788,14 @@ ${variantNames}
         if (!originalParentName) {
           throw new Error("Struct field type must have a parent name.");
         }
-        parentName = pascalCase2(originalParentName) + pascalCase2(structFieldType.name);
+        parentName = pascalCase3(originalParentName) + pascalCase3(structFieldType.name);
         nestedStruct = true;
         inlineStruct = false;
-        const fieldManifest = visit(structFieldType.type, self);
+        const fieldManifest = visit3(structFieldType.type, self);
         parentName = originalParentName;
         inlineStruct = originalInlineStruct;
         nestedStruct = originalNestedStruct;
-        const fieldName = snakeCase2(structFieldType.name);
+        const fieldName = snakeCase3(structFieldType.name);
         const docblock = rustDocblock(parseDocs(structFieldType.docs));
         const resolvedNestedType = resolveNestedTypeNode(structFieldType.type);
         let derive = "";
@@ -605,9 +803,9 @@ ${variantNames}
           derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::DisplayFromStr>"))]\n';
         } else if (fieldManifest.type === "Vec<Pubkey>") {
           derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<Vec<serde_with::DisplayFromStr>>"))]\n';
-        } else if (isNode2(resolvedNestedType, "arrayTypeNode") && isNode2(resolvedNestedType.count, "fixedCountNode") && resolvedNestedType.count.value > 32) {
+        } else if (isNode4(resolvedNestedType, "arrayTypeNode") && isNode4(resolvedNestedType.count, "fixedCountNode") && resolvedNestedType.count.value > 32) {
           derive = '#[cfg_attr(feature = "serde", serde(with = "serde_big_array::BigArray"))]\n';
-        } else if (isNode2(resolvedNestedType, ["bytesTypeNode", "stringTypeNode"]) && isNode2(structFieldType.type, "fixedSizeTypeNode") && structFieldType.type.size > 32) {
+        } else if (isNode4(resolvedNestedType, ["bytesTypeNode", "stringTypeNode"]) && isNode4(structFieldType.type, "fixedSizeTypeNode") && structFieldType.type.size > 32) {
           derive = '#[cfg_attr(feature = "serde", serde(with = "serde_with::As::<serde_with::Bytes>"))]\n';
         }
         return {
@@ -620,7 +818,7 @@ ${variantNames}
         if (!originalParentName) {
           throw new Error("Struct type must have a parent name.");
         }
-        const fields = structType.fields.map((field) => visit(field, self));
+        const fields = structType.fields.map((field) => visit3(field, self));
         const fieldTypes = fields.map((field) => field.type).join("\n");
         const mergedManifest = mergeManifests(fields);
         if (nestedStruct) {
@@ -632,11 +830,11 @@ ${variantNames}
             ...mergedManifest,
             nestedStructs: [
               ...mergedManifest.nestedStructs,
-              `${nestedTraits.render}pub struct ${pascalCase2(originalParentName)} {
+              `${nestedTraits.render}pub struct ${pascalCase3(originalParentName)} {
 ${fieldTypes}
 }`
             ],
-            type: pascalCase2(originalParentName)
+            type: pascalCase3(originalParentName)
           };
         }
         if (inlineStruct) {
@@ -646,13 +844,13 @@ ${fieldTypes}
         }
         return {
           ...mergedManifest,
-          type: `pub struct ${pascalCase2(originalParentName)} {
+          type: `pub struct ${pascalCase3(originalParentName)} {
 ${fieldTypes}
 }`
         };
       },
       visitTupleType(tupleType, { self }) {
-        const items = tupleType.items.map((item) => visit(item, self));
+        const items = tupleType.items.map((item) => visit3(item, self));
         const mergedManifest = mergeManifests(items);
         return {
           ...mergedManifest,
@@ -672,149 +870,6 @@ function mergeManifests(manifests) {
   };
 }
 
-// src/renderValueNodeVisitor.ts
-import {
-  arrayValueNode,
-  bytesValueNode,
-  isNode as isNode3,
-  numberValueNode,
-  pascalCase as pascalCase3
-} from "@codama/nodes";
-import { visit as visit2 } from "@codama/visitors-core";
-function renderValueNode(value, getImportFrom, useStr = false) {
-  return visit2(value, renderValueNodeVisitor(getImportFrom, useStr));
-}
-function renderValueNodeVisitor(getImportFrom, useStr = false) {
-  return {
-    visitArrayValue(node) {
-      const list = node.items.map((v) => visit2(v, this));
-      return {
-        imports: new ImportMap().mergeWith(...list.map((c) => c.imports)),
-        render: `[${list.map((c) => c.render).join(", ")}]`
-      };
-    },
-    visitBooleanValue(node) {
-      return {
-        imports: new ImportMap(),
-        render: JSON.stringify(node.boolean)
-      };
-    },
-    visitBytesValue(node) {
-      const bytes = getBytesFromBytesValueNode(node);
-      const numbers = Array.from(bytes).map(numberValueNode);
-      return visit2(arrayValueNode(numbers), this);
-    },
-    visitConstantValue(node) {
-      if (isNode3(node.value, "bytesValueNode")) {
-        return visit2(node.value, this);
-      }
-      if (isNode3(node.type, "stringTypeNode") && isNode3(node.value, "stringValueNode")) {
-        return visit2(bytesValueNode(node.type.encoding, node.value.string), this);
-      }
-      if (isNode3(node.type, "numberTypeNode") && isNode3(node.value, "numberValueNode")) {
-        const numberManifest = visit2(node.value, this);
-        const { format, endian } = node.type;
-        const byteFunction = endian === "le" ? "to_le_bytes" : "to_be_bytes";
-        numberManifest.render = `${numberManifest.render}${format}.${byteFunction}()`;
-        return numberManifest;
-      }
-      throw new Error("Unsupported constant value type.");
-    },
-    visitEnumValue(node) {
-      const imports = new ImportMap();
-      const enumName = pascalCase3(node.enum.name);
-      const variantName = pascalCase3(node.variant);
-      const importFrom = getImportFrom(node.enum);
-      imports.add(`${importFrom}::${enumName}`);
-      if (!node.value) {
-        return { imports, render: `${enumName}::${variantName}` };
-      }
-      const enumValue = visit2(node.value, this);
-      const fields = enumValue.render;
-      return {
-        imports: imports.mergeWith(enumValue.imports),
-        render: `${enumName}::${variantName} ${fields}`
-      };
-    },
-    visitMapEntryValue(node) {
-      const mapKey = visit2(node.key, this);
-      const mapValue = visit2(node.value, this);
-      return {
-        imports: mapKey.imports.mergeWith(mapValue.imports),
-        render: `[${mapKey.render}, ${mapValue.render}]`
-      };
-    },
-    visitMapValue(node) {
-      const map = node.entries.map((entry) => visit2(entry, this));
-      const imports = new ImportMap().add("std::collection::HashMap");
-      return {
-        imports: imports.mergeWith(...map.map((c) => c.imports)),
-        render: `HashMap::from([${map.map((c) => c.render).join(", ")}])`
-      };
-    },
-    visitNoneValue() {
-      return {
-        imports: new ImportMap(),
-        render: "None"
-      };
-    },
-    visitNumberValue(node) {
-      return {
-        imports: new ImportMap(),
-        render: node.number.toString()
-      };
-    },
-    visitPublicKeyValue(node) {
-      return {
-        imports: new ImportMap().add("solana_pubkey"),
-        render: `pubkey!("${node.publicKey}")`
-      };
-    },
-    visitSetValue(node) {
-      const set = node.items.map((v) => visit2(v, this));
-      const imports = new ImportMap().add("std::collection::HashSet");
-      return {
-        imports: imports.mergeWith(...set.map((c) => c.imports)),
-        render: `HashSet::from([${set.map((c) => c.render).join(", ")}])`
-      };
-    },
-    visitSomeValue(node) {
-      const child = visit2(node.value, this);
-      return {
-        ...child,
-        render: `Some(${child.render})`
-      };
-    },
-    visitStringValue(node) {
-      return {
-        imports: new ImportMap(),
-        render: useStr ? `${JSON.stringify(node.string)}` : `String::from(${JSON.stringify(node.string)})`
-      };
-    },
-    visitStructFieldValue(node) {
-      const structValue = visit2(node.value, this);
-      return {
-        imports: structValue.imports,
-        render: `${node.name}: ${structValue.render}`
-      };
-    },
-    visitStructValue(node) {
-      const struct = node.fields.map((field) => visit2(field, this));
-      return {
-        imports: new ImportMap().mergeWith(...struct.map((c) => c.imports)),
-        render: `{ ${struct.map((c) => c.render).join(", ")} }`
-      };
-    },
-    visitTupleValue(node) {
-      const tuple = node.items.map((v) => visit2(v, this));
-      return {
-        imports: new ImportMap().mergeWith(...tuple.map((c) => c.imports)),
-        render: `(${tuple.map((c) => c.render).join(", ")})`
-      };
-    }
-  };
-}
-
 // src/getRenderMapVisitor.ts
 function getRenderMapVisitor(options = {}) {
   const linkables = new LinkableDictionary();
@@ -832,40 +887,49 @@ function getRenderMapVisitor(options = {}) {
     }),
     (v) => extendVisitor2(v, {
       visitAccount(node) {
-        const typeManifest = visit3(node, typeManifestVisitor);
+        const typeManifest = visit4(node, typeManifestVisitor);
+        const fields = resolveNestedTypeNode2(node.data).fields;
+        const discriminatorConstants = getDiscriminatorConstants({
+          discriminatorNodes: node.discriminators ?? [],
+          fields,
+          getImportFrom,
+          prefix: node.name,
+          typeManifestVisitor
+        });
         const seedsImports = new ImportMap();
         const pda = node.pda ? linkables.get([...stack.getPath(), node.pda]) : void 0;
         const pdaSeeds = pda?.seeds ?? [];
         const seeds = pdaSeeds.map((seed) => {
-          if (isNode4(seed, "variablePdaSeedNode")) {
-            const seedManifest2 = visit3(seed.type, typeManifestVisitor);
+          if (isNode5(seed, "variablePdaSeedNode")) {
+            const seedManifest2 = visit4(seed.type, typeManifestVisitor);
             seedsImports.mergeWith(seedManifest2.imports);
             const resolvedType2 = resolveNestedTypeNode2(seed.type);
             return { ...seed, resolvedType: resolvedType2, typeManifest: seedManifest2 };
           }
-          if (isNode4(seed.value, "programIdValueNode")) {
+          if (isNode5(seed.value, "programIdValueNode")) {
             return seed;
           }
-          const seedManifest = visit3(seed.type, typeManifestVisitor);
+          const seedManifest = visit4(seed.type, typeManifestVisitor);
           const valueManifest = renderValueNode(seed.value, getImportFrom, true);
           seedsImports.mergeWith(valueManifest.imports);
           const resolvedType = resolveNestedTypeNode2(seed.type);
           return { ...seed, resolvedType, typeManifest: seedManifest, valueManifest };
         });
-        const hasVariableSeeds = pdaSeeds.filter(isNodeFilter("variablePdaSeedNode")).length > 0;
-        const constantSeeds = seeds.filter(isNodeFilter("constantPdaSeedNode")).filter((seed) => !isNode4(seed.value, "programIdValueNode"));
+        const hasVariableSeeds = pdaSeeds.filter(isNodeFilter2("variablePdaSeedNode")).length > 0;
+        const constantSeeds = seeds.filter(isNodeFilter2("constantPdaSeedNode")).filter((seed) => !isNode5(seed.value, "programIdValueNode"));
         const { imports } = typeManifest;
         if (hasVariableSeeds) {
           imports.mergeWith(seedsImports);
         }
         return new RenderMap().add(
-          `accounts/${snakeCase3(node.name)}.rs`,
+          `accounts/${snakeCase4(node.name)}.rs`,
           render("accountsPage.njk", {
             account: node,
             anchorTraits,
             constantSeeds,
+            discriminatorConstants: discriminatorConstants.render,
             hasVariableSeeds,
-            imports: imports.remove(`generatedAccounts::${pascalCase4(node.name)}`).toString(dependencyMap),
+            imports: imports.mergeWith(discriminatorConstants.imports).remove(`generatedAccounts::${pascalCase4(node.name)}`).toString(dependencyMap),
             pda,
             program,
             seeds,
@@ -874,10 +938,10 @@ function getRenderMapVisitor(options = {}) {
         );
       },
       visitDefinedType(node) {
-        const typeManifest = visit3(node, typeManifestVisitor);
+        const typeManifest = visit4(node, typeManifestVisitor);
         const imports = new ImportMap().mergeWithManifest(typeManifest);
         return new RenderMap().add(
-          `types/${snakeCase3(node.name)}.rs`,
+          `types/${snakeCase4(node.name)}.rs`,
           render("definedTypesPage.njk", {
             definedType: node,
             imports: imports.remove(`generatedTypes::${pascalCase4(node.name)}`).toString(dependencyMap),
@@ -893,6 +957,13 @@ function getRenderMapVisitor(options = {}) {
             `[Rust] Accounts and args of instruction [${node.name}] have the following conflicting attributes [${accountsAndArgsConflicts.join(", ")}]. Thus, the conflicting arguments will be suffixed with "_arg". You may want to rename the conflicting attributes.`
           );
         }
+        const discriminatorConstants = getDiscriminatorConstants({
+          discriminatorNodes: node.discriminators ?? [],
+          fields: node.arguments,
+          getImportFrom,
+          prefix: node.name,
+          typeManifestVisitor
+        });
         const instructionArgs = [];
         let hasArgs = false;
         let hasOptional = false;
@@ -903,10 +974,10 @@ function getRenderMapVisitor(options = {}) {
             nestedStruct: true,
             parentName: `${pascalCase4(node.name)}InstructionData`
           });
-          const manifest = visit3(argument.type, argumentVisitor);
+          const manifest = visit4(argument.type, argumentVisitor);
           imports.mergeWith(manifest.imports);
-          const innerOptionType = isNode4(argument.type, "optionTypeNode") ? manifest.type.slice("Option<".length, -1) : null;
-          const hasDefaultValue = !!argument.defaultValue && isNode4(argument.defaultValue, VALUE_NODES);
+          const innerOptionType = isNode5(argument.type, "optionTypeNode") ? manifest.type.slice("Option<".length, -1) : null;
+          const hasDefaultValue = !!argument.defaultValue && isNode5(argument.defaultValue, VALUE_NODES2);
           let renderValue = null;
           if (hasDefaultValue) {
             const { imports: argImports, render: value } = renderValueNode(
@@ -934,16 +1005,17 @@ function getRenderMapVisitor(options = {}) {
           getTraitsFromNode: getTraitsFromNode2,
           parentName: `${pascalCase4(node.name)}InstructionData`
         });
-        const typeManifest = visit3(struct, structVisitor);
+        const typeManifest = visit4(struct, structVisitor);
         const dataTraits = getTraitsFromNode2(node);
         imports.mergeWith(dataTraits.imports);
         return new RenderMap().add(
-          `instructions/${snakeCase3(node.name)}.rs`,
+          `instructions/${snakeCase4(node.name)}.rs`,
           render("instructionsPage.njk", {
             dataTraits: dataTraits.render,
+            discriminatorConstants: discriminatorConstants.render,
             hasArgs,
             hasOptional,
-            imports: imports.remove(`generatedInstructions::${pascalCase4(node.name)}`).toString(dependencyMap),
+            imports: imports.mergeWith(discriminatorConstants.imports).remove(`generatedInstructions::${pascalCase4(node.name)}`).toString(dependencyMap),
             instruction: node,
             instructionArgs,
             program,
@@ -953,14 +1025,14 @@ function getRenderMapVisitor(options = {}) {
       },
       visitProgram(node, { self }) {
         program = node;
-        const renderMap = new RenderMap().mergeWith(...node.accounts.map((account) => visit3(account, self))).mergeWith(...node.definedTypes.map((type) => visit3(type, self))).mergeWith(
+        const renderMap = new RenderMap().mergeWith(...node.accounts.map((account) => visit4(account, self))).mergeWith(...node.definedTypes.map((type) => visit4(type, self))).mergeWith(
           ...getAllInstructionsWithSubs(node, {
             leavesOnly: !renderParentInstructions
-          }).map((ix) => visit3(ix, self))
+          }).map((ix) => visit4(ix, self))
         );
         if (node.errors.length > 0) {
           renderMap.add(
-            `errors/${snakeCase3(node.name)}.rs`,
+            `errors/${snakeCase4(node.name)}.rs`,
             render("errorsPage.njk", {
               errors: node.errors,
               imports: new ImportMap().toString(dependencyMap),
@@ -1006,7 +1078,7 @@ function getRenderMapVisitor(options = {}) {
         if (definedTypesToExport.length > 0) {
           map.add("types/mod.rs", render("definedTypesMod.njk", ctx));
         }
-        return map.add("mod.rs", render("rootMod.njk", ctx)).mergeWith(...getAllPrograms(node).map((p) => visit3(p, self)));
+        return map.add("mod.rs", render("rootMod.njk", ctx)).mergeWith(...getAllPrograms(node).map((p) => visit4(p, self)));
       }
     }),
     (v) => recordNodeStackVisitor(v, stack),
@@ -1025,14 +1097,14 @@ function getConflictsForInstructionAccountsAndArgs(instruction) {
 // src/renderVisitor.ts
 import { logError, logWarn as logWarn2 } from "@codama/errors";
 import { deleteDirectory, writeRenderMapVisitor } from "@codama/renderers-core";
-import { rootNodeVisitor, visit as visit4 } from "@codama/visitors-core";
+import { rootNodeVisitor, visit as visit5 } from "@codama/visitors-core";
 import { spawnSync } from "child_process";
 function renderVisitor(path, options = {}) {
   return rootNodeVisitor((root) => {
     if (options.deleteFolderBeforeRendering ?? true) {
       deleteDirectory(path);
     }
-    visit4(root, writeRenderMapVisitor(getRenderMapVisitor(options), path));
+    visit5(root, writeRenderMapVisitor(getRenderMapVisitor(options), path));
     if (options.formatCode) {
       if (options.crateFolder) {
         const toolchain = options.toolchain ?? "+stable";