codama-renderers-dart 0.4.3 → 0.5.1

package/dist/index.node.js

@@ -3,18 +3,76 @@ import { join, dirname, posix } from 'path';
 import { staticVisitor, extendVisitor, visit, NodeStack, LinkableDictionary, pipe, recordNodeStackVisitor, recordLinkablesOnFirstVisitVisitor, rootNodeVisitor } from '@codama/visitors-core';
 import { createRenderMap, addToRenderMap, mergeRenderMaps, deleteDirectory } from '@codama/renderers-core';
 import { execSync } from 'child_process';
-import { resolveNestedTypeNode } from '@codama/nodes';
+import { resolveNestedTypeNode, getAllInstructionsWithSubs } from '@codama/nodes';
 import { CodamaError, CODAMA_ERROR__UNEXPECTED_NODE_KIND } from '@codama/errors';
 
 // src/visitors/renderVisitor.ts
 function formatDartDirectory(dir) {
-  try {
-    execSync(`dart format --fix "${dir}"`, {
-      encoding: "utf-8",
-      timeout: 6e4,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch {
+  execSync(`dart format "${dir}"`, {
+    encoding: "utf-8",
+    timeout: 6e4,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+
+// src/utils/normalizeRootNode.ts
+function normalizeRootNode(root) {
+  return normalizeNode(root);
+}
+function normalizeNode(value) {
+  if (Array.isArray(value)) {
+    return value.map(normalizeNode);
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  const normalized = Object.fromEntries(
+    Object.entries(value).map(([key, child]) => [key, normalizeNode(child)])
+  );
+  switch (normalized.kind) {
+    case "rootNode":
+      setEmptyCollection(normalized, "additionalPrograms");
+      break;
+    case "programNode":
+      setEmptyCollection(normalized, "accounts");
+      setEmptyCollection(normalized, "constants");
+      setEmptyCollection(normalized, "definedTypes");
+      setEmptyCollection(normalized, "errors");
+      setEmptyCollection(normalized, "events");
+      setEmptyCollection(normalized, "instructions");
+      setEmptyCollection(normalized, "pdas");
+      break;
+    case "instructionNode":
+      setEmptyCollection(normalized, "accounts");
+      setEmptyCollection(normalized, "arguments");
+      break;
+    case "pdaNode":
+      setEmptyCollection(normalized, "seeds");
+      break;
+    case "structTypeNode":
+      setEmptyCollection(normalized, "fields");
+      break;
+    case "enumTypeNode":
+      setEmptyCollection(normalized, "variants");
+      break;
+    case "tupleTypeNode":
+      setEmptyCollection(normalized, "items");
+      break;
+    case "hiddenPrefixTypeNode":
+      setEmptyCollection(normalized, "prefix");
+      break;
+    case "hiddenSuffixTypeNode":
+      setEmptyCollection(normalized, "suffix");
+      break;
+  }
+  return normalized;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function setEmptyCollection(record, key) {
+  if (record[key] === void 0) {
+    record[key] = [];
   }
 }
 
@@ -46,7 +104,7 @@ function createDartNameApi() {
     errorConstant: (programName, errorName) => `${camelCase(programName)}Error${pascalCase(errorName)}`,
     errorMessageFunction: (name) => `get${pascalCase(name)}ErrorMessage`,
     enumVariant: (name) => camelCase(name),
-    sealedClassVariant: (_parentName, variantName) => pascalCase(variantName),
+    sealedClassVariant: (parentName, variantName) => `${pascalCase(parentName)}${pascalCase(variantName)}`,
     isTypeFunction: (name) => `is${pascalCase(name)}`,
     fileName: (name) => snakeCase(name),
     discriminatorConstant: (name) => `${camelCase(name)}Discriminator`
@@ -120,11 +178,16 @@ var DartImportMap = class {
     const uris = /* @__PURE__ */ new Set();
     for (const module of this._imports) {
       if (module in internalMap) {
-        uris.add(internalMap[module]);
+        const uri = internalMap[module];
+        if (uri) {
+          uris.add(uri);
+        }
       } else if (module in DART_EXTERNAL_PACKAGE_MAP) {
         uris.add(DART_EXTERNAL_PACKAGE_MAP[module]);
-      } else {
+      } else if (isRawDartImportUri(module)) {
         uris.add(module);
+      } else {
+        throw new Error(`Unresolved Dart import module "${module}"`);
       }
     }
     return [...uris].sort((a, b) => {
@@ -153,6 +216,9 @@ var DartImportMap = class {
     return lines.join("\n");
   }
 };
+function isRawDartImportUri(module) {
+  return module.startsWith("dart:") || module.startsWith("package:") || module.endsWith(".dart") && !module.includes(":");
+}
 
 // src/utils/fragment.ts
 function fragment(strings, ...values) {
@@ -196,17 +262,6 @@ function use(typeName, module) {
   return { content: typeName, imports };
 }
 
-// src/utils/typeManifest.ts
-function emptyTypeManifest() {
-  return {
-    type: emptyFragment(),
-    encoder: emptyFragment(),
-    decoder: emptyFragment(),
-    value: emptyFragment(),
-    isEnum: false
-  };
-}
-
 // src/utils/wellKnownAddresses.ts
 var WELL_KNOWN_ADDRESSES = /* @__PURE__ */ new Map([
   // Agave / Solana native programs
@@ -244,10 +299,10 @@ var WELL_KNOWN_ADDRESSES = /* @__PURE__ */ new Map([
   ["Sysvar1111111111111111111111111111111111111", "sysvarOwnerAddress"],
   // SPL programs
   ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", "tokenProgramAddress"],
-  ["TokenzQdBNb4qyze1S1U9AHB8MGXmNK1REkTPT5Z3Y", "token2022ProgramAddress"],
-  ["ATokenGPvbdGVxr1b2hvZbsiqW5xWH25ef7s3c8BnQKu", "associatedTokenProgramAddress"],
-  ["Memo1UhkJRfRhVq1sR7Y7Nto1s3J2mXTT3L6Wk4K2m6", "memoProgramAddress"],
-  ["MemoSq4gqABXKKYWVqKkV3m3kb1cTR7F2UMy9r6kFNK", "memoLegacyProgramAddress"],
+  ["TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb", "token2022ProgramAddress"],
+  ["ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL", "associatedTokenProgramAddress"],
+  ["MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr", "memoProgramAddress"],
+  ["Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo", "memoLegacyProgramAddress"],
   // Metaplex programs
   ["metaqbxxU9qX8rZXkmUJ7haCrXXz2W1PSUq1Rn3E1od", "tokenMetadataProgramAddress"],
   ["BGUMAp9V1mQ2KV8t34L5u3gZsXYZaYDBdKkc1xYk1qA1", "mplBubblegumProgramAddress"],
@@ -261,6 +316,207 @@ var WELL_KNOWN_ADDRESSES = /* @__PURE__ */ new Map([
   ["Es9vMFrzaCERm6YKXx6bqKr1Rmd9b5v3J8rM5e4rfF4", "usdtAddress"]
 ]);
 
+// src/utils/valueNodes.ts
+function getDartValueFragment(value, dartType) {
+  switch (value.kind) {
+    case "numberValueNode":
+      return fragmentFromString(
+        dartType === "BigInt" ? `BigInt.from(${value.number})` : String(value.number)
+      );
+    case "booleanValueNode":
+      return fragmentFromString(String(value.boolean));
+    case "stringValueNode":
+      return fragmentFromString(toDartStringLiteral(value.string));
+    case "noneValueNode":
+      return fragmentFromString("null");
+    case "bytesValueNode": {
+      if (value.encoding !== "base16") {
+        throw new Error(
+          `Unsupported deterministic bytes encoding: ${value.encoding}`
+        );
+      }
+      const clean = value.data.replace(/^0x/, "");
+      if (clean.length % 2 !== 0 || !/^[0-9a-f]*$/i.test(clean)) {
+        throw new Error(`Invalid hexadecimal bytes value: ${value.data}`);
+      }
+      const bytes = clean.match(/.{2}/g)?.map((byte) => `0x${byte}`) ?? [];
+      return fragment`${use("Uint8List", "dartTypedData")}.fromList([${fragmentFromString(bytes.join(", "))}])`;
+    }
+    case "publicKeyValueNode": {
+      const wellKnownName = WELL_KNOWN_ADDRESSES.get(value.publicKey);
+      return wellKnownName ? fragment`${use(wellKnownName, "solanaAddresses")}` : fragment`${use("Address", "solanaAddresses")}(${fragmentFromString(toDartStringLiteral(value.publicKey))})`;
+    }
+    default:
+      throw new Error(
+        `Unsupported deterministic Dart value node: ${value.kind}`
+      );
+  }
+}
+function isConstDartValueNode(value) {
+  switch (value.kind) {
+    case "numberValueNode":
+    case "booleanValueNode":
+    case "stringValueNode":
+    case "noneValueNode":
+    case "publicKeyValueNode":
+      return true;
+    default:
+      return false;
+  }
+}
+function toDartStringLiteral(value) {
+  return `'${value.replaceAll("\\", "\\\\").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("	", "\\t").replaceAll("\b", "\\b").replaceAll("\f", "\\f").replaceAll("$", "\\$").replaceAll("'", "\\'")}'`;
+}
+
+// src/utils/discriminators.ts
+function getDiscriminatorValidationFragment(node, scope) {
+  const discriminators = node.discriminators ?? [];
+  if (discriminators.length === 0) return emptyFragment();
+  const fields = getDiscriminatorFields(node);
+  const fragments = discriminators.map((discriminator) => {
+    switch (discriminator.kind) {
+      case "constantDiscriminatorNode":
+        return getConstantValidationFragment(
+          discriminator.constant,
+          discriminator.offset,
+          scope
+        );
+      case "fieldDiscriminatorNode": {
+        const field = fields.find(
+          (candidate) => candidate.name === discriminator.name
+        );
+        if (field?.defaultValue == null) {
+          throw new Error(
+            `Field discriminator "${discriminator.name}" on ${node.kind} "${node.name}" must reference a field with a default value.`
+          );
+        }
+        return getConstantValidationFragment(
+          {
+            type: field.type,
+            value: field.defaultValue
+          },
+          discriminator.offset,
+          scope
+        );
+      }
+      case "sizeDiscriminatorNode": {
+        if (!Number.isSafeInteger(discriminator.size) || discriminator.size < 0) {
+          throw new Error(
+            `Discriminator size must be a non-negative safe integer, got ${discriminator.size}.`
+          );
+        }
+        return fragment`if (bytes.length - offset != ${fragmentFromString(String(discriminator.size))}) {
+  throw ${use("SolanaError", "solanaErrors")}(
+    ${use("SolanaErrorCode", "solanaErrors")}.codecsInvalidByteLength,
+    {
+      'codecDescription': '${fragmentFromString(node.name)} discriminator',
+      'expected': ${fragmentFromString(String(discriminator.size))},
+      'bytesLength': bytes.length - offset,
+    },
+  );
+}`;
+      }
+    }
+  });
+  return mergeFragments(fragments, (contents) => contents.join("\n"));
+}
+function getConstantValidationFragment(constant, discriminatorOffset, scope) {
+  if (!Number.isSafeInteger(discriminatorOffset) || discriminatorOffset < 0) {
+    throw new Error(
+      `Discriminator offset must be a non-negative safe integer, got ${discriminatorOffset}.`
+    );
+  }
+  const manifest = visit(constant.type, scope.typeManifestVisitor);
+  const value = getDartValueFragment(
+    constant.value,
+    manifest.type.content
+  );
+  return fragment`${use("getConstantDecoder", "solanaCodecsDataStructures")}(
+  ${manifest.encoder}.encode(${value}),
+).read(bytes, offset + ${fragmentFromString(String(discriminatorOffset))});`;
+}
+function getDiscriminatorFields(node) {
+  if (node.kind === "accountNode") {
+    return resolveNestedTypeNode(node.data).fields ?? [];
+  }
+  return (node.arguments ?? []).map(
+    (argument) => ({
+      ...argument,
+      kind: "structFieldTypeNode"
+    })
+  );
+}
+
+// src/utils/exactDecoder.ts
+function getTopLevelDecoderFragment({
+  typeName,
+  description,
+  discriminatorValidation,
+  fromMapFields,
+  requireExactConsumption
+}) {
+  const validation = discriminatorValidation.content ? `    ${discriminatorValidation.content.replaceAll("\n", "\n    ")}
+` : "";
+  const consumptionCheck = requireExactConsumption ? `    if (newOffset != bytes.length) {
+      throwInvalidByteLength(newOffset - offset, bytes.length - offset);
+    }
+` : "";
+  const fixedSizeCheck = requireExactConsumption ? "bytesLength != structDecoder.fixedSize" : "bytesLength < structDecoder.fixedSize";
+  const result = fragment`  Never throwInvalidByteLength(int expected, int bytesLength) {
+    throw ${use("SolanaError", "solanaErrors")}(
+      ${use("SolanaErrorCode", "solanaErrors")}.codecsInvalidByteLength,
+      {
+        'codecDescription': '${fragmentFromString(description)}',
+        'expected': expected,
+        'bytesLength': bytesLength,
+      },
+    );
+  }
+
+  (${fragmentFromString(typeName)}, int) readTopLevel(Uint8List bytes, int offset) {
+${fragmentFromString(validation)}    final (map, newOffset) = structDecoder.read(bytes, offset);
+${fragmentFromString(consumptionCheck)}
+    return (
+      ${fragmentFromString(typeName)}(
+${fragmentFromString(fromMapFields)}
+      ),
+      newOffset,
+    );
+  }
+
+  return switch (structDecoder) {
+    ${use("FixedSizeDecoder", "solanaCodecsCore")}<Map<String, Object?>>() =>
+      ${use("FixedSizeDecoder", "solanaCodecsCore")}<${fragmentFromString(typeName)}>(
+        fixedSize: structDecoder.fixedSize,
+        read: (bytes, offset) {
+          final bytesLength = bytes.length - offset;
+          if (${fragmentFromString(fixedSizeCheck)}) {
+            throwInvalidByteLength(structDecoder.fixedSize, bytesLength);
+          }
+          return readTopLevel(bytes, offset);
+        },
+      ),
+    ${use("VariableSizeDecoder", "solanaCodecsCore")}<Map<String, Object?>>() =>
+      ${use("VariableSizeDecoder", "solanaCodecsCore")}<${fragmentFromString(typeName)}>(
+        read: readTopLevel,
+        maxSize: structDecoder.maxSize,
+      ),
+  };`;
+  result.imports.mergeWith(discriminatorValidation.imports);
+  return result;
+}
+
+// src/utils/typeManifest.ts
+function emptyTypeManifest() {
+  return {
+    type: emptyFragment(),
+    encoder: emptyFragment(),
+    decoder: emptyFragment(),
+    value: emptyFragment(),
+    isEnum: false
+  };
+}
+
 // src/visitors/getTypeManifestVisitor.ts
 function getTypeManifestVisitor(input) {
   const { nameApi, linkables, nonScalarEnums = [] } = input;
@@ -402,17 +658,23 @@ function getTypeManifestVisitor(input) {
     },
     visitArrayType(node, { self }) {
       const itemManifest = visit(node.item, self);
-      const sizeExpr = getArraySizeExpression(node);
+      const encoderSizeExpr = getArraySizeExpression(node, "Encoder");
+      const decoderSizeExpr = getArraySizeExpression(node, "Decoder");
+      const itemType = fragmentFromString(itemManifest.type.content);
+      const itemEncoder = fragment`${use(
+        "transformEncoder",
+        "solanaCodecsCore"
+      )}(${itemManifest.encoder}, (${itemType} value) => value)`;
       return {
         type: fragment`List<${itemManifest.type}>`,
         encoder: fragment`${use(
           "getArrayEncoder",
           "solanaCodecsDataStructures"
-        )}(${itemManifest.encoder}${sizeExpr})`,
+        )}<${itemType}>(${itemEncoder}${encoderSizeExpr})`,
         decoder: fragment`${use(
           "getArrayDecoder",
           "solanaCodecsDataStructures"
-        )}(${itemManifest.decoder}${sizeExpr})`,
+        )}(${itemManifest.decoder}${decoderSizeExpr})`,
         value: emptyTypeManifest().value,
         isEnum: false
       };
@@ -420,40 +682,42 @@ function getTypeManifestVisitor(input) {
     visitMapType(node, { self }) {
       const keyManifest = visit(node.key, self);
       const valueManifest = visit(node.value, self);
-      const sizeExpr = getMapSizeExpression(node);
+      const encoderSizeExpr = getMapSizeExpression(node, "Encoder");
+      const decoderSizeExpr = getMapSizeExpression(node, "Decoder");
       return {
         type: fragment`Map<${keyManifest.type}, ${valueManifest.type}>`,
         encoder: fragment`${use(
           "getMapEncoder",
           "solanaCodecsDataStructures"
-        )}(${keyManifest.encoder}, ${valueManifest.encoder}${sizeExpr})`,
+        )}(${keyManifest.encoder}, ${valueManifest.encoder}${encoderSizeExpr})`,
         decoder: fragment`${use(
           "getMapDecoder",
           "solanaCodecsDataStructures"
-        )}(${keyManifest.decoder}, ${valueManifest.decoder}${sizeExpr})`,
+        )}(${keyManifest.decoder}, ${valueManifest.decoder}${decoderSizeExpr})`,
         value: emptyTypeManifest().value,
         isEnum: false
       };
     },
     visitSetType(node, { self }) {
       const itemManifest = visit(node.item, self);
-      const sizeExpr = getSetSizeExpression(node);
+      const encoderSizeExpr = getSetSizeExpression(node, "Encoder");
+      const decoderSizeExpr = getSetSizeExpression(node, "Decoder");
       return {
         type: fragment`Set<${itemManifest.type}>`,
         encoder: fragment`${use(
           "getSetEncoder",
           "solanaCodecsDataStructures"
-        )}(${itemManifest.encoder}${sizeExpr})`,
+        )}(${itemManifest.encoder}${encoderSizeExpr})`,
         decoder: fragment`${use(
           "getSetDecoder",
           "solanaCodecsDataStructures"
-        )}(${itemManifest.decoder}${sizeExpr})`,
+        )}(${itemManifest.decoder}${decoderSizeExpr})`,
         value: emptyTypeManifest().value,
         isEnum: false
       };
     },
     visitTupleType(node, { self }) {
-      const itemManifests = node.items.map((item) => visit(item, self));
+      const itemManifests = (node.items ?? []).map((item) => visit(item, self));
       const typeList = itemManifests.map((m) => m.type.content).join(", ");
       const encoderList = itemManifests.map((m) => m.encoder);
       const decoderList = itemManifests.map((m) => m.decoder);
@@ -486,8 +750,9 @@ function getTypeManifestVisitor(input) {
       };
     },
     visitStructType(node, { self }) {
-      const fields = node.fields.map((f) => visit(f, self));
-      const fieldNames = node.fields.map((f) => f.name);
+      const nodeFields = node.fields ?? [];
+      const fields = nodeFields.map((f) => visit(f, self));
+      const fieldNames = nodeFields.map((f) => f.name);
       const typeStr = "Map<String, Object?>";
       const encoderFields = fields.map((f, i) => `('${fieldNames[i]}', ${f.encoder.content})`).join(", ");
       const encoderFrag = fragment`${use(
@@ -517,7 +782,7 @@ function getTypeManifestVisitor(input) {
       return visit(node.type, self);
     },
     visitEnumType(node, { self }) {
-      const isScalar = node.variants.every(
+      const isScalar = (node.variants ?? []).every(
         (v) => v.kind === "enumEmptyVariantTypeNode"
       );
       if (isScalar) {
@@ -609,7 +874,7 @@ function getTypeManifestVisitor(input) {
         encoder: fragment`${use(
           "fixEncoderSize",
           "solanaCodecsCore"
-        )}(${innerManifest.encoder}, ${fragmentFromString(String(node.size))})`,
+        )}(${innerManifest.encoder}, ${fragmentFromString(String(node.size))}, allowTruncation: false)`,
         decoder: fragment`${use(
           "fixDecoderSize",
           "solanaCodecsCore"
@@ -623,9 +888,10 @@ function getTypeManifestVisitor(input) {
       const bigIntFormats = /* @__PURE__ */ new Set(["u64", "u128", "i64", "i128"]);
       let prefixManifest;
       if (node.prefix.kind === "numberTypeNode" && bigIntFormats.has(node.prefix.format)) {
+        const codecName = getNumberCodecName(node.prefix.format);
         prefixManifest = {
-          encoder: fragment`${use("getU32Encoder", "solanaCodecsNumbers")}()`,
-          decoder: fragment`${use("getU32Decoder", "solanaCodecsNumbers")}()`
+          encoder: fragment`transformEncoder(${use(`get${codecName}Encoder`, "solanaCodecsNumbers")}(), (size) => BigInt.from(size))`,
+          decoder: fragment`transformDecoder(${use(`get${codecName}Decoder`, "solanaCodecsNumbers")}(), (size, _, __) => size.toInt())`
         };
       } else {
         prefixManifest = visit(node.prefix, self);
@@ -646,7 +912,7 @@ function getTypeManifestVisitor(input) {
     },
     visitHiddenPrefixType(node, { self }) {
       const innerManifest = visit(node.type, self);
-      const prefixes = node.prefix.map((p) => getHiddenAffixManifest(p, self));
+      const prefixes = (node.prefix ?? []).map((p) => getHiddenAffixManifest(p, self));
       const prefixEncoders = prefixes.map((p) => p.encoder.content).join(", ");
       const prefixDecoders = prefixes.map((p) => p.decoder.content).join(", ");
       const encoderFrag = fragment`${use(
@@ -673,7 +939,7 @@ function getTypeManifestVisitor(input) {
     },
     visitHiddenSuffixType(node, { self }) {
       const innerManifest = visit(node.type, self);
-      const suffixes = node.suffix.map((s) => getHiddenAffixManifest(s, self));
+      const suffixes = (node.suffix ?? []).map((s) => getHiddenAffixManifest(s, self));
       const suffixEncoders = suffixes.map((s) => s.encoder.content).join(", ");
       const suffixDecoders = suffixes.map((s) => s.decoder.content).join(", ");
       const encoderFrag = fragment`${use(
@@ -812,7 +1078,7 @@ function getNumberCodecExpression(format, codecType) {
   const name = getNumberCodecName(format);
   return `get${name}${codecType}()`;
 }
-function getArraySizeExpression(node) {
+function getArraySizeExpression(node, codecType) {
   if (!("count" in node) || !node.count) return "";
   const count = node.count;
   switch (count.kind) {
@@ -825,13 +1091,13 @@ function getArraySizeExpression(node) {
       if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
         return "";
       }
-      return `, size: PrefixedArraySize(get${getNumberCodecName(resolvedPrefix.format)}Encoder())`;
+      return `, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix.format, codecType)})`;
     }
     default:
       return "";
   }
 }
-function getMapSizeExpression(node) {
+function getMapSizeExpression(node, codecType) {
   if (!("count" in node) || !node.count) return "";
   const count = node.count;
   switch (count.kind) {
@@ -844,13 +1110,13 @@ function getMapSizeExpression(node) {
       if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
         return "";
       }
-      return `, size: PrefixedArraySize(get${getNumberCodecName(resolvedPrefix.format)}Encoder())`;
+      return `, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix.format, codecType)})`;
     }
     default:
       return "";
   }
 }
-function getSetSizeExpression(node) {
+function getSetSizeExpression(node, codecType) {
   if (!("count" in node) || !node.count) return "";
   const count = node.count;
   switch (count.kind) {
@@ -863,7 +1129,7 @@ function getSetSizeExpression(node) {
       if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
         return "";
       }
-      return `, size: PrefixedArraySize(get${getNumberCodecName(resolvedPrefix.format)}Encoder())`;
+      return `, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix.format, codecType)})`;
     }
     default:
       return "";
@@ -960,19 +1226,52 @@ function hexToBytes(hex) {
 function getAccountPageFragment(node, scope) {
   const name = node.name;
   const typeName = scope.nameApi.dataType(name);
-  const dataNode = resolveNestedTypeNode(node.data);
-  const fields = dataNode.fields;
+  const fields = resolveNestedTypeNode(node.data).fields ?? [];
   const fieldManifests = fields.map((f) => ({
     field: f,
     manifest: visit(f.type, scope.typeManifestVisitor)
   }));
+  const omittedFields = fields.filter(isOmittedDefaultField);
+  const constructorFields = fields.filter(
+    (field) => !isOmittedDefaultField(field)
+  );
+  const forcedFields = /* @__PURE__ */ new Set([
+    ...omittedFields,
+    ...fields.filter((field) => isFieldDiscriminator(field, node))
+  ]);
+  const fieldDefaults = new Map(
+    fieldManifests.flatMap(({ field, manifest }) => {
+      if (!forcedFields.has(field) || field.defaultValue == null) return [];
+      return [
+        [
+          field,
+          getDartValueFragment(field.defaultValue, manifest.type.content)
+        ]
+      ];
+    })
+  );
+  for (const field of forcedFields) {
+    if (!fieldDefaults.has(field)) {
+      throw new Error(
+        `Forced field "${field.name}" on account "${node.name}" must have a deterministic default value.`
+      );
+    }
+  }
   const fieldDecls = fieldManifests.map(({ field: f, manifest }) => {
     return `  final ${manifest.type.content} ${camelCase(f.name)};`;
   }).join("\n");
-  const ctorParams = fields.map((f) => `    required this.${camelCase(f.name)},`).join("\n");
-  const ctorSignature = fields.length === 0 ? `const ${typeName}();` : `const ${typeName}({
+  const ctorParams = constructorFields.map((f) => `    required this.${camelCase(f.name)},`).join("\n");
+  const ctorInitializers = omittedFields.map((field) => {
+    const fieldName = camelCase(field.name);
+    return `${fieldName} = ${fieldDefaults.get(field).content}`;
+  }).join(",\n      ");
+  const ctorKeyword = omittedFields.every(
+    (field) => isConstDartValueNode(field.defaultValue)
+  ) ? "const " : "";
+  const ctorSignature = constructorFields.length === 0 ? `${ctorKeyword}${typeName}()${ctorInitializers ? ` : ${ctorInitializers}` : ""};` : `${ctorKeyword}${typeName}({
 ${ctorParams}
-  });`;
+  })${ctorInitializers ? ` :
+      ${ctorInitializers}` : ""};`;
   const eqChecks = fields.length === 0 ? "true" : fields.map(
     (f) => `${camelCase(f.name)} == other.${camelCase(f.name)}`
   ).join(" &&\n          ");
@@ -987,10 +1286,11 @@ ${ctorParams}
   const decFields = fieldManifests.map(({ field: f, manifest }) => {
     return `    ('${f.name}', ${manifest.decoder.content}),`;
   }).join("\n");
-  const toMapFields = fields.map(
-    (f) => `      '${f.name}': value.${camelCase(f.name)},`
-  ).join("\n");
-  const fromMapFields = fieldManifests.map(({ field: f, manifest }) => {
+  const toMapFields = fields.map((f) => {
+    const value = forcedFields.has(f) ? fieldDefaults.get(f).content : `value.${camelCase(f.name)}`;
+    return `      '${f.name}': ${value},`;
+  }).join("\n");
+  const fromMapFields = fieldManifests.filter(({ field }) => !isOmittedDefaultField(field)).map(({ field: f, manifest }) => {
     const typeStr = manifest.type.content;
     const isNullable = typeStr.endsWith("?");
     const accessor = isNullable ? `map['${f.name}']` : `map['${f.name}']!`;
@@ -1004,6 +1304,19 @@ ${ctorParams}
 /// The size of the [${fragmentFromString(typeName)}] account data in bytes.
 const int ${fragmentFromString(scope.nameApi.accountSizeConstant(name))} = ${fragmentFromString(String(node.size))};` : emptyFragment();
   const discFragment = getDiscriminatorConstantsFragment(node, scope);
+  const discriminatorValidation = getDiscriminatorValidationFragment(
+    node,
+    scope
+  );
+  const topLevelDecoder = getTopLevelDecoderFragment({
+    typeName,
+    description: `${name} account decoder`,
+    discriminatorValidation,
+    fromMapFields,
+    requireExactConsumption: (node.discriminators ?? []).some(
+      (discriminator) => discriminator.kind === "sizeDiscriminatorNode"
+    )
+  });
   const parts = [
     fragment`// Auto-generated. Do not edit.
 // ignore_for_file: type=lint
@@ -1063,12 +1376,7 @@ Decoder<${fragmentFromString(typeName)}> ${fragmentFromString(decoderName)}() {
 ${fragmentFromString(decFields)}
   ]);
 
-  return transformDecoder(
-    structDecoder,
-    (Map<String, Object?> map, Uint8List bytes, int offset) => ${fragmentFromString(typeName)}(
-${fragmentFromString(fromMapFields)}
-    ),
-  );
+${topLevelDecoder}
 }
 
 Codec<${fragmentFromString(typeName)}, ${fragmentFromString(typeName)}> ${fragmentFromString(codecName)}() {
@@ -1084,8 +1392,19 @@ Account<${fragmentFromString(typeName)}> ${fragmentFromString(decodeFnName)}(Enc
     result.imports.mergeWith(manifest.decoder.imports);
     result.imports.mergeWith(manifest.type.imports);
   }
+  for (const defaultValue of fieldDefaults.values()) {
+    result.imports.mergeWith(defaultValue.imports);
+  }
   return result;
 }
+function isOmittedDefaultField(field) {
+  return field.defaultValue != null && field.defaultValueStrategy === "omitted";
+}
+function isFieldDiscriminator(field, node) {
+  return (node.discriminators ?? []).some(
+    (discriminator) => discriminator.kind === "fieldDiscriminatorNode" && discriminator.name === field.name
+  );
+}
 
 // src/fragments/errorPage.ts
 function getErrorPageFragment(programNode, scope) {
@@ -1146,7 +1465,7 @@ function getIndexPageFragment(fileNames, relativePath = "") {
       "// Auto-generated. Do not edit.\n// ignore_for_file: type=lint\n"
     );
   }
-  const exports$1 = fileNames.sort().map((f) => {
+  const exports = fileNames.sort().map((f) => {
     const path = relativePath ? `${relativePath}/${f}` : f;
     return `export '${path}';`;
   }).join("\n");
@@ -1154,17 +1473,17 @@ function getIndexPageFragment(fileNames, relativePath = "") {
     `// Auto-generated. Do not edit.
 // ignore_for_file: type=lint
 
-${exports$1}
+${exports}
 `
   );
 }
 function getRootIndexPageFragment(categories) {
-  const exports$1 = categories.sort().map((cat) => `export '${cat}/${cat}.dart';`).join("\n");
+  const exports = categories.sort().map((cat) => `export '${cat}/${cat}.dart';`).join("\n");
   return fragmentFromString(
     `// Auto-generated. Do not edit.
 // ignore_for_file: type=lint
 
-${exports$1}
+${exports}
 `
   );
 }
@@ -1174,30 +1493,62 @@ function getInstructionPageFragment(node, scope) {
   const instrFnName = scope.nameApi.instructionFunction(name);
   const parseFnName = scope.nameApi.instructionParseFunction(name);
   const accounts = node.accounts ?? [];
-  const args = (node.arguments ?? []).filter(
-    (arg) => !isDiscriminatorArg(arg, node)
-  );
   const allArgs = node.arguments ?? [];
+  const optionalAccountStrategy = node.optionalAccountStrategy ?? "programId";
+  if (optionalAccountStrategy !== "programId" && optionalAccountStrategy !== "omitted") {
+    throw new Error(
+      `Unsupported optional account strategy on instruction "${node.name}": ${optionalAccountStrategy}`
+    );
+  }
+  const args = allArgs.filter(
+    (arg) => !isDiscriminatorArg(arg, node) && !isOmittedDefaultArgument(arg)
+  );
   const dataClassName = `${typeName}InstructionData`;
-  const allArgManifests = allArgs.map((arg) => ({
+  const allArgManifests = (node.arguments ?? []).map((arg) => ({
     arg,
     manifest: visit(arg.type, scope.typeManifestVisitor)
   }));
+  const argDefaultValues = new Map(
+    allArgManifests.flatMap(({ arg, manifest }) => {
+      if (arg.defaultValue == null) return [];
+      const needsRenderedDefault = isOmittedDefaultArgument(arg) || isDiscriminatorArg(arg, node) || arg.defaultValue.kind !== "accountBumpValueNode";
+      if (!needsRenderedDefault) return [];
+      return [
+        [
+          arg,
+          getDartValueFragment(arg.defaultValue, manifest.type.content)
+        ]
+      ];
+    })
+  );
+  for (const arg of allArgs.filter(
+    (candidate) => isDiscriminatorArg(candidate, node)
+  )) {
+    if (!argDefaultValues.has(arg)) {
+      throw new Error(
+        `Field discriminator "${arg.name}" on instruction "${node.name}" must reference a field with a default value.`
+      );
+    }
+  }
   const dataFieldDecls = allArgManifests.map(({ arg, manifest }) => {
     const fieldName = camelCase(arg.name);
     return `  final ${manifest.type.content} ${fieldName};`;
   }).join("\n");
   const dataCtorParams = allArgManifests.map(({ arg, manifest }) => {
     const fieldName = camelCase(arg.name);
+    if (isOmittedDefaultArgument(arg)) return "";
     if (isDiscriminatorArg(arg, node)) {
-      return isConstDefaultValue(arg.defaultValue) ? `    this.${fieldName} = ${getDiscriminatorDefault(arg)},` : `    ${manifest.type.content}? ${fieldName},`;
+      return isConstDefaultValue(arg.defaultValue) ? `    this.${fieldName} = ${argDefaultValues.get(arg).content},` : `    ${manifest.type.content}? ${fieldName},`;
     }
     return `    required this.${fieldName},`;
-  }).join("\n");
+  }).filter(Boolean).join("\n");
   const dataCtorInitializers = allArgManifests.map(({ arg }) => {
     const fieldName = camelCase(arg.name);
+    if (isOmittedDefaultArgument(arg)) {
+      return `      ${fieldName} = ${argDefaultValues.get(arg).content}`;
+    }
     if (isDiscriminatorArg(arg, node) && !isConstDefaultValue(arg.defaultValue)) {
-      return `      ${fieldName} = ${fieldName} ?? ${getDiscriminatorDefault(arg)}`;
+      return `      ${fieldName} = ${fieldName} ?? ${argDefaultValues.get(arg).content}`;
     }
     return null;
   }).filter((value) => value !== null).join(",\n");
@@ -1207,16 +1558,26 @@ function getInstructionPageFragment(node, scope) {
   const decFields = allArgManifests.map(({ arg, manifest }) => {
     return `    ('${arg.name}', ${manifest.decoder.content}),`;
   }).join("\n");
-  const toMapFields = allArgs.map(
-    (arg) => `      '${arg.name}': value.${camelCase(arg.name)},`
-  ).join("\n");
-  const fromMapFields = allArgManifests.map(({ arg, manifest }) => {
+  const toMapFields = allArgs.map((arg) => {
+    const value = isOmittedDefaultArgument(arg) || isDiscriminatorArg(arg, node) ? argDefaultValues.get(arg).content : `value.${camelCase(arg.name)}`;
+    return `      '${arg.name}': ${value},`;
+  }).join("\n");
+  const fromMapFields = allArgManifests.filter(({ arg }) => !isOmittedDefaultArgument(arg)).map(({ arg, manifest }) => {
     const typeStr = manifest.type.content;
     const isNullable = typeStr.endsWith("?");
     const accessor = isNullable ? `map['${arg.name}']` : `map['${arg.name}']!`;
     return `      ${camelCase(arg.name)}: ${accessor} as ${typeStr},`;
   }).join("\n");
-  const dataCtorKeyword = dataCtorInitializers ? "" : "const ";
+  const dataCtorKeyword = allArgs.every(
+    (arg) => !isOmittedDefaultArgument(arg) || isConstDartValueNode(arg.defaultValue)
+  ) && allArgs.every(
+    (arg) => !isDiscriminatorArg(arg, node) || isConstDefaultValue(arg.defaultValue)
+  ) ? "const " : "";
+  const dataCtorSignature = dataCtorParams ? `${dataCtorKeyword}${dataClassName}({
+${dataCtorParams}
+  })${dataCtorInitializers ? ` :
+${dataCtorInitializers}` : ""};` : `${dataCtorKeyword}${dataClassName}()${dataCtorInitializers ? ` :
+${dataCtorInitializers}` : ""};`;
   const dataEncoderName = `get${typeName}InstructionDataEncoder`;
   const dataDecoderName = `get${typeName}InstructionDataDecoder`;
   const dataCodecName = `get${typeName}InstructionDataCodec`;
@@ -1234,7 +1595,7 @@ function getInstructionPageFragment(node, scope) {
     const manifest = argManifestMap.get(arg);
     const fieldName = camelCase(arg.name);
     const typeStr = manifest.type.content;
-    const hasDefault = arg.defaultValue != null;
+    const hasDefault = arg.defaultValue != null && arg.defaultValue.kind !== "accountBumpValueNode";
     if (hasDefault) {
       const nullableType = typeStr.endsWith("?") ? typeStr : `${typeStr}?`;
       return `  ${nullableType} ${fieldName},`;
@@ -1246,18 +1607,33 @@ function getInstructionPageFragment(node, scope) {
     const role = getAccountRole(acc);
     const isOptional = acc.isOptional ?? false;
     if (isOptional) {
-      return `    if (${fieldName} != null) AccountMeta(address: ${fieldName}, role: ${role}),`;
+      if (optionalAccountStrategy === "omitted") {
+        return `    if (${fieldName} != null) AccountMeta(address: ${fieldName}, role: ${role}),`;
+      }
+      return `    if (${fieldName} != null) AccountMeta(address: ${fieldName}, role: ${role}) else AccountMeta(address: ${instrProgramParam}, role: AccountRole.readonly),`;
     }
     return `    AccountMeta(address: ${fieldName}, role: ${role}),`;
   }).join("\n");
   const dataConstruction = allArgs.map((arg) => {
     const fieldName = camelCase(arg.name);
-    if (isDiscriminatorArg(arg, node)) {
+    if (isOmittedDefaultArgument(arg) || isDiscriminatorArg(arg, node)) {
       return "";
     }
-    return `      ${fieldName}: ${fieldName}${arg.defaultValue != null ? ` ?? ${getDefaultValue(arg)}` : ""},`;
+    const skipDefault = arg.defaultValue?.kind === "accountBumpValueNode";
+    return `      ${fieldName}: ${fieldName}${arg.defaultValue != null && !skipDefault ? ` ?? ${argDefaultValues.get(arg).content}` : ""},`;
   }).filter(Boolean).join("\n");
   const discFragment = getDiscriminatorConstantsFragment(node, scope);
+  const discriminatorValidation = getDiscriminatorValidationFragment(
+    node,
+    scope
+  );
+  const topLevelDecoder = getTopLevelDecoderFragment({
+    typeName: dataClassName,
+    description: `${name} instruction decoder`,
+    discriminatorValidation,
+    fromMapFields,
+    requireExactConsumption: true
+  });
   const parts = [
     fragment`// Auto-generated. Do not edit.
 // ignore_for_file: type=lint
@@ -1281,10 +1657,7 @@ ${use("AccountRole", "solanaInstructions")}`
   parts.push(fragment`
 @immutable
 class ${fragmentFromString(dataClassName)} {
-  ${fragmentFromString(dataCtorKeyword)}${fragmentFromString(dataClassName)}({
-${fragmentFromString(dataCtorParams)}
-  })${fragmentFromString(dataCtorInitializers ? ` :
-${dataCtorInitializers}` : "")};
+  ${fragmentFromString(dataCtorSignature)}
 
 ${fragmentFromString(dataFieldDecls)}
 }`);
@@ -1307,12 +1680,7 @@ Decoder<${fragmentFromString(dataClassName)}> ${fragmentFromString(dataDecoderNa
 ${fragmentFromString(decFields)}
   ]);
 
-  return transformDecoder(
-    structDecoder,
-    (Map<String, Object?> map, Uint8List bytes, int offset) => ${fragmentFromString(dataClassName)}(
-${fragmentFromString(fromMapFields)}
-    ),
-  );
+${topLevelDecoder}
 }
 
 Codec<${fragmentFromString(dataClassName)}, ${fragmentFromString(dataClassName)}> ${fragmentFromString(dataCodecName)}() {
@@ -1348,6 +1716,9 @@ ${fragmentFromString(dataClassName)} ${fragmentFromString(parseFnName)}(Instruct
     result.imports.mergeWith(manifest.decoder.imports);
     result.imports.mergeWith(manifest.type.imports);
   }
+  for (const defaultValue of argDefaultValues.values()) {
+    result.imports.mergeWith(defaultValue.imports);
+  }
   return result;
 }
 function getAccountRole(acc) {
@@ -1364,19 +1735,6 @@ function isDiscriminatorArg(arg, node) {
     (d) => d.kind === "fieldDiscriminatorNode" && d.name === arg.name
   );
 }
-function getDiscriminatorDefault(arg, _node) {
-  if (arg.defaultValue) {
-    if (arg.defaultValue.kind === "numberValueNode") {
-      return String(arg.defaultValue.number);
-    }
-    if (arg.defaultValue.kind === "bytesValueNode") {
-      const data = arg.defaultValue.data;
-      const bytes = data.match(/.{1,2}/g)?.map((b) => parseInt(b, 16)) ?? [];
-      return `Uint8List.fromList([${bytes.join(", ")}])`;
-    }
-  }
-  return "0";
-}
 function isConstDefaultValue(defaultValue) {
   if (!defaultValue) return false;
   switch (defaultValue.kind) {
@@ -1389,33 +1747,8 @@ function isConstDefaultValue(defaultValue) {
       return false;
   }
 }
-function getDefaultValue(arg) {
-  if (!arg.defaultValue) return "null";
-  const dv = arg.defaultValue;
-  switch (dv.kind) {
-    case "numberValueNode":
-      return String(dv.number);
-    case "booleanValueNode":
-      return String(dv.boolean);
-    case "stringValueNode":
-      return `'${dv.string}'`;
-    case "publicKeyValueNode": {
-      const wellKnownName = WELL_KNOWN_ADDRESSES.get(dv.publicKey);
-      if (wellKnownName) {
-        use(wellKnownName, "solanaAddresses");
-        return wellKnownName;
-      }
-      return `Address('${dv.publicKey}')`;
-    }
-    case "noneValueNode":
-      return "null";
-    case "bytesValueNode": {
-      const bytes = dv.data.match(/.{1,2}/g)?.map((b) => parseInt(b, 16)) ?? [];
-      return `Uint8List.fromList([${bytes.join(", ")}])`;
-    }
-    default:
-      return "null";
-  }
+function isOmittedDefaultArgument(arg) {
+  return arg.defaultValue != null && arg.defaultValueStrategy === "omitted";
 }
 function getPdaPageFragment(node, scope) {
   const name = node.name;
@@ -1534,8 +1867,6 @@ function bytesValueToDart(hex) {
   }
   return `[${pairs.join(", ")}]`;
 }
-
-// src/fragments/programPage.ts
 function getProgramPageFragment(node, scope) {
   const name = node.name;
   const addressConstName = scope.nameApi.programAddressConstant(name);
@@ -1567,41 +1898,171 @@ enum ${fragmentFromString(pascalCase(name))}Account {
 ${fragmentFromString(accountVariants)}
 }`);
   }
-  const instructions = node.instructions ?? [];
+  const instructions = getAllInstructionsWithSubs(node);
   if (instructions.length > 0) {
+    const programName = pascalCase(name);
+    const instructionEnum = `${programName}Instruction`;
     const instrVariants = instructions.map((instr) => `  ${camelCase(instr.name)},`).join("\n");
     parts.push(fragment`
-/// Known instructions for the ${fragmentFromString(pascalCase(name))} program.
-enum ${fragmentFromString(pascalCase(name))}Instruction {
+/// Known instructions for the ${fragmentFromString(programName)} program.
+enum ${fragmentFromString(instructionEnum)} {
 ${fragmentFromString(instrVariants)}
 }`);
+    const identifiableInstructions = instructions.map((instruction) => ({
+      instruction,
+      condition: getInstructionDiscriminatorCondition(instruction, scope)
+    })).filter(({ condition }) => condition !== null);
+    if (identifiableInstructions.length > 0) {
+      const identifyBranches = identifiableInstructions.map(
+        ({ instruction, condition }) => fragment`  if (${condition}) {
+    return ${fragmentFromString(instructionEnum)}.${fragmentFromString(camelCase(instruction.name))};
+  }`
+      );
+      const parsedBase = `Parsed${programName}Instruction`;
+      const parsedClasses = instructions.map((instruction) => {
+        const instructionName = pascalCase(instruction.name);
+        const variant = camelCase(instruction.name);
+        const parsedClass = `Parsed${instructionName}`;
+        const dataClass = `${instructionName}InstructionData`;
+        return fragment`/// A parsed ${fragmentFromString(instructionName)} instruction.
+final class ${fragmentFromString(parsedClass)} extends ${fragmentFromString(parsedBase)} {
+  const ${fragmentFromString(parsedClass)}({required this.data})
+      : super(${fragmentFromString(instructionEnum)}.${fragmentFromString(variant)});
+
+  final ${use(dataClass, "../instructions/instructions.dart")} data;
+}`;
+      });
+      const parseBranches = instructions.map((instruction) => {
+        const instructionName = pascalCase(instruction.name);
+        const variant = camelCase(instruction.name);
+        const parsedClass = `Parsed${instructionName}`;
+        const parseFunction = scope.nameApi.instructionParseFunction(
+          instruction.name
+        );
+        return fragment`    ${fragmentFromString(instructionEnum)}.${fragmentFromString(variant)} => ${fragmentFromString(parsedClass)}(
+      data: ${use(parseFunction, "../instructions/instructions.dart")}(instruction),
+    ),`;
+      });
+      parts.push(fragment`
+/// Identifies the type of a ${fragmentFromString(programName)} instruction.
+${fragmentFromString(instructionEnum)} identify${fragmentFromString(programName)}Instruction(
+  ${use("Uint8List", "dartTypedData")} data,
+) {
+${mergeFragments(identifyBranches, (cs) => cs.join("\n"))}
+
+  throw ${use("SolanaError", "solanaErrors")}(
+    ${use("SolanaErrorCode", "solanaErrors")}.programClientsFailedToIdentifyInstruction,
+    {
+      'instructionData': data,
+      'programName': '${fragmentFromString(name)}',
+    },
+  );
+}
+
+/// A parsed instruction from the ${fragmentFromString(programName)} program.
+sealed class ${fragmentFromString(parsedBase)} {
+  const ${fragmentFromString(parsedBase)}(this.instructionType);
+
+  final ${fragmentFromString(instructionEnum)} instructionType;
+}
+
+${mergeFragments(parsedClasses, (cs) => cs.join("\n\n"))}
+
+/// Parses a ${fragmentFromString(programName)} instruction.
+${fragmentFromString(parsedBase)} parse${fragmentFromString(programName)}Instruction(
+  ${use("Instruction", "solanaInstructions")} instruction,
+) {
+  return switch (identify${fragmentFromString(programName)}Instruction(
+    instruction.data ?? Uint8List(0),
+  )) {
+${mergeFragments(parseBranches, (cs) => cs.join("\n"))}
+  };
+}`);
+    }
   }
   return mergeFragments(parts, (cs) => cs.join("\n"));
 }
+function getInstructionDiscriminatorCondition(instruction, scope) {
+  const discriminators = instruction.discriminators ?? [];
+  if (discriminators.length === 0) return null;
+  const conditions = discriminators.map((discriminator) => {
+    switch (discriminator.kind) {
+      case "sizeDiscriminatorNode":
+        return fragment`data.length == ${discriminator.size}`;
+      case "constantDiscriminatorNode": {
+        const manifest = visit(
+          discriminator.constant.type,
+          scope.typeManifestVisitor
+        );
+        const value = getValueFragment(
+          discriminator.constant.value,
+          manifest.type.content
+        );
+        if (value === null) return null;
+        return fragment`${use("containsBytes", "solanaCodecsCore")}(data, ${manifest.encoder}.encode(${value}), ${discriminator.offset})`;
+      }
+      case "fieldDiscriminatorNode": {
+        const argument = (instruction.arguments ?? []).find(
+          (candidate) => candidate.name === discriminator.name
+        );
+        if (argument?.defaultValue == null) return null;
+        const manifest = visit(argument.type, scope.typeManifestVisitor);
+        const value = getValueFragment(
+          argument.defaultValue,
+          manifest.type.content
+        );
+        if (value === null) return null;
+        return fragment`${use("containsBytes", "solanaCodecsCore")}(data, ${manifest.encoder}.encode(${value}), ${discriminator.offset})`;
+      }
+    }
+  });
+  if (conditions.some((condition) => condition === null)) return null;
+  return mergeFragments(conditions, (cs) => cs.join(" && "));
+}
+function getValueFragment(value, dartType) {
+  switch (value.kind) {
+    case "numberValueNode":
+      return fragmentFromString(
+        dartType === "BigInt" ? `BigInt.from(${value.number})` : String(value.number)
+      );
+    case "booleanValueNode":
+      return fragmentFromString(String(value.boolean));
+    case "stringValueNode":
+      return fragmentFromString(`'${value.string.replaceAll("'", "\\'")}'`);
+    case "bytesValueNode": {
+      const clean = value.data.replace(/^0x/, "");
+      const bytes = clean.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16)) ?? [];
+      return fragment`${use("Uint8List", "dartTypedData")}.fromList([${fragmentFromString(bytes.join(", "))}])`;
+    }
+    default:
+      return null;
+  }
+}
 function getTypePageFragment(node, scope) {
   const name = node.name;
   scope.nameApi.dataType(name);
   const typeNode = node.type;
   if (typeNode.kind === "enumTypeNode") {
-    const isScalar = typeNode.variants.every(
+    const variants = typeNode.variants ?? [];
+    const isScalar = variants.every(
       (v) => v.kind === "enumEmptyVariantTypeNode"
     );
     if (isScalar) {
-      return getScalarEnumPageFragment(node, scope);
+      return getScalarEnumPageFragment(node, variants, scope);
     }
-    return getDataEnumPageFragment(node, scope);
+    return getDataEnumPageFragment(node, variants, scope);
   }
   if (typeNode.kind === "structTypeNode") {
     return getStructPageFragment(node, scope);
   }
   return getTypeAliasPageFragment(node, scope);
 }
-function getScalarEnumPageFragment(node, scope) {
+function getScalarEnumPageFragment(node, enumVariants, scope) {
   const name = node.name;
   const typeName = scope.nameApi.dataType(name);
   const enumNode = node.type;
   if (enumNode.kind !== "enumTypeNode") return emptyFragment();
-  const variants = enumNode.variants.map((v) => {
+  const variants = enumVariants.map((v) => {
     const variantName = scope.nameApi.enumVariant(v.name);
     return variantName;
   });
@@ -1612,6 +2073,14 @@ function getScalarEnumPageFragment(node, scope) {
   const resolvedSize = resolveNestedTypeNode(enumNode.size);
   const sizeType = resolvedSize.format ?? "u8";
   const sizeCodecName = getNumberCodecName2(sizeType);
+  const isU64 = sizeType === "u64";
+  const encodedVariantIndex = isU64 ? "BigInt.from(value.index)" : "value.index";
+  const decodedVariant = isU64 ? `(BigInt value, Uint8List bytes, int offset) {
+      if (value.isNegative || value >= BigInt.from(${typeName}.values.length)) {
+        throw RangeError('Invalid ${typeName} discriminator: ' + value.toString());
+      }
+      return ${typeName}.values[value.toInt()];
+    }` : `(int value, Uint8List bytes, int offset) => ${typeName}.values[value]`;
   return fragment`// Auto-generated. Do not edit.
 // ignore_for_file: type=lint
 
@@ -1632,14 +2101,14 @@ ${fragmentFromString(variantLines)}
 Encoder<${fragmentFromString(typeName)}> ${fragmentFromString(encoderName)}() {
   return transformEncoder(
     get${fragmentFromString(sizeCodecName)}Encoder(),
-    (${fragmentFromString(typeName)} value) => value.index,
+    (${fragmentFromString(typeName)} value) => ${fragmentFromString(encodedVariantIndex)},
   );
 }
 
 Decoder<${fragmentFromString(typeName)}> ${fragmentFromString(decoderName)}() {
   return transformDecoder(
     get${fragmentFromString(sizeCodecName)}Decoder(),
-    (int value, Uint8List bytes, int offset) => ${fragmentFromString(typeName)}.values[value],
+    ${fragmentFromString(decodedVariant)},
   );
 }
 
@@ -1647,7 +2116,7 @@ Codec<${fragmentFromString(typeName)}, ${fragmentFromString(typeName)}> ${fragme
   return combineCodec(${fragmentFromString(encoderName)}(), ${fragmentFromString(decoderName)}());
 }`;
 }
-function getDataEnumPageFragment(node, scope) {
+function getDataEnumPageFragment(node, variants, scope) {
   const name = node.name;
   const typeName = scope.nameApi.dataType(name);
   const enumNode = node.type;
@@ -1658,8 +2127,9 @@ function getDataEnumPageFragment(node, scope) {
   const encodeCases = [];
   const decodeCases = [];
   const allVariantManifests = [];
-  for (let i = 0; i < enumNode.variants.length; i++) {
-    const variant = enumNode.variants[i];
+  for (let i = 0; i < variants.length; i++) {
+    const variant = variants[i];
+    const variantName = pascalCase(variant.name);
     const variantClassName = scope.nameApi.sealedClassVariant(
       name,
       variant.name
@@ -1676,7 +2146,7 @@ function getDataEnumPageFragment(node, scope) {
   int get hashCode => runtimeType.hashCode;
 
   @override
-  String toString() => '${typeName}.${variantClassName}()';
+  String toString() => '${typeName}.${variantName}()';
 }`);
       encoderVariants.push(
         `(${i}, getStructEncoder(<(String, Encoder<Object?>)>[]))`
@@ -1688,7 +2158,7 @@ function getDataEnumPageFragment(node, scope) {
       decodeCases.push(`case ${i}: return const ${variantClassName}();`);
     } else if (variant.kind === "enumStructVariantTypeNode") {
       const resolvedStruct = resolveNestedTypeNode(variant.struct);
-      const fields = resolvedStruct.fields;
+      const fields = resolvedStruct.fields ?? [];
       const fieldManifests = fields.map((f) => ({
         field: f,
         manifest: visit(f.type, scope.typeManifestVisitor)
@@ -1723,7 +2193,7 @@ ${fieldDecls}
   int get hashCode => ${hashExpression};
 
   @override
-  String toString() => '${typeName}.${variantClassName}(${toStringFields})';
+  String toString() => '${typeName}.${variantName}(${toStringFields})';
 }`);
       const encFields = fieldManifests.map(({ field: f, manifest }) => {
         return `('${f.name}', ${manifest.encoder.content})`;
@@ -1754,7 +2224,7 @@ ${fieldDecls}
       decodeCases.push(`case ${i}: return ${variantClassName}(${fromMapFields.replace(/\n/g, " ").replace(/,$/, "")});`);
     } else if (variant.kind === "enumTupleVariantTypeNode") {
       const resolvedTuple = resolveNestedTypeNode(variant.tuple);
-      const items = resolvedTuple.items;
+      const items = resolvedTuple.items ?? [];
       if (items.length === 1) {
         const manifest = visit(items[0], scope.typeManifestVisitor);
         allVariantManifests.push(manifest);
@@ -1772,7 +2242,7 @@ ${fieldDecls}
   int get hashCode => value.hashCode;
 
   @override
-  String toString() => '${typeName}.${variantClassName}($value)';
+  String toString() => '${typeName}.${variantName}($value)';
 }`);
         encoderVariants.push(
           `(${i}, transformEncoder<${manifest.type.content}, Map<String, Object?>>(${manifest.encoder.content}, (Map<String, Object?> map) => map['value']! as ${manifest.type.content}))`
@@ -1854,7 +2324,7 @@ function getStructPageFragment(node, scope) {
   const typeName = scope.nameApi.dataType(name);
   const structNode = node.type;
   if (structNode.kind !== "structTypeNode") return emptyFragment();
-  const fields = structNode.fields;
+  const fields = structNode.fields ?? [];
   const fieldManifests = fields.map((f) => ({
     field: f,
     manifest: visit(f.type, scope.typeManifestVisitor)
@@ -2061,7 +2531,7 @@ function getRenderMapVisitor(options = {}) {
       visitRoot(node, { self }) {
         const programMaps = [
           visit(node.program, self),
-          ...node.additionalPrograms.map((p) => visit(p, self))
+          ...(node.additionalPrograms ?? []).map((p) => visit(p, self))
         ];
         const mergedProgramMap = mergeRenderMaps(programMaps);
         const categoryMaps = getSharedCategoryIndexMaps(mergedProgramMap);
@@ -2207,16 +2677,17 @@ function renderVisitor(outputDir, options = {}) {
     dependencyMap
   } = options;
   return rootNodeVisitor((root) => {
+    const normalizedRoot = normalizeRootNode(root);
     if (deleteFolderBeforeRendering && existsSync(outputDir)) {
       deleteDirectory(outputDir);
     }
     const renderMap = visit(
-      root,
+      normalizedRoot,
       getRenderMapVisitor({ nameApi, dependencyMap })
     );
     const typePathMap = {};
     for (const renderPath of renderMap.keys()) {
-      const match = renderPath.match(/^(?:.*\/)?types\/([a-z_]+)\.dart$/);
+      const match = renderPath.match(/^(?:.*\/)?types\/([a-z0-9_]+)\.dart$/);
       if (match) {
         typePathMap[`definedType:${match[1]}`] = renderPath;
       }
@@ -2230,7 +2701,10 @@ function renderVisitor(outputDir, options = {}) {
       const fileDir = dirname(filePath);
       const internalMap = {};
       for (const [key, typePath] of Object.entries(typePathMap)) {
-        if (typePath === filePath) continue;
+        if (typePath === filePath) {
+          internalMap[key] = "";
+          continue;
+        }
         let rel = posix.relative(fileDir, typePath);
         if (!rel.startsWith(".")) {
           rel = `./${rel}`;
@@ -2290,6 +2764,6 @@ function cleanFragmentContent(content) {
 // src/index.ts
 var src_default = renderVisitor;
 
-export { DART_EXTERNAL_PACKAGE_MAP, DartImportMap, createDartNameApi, src_default as default, getRenderMapVisitor, getTypeManifestVisitor, renderVisitor };
+export { DART_EXTERNAL_PACKAGE_MAP, DartImportMap, createDartNameApi, src_default as default, getRenderMapVisitor, getTypeManifestVisitor, normalizeRootNode, renderVisitor };
 //# sourceMappingURL=index.node.js.map
 //# sourceMappingURL=index.node.js.map