codama-renderers-dart 0.5.0 → 0.5.1

package/src/fragments/instructionPage.ts

@@ -7,16 +7,20 @@ import { visit } from "@codama/visitors-core";
 
 import type { Fragment } from "../utils/fragment.js";
 import {
-  emptyFragment,
   fragment,
   fragmentFromString,
   mergeFragments,
   use,
 } from "../utils/fragment.js";
 import type { RenderScope } from "../utils/options.js";
-import { camelCase, pascalCase } from "../utils/nameTransformers.js";
+import { camelCase } from "../utils/nameTransformers.js";
+import { getDiscriminatorValidationFragment } from "../utils/discriminators.js";
+import { getTopLevelDecoderFragment } from "../utils/exactDecoder.js";
+import {
+  getDartValueFragment,
+  isConstDartValueNode,
+} from "../utils/valueNodes.js";
 import { getDiscriminatorConstantsFragment } from "./discriminatorConstants.js";
-import { WELL_KNOWN_ADDRESSES } from "../utils/wellKnownAddresses.js";
 
 /**
  * Generate a full Dart file for an instruction.
@@ -31,19 +35,55 @@ export function getInstructionPageFragment(
   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: string =
+    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),
+  );
 
   // Build the instruction data class
   const dataClassName = `${typeName}InstructionData`;
 
   // Visit each arg type once and collect manifests for reuse
-  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),
+        ] as const,
+      ];
+    }),
+  );
+  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.`,
+      );
+    }
+  }
 
   // Data fields (non-discriminator arguments)
   const dataFieldDecls = allArgManifests
@@ -56,20 +96,25 @@ export function getInstructionPageFragment(
   const dataCtorParams = allArgManifests
     .map(({ arg, manifest }) => {
       const fieldName = camelCase(arg.name as string);
+      if (isOmittedDefaultArgument(arg)) return "";
       if (isDiscriminatorArg(arg, node)) {
         return isConstDefaultValue(arg.defaultValue)
-          ? `    this.${fieldName} = ${getDiscriminatorDefault(arg, node)},`
+          ? `    this.${fieldName} = ${argDefaultValues.get(arg)!.content},`
           : `    ${manifest.type.content}? ${fieldName},`;
       }
       return `    required this.${fieldName},`;
     })
+    .filter(Boolean)
     .join("\n");
 
   const dataCtorInitializers = allArgManifests
     .map(({ arg }) => {
       const fieldName = camelCase(arg.name as string);
+      if (isOmittedDefaultArgument(arg)) {
+        return `      ${fieldName} = ${argDefaultValues.get(arg)!.content}`;
+      }
       if (isDiscriminatorArg(arg, node) && !isConstDefaultValue(arg.defaultValue)) {
-        return `      ${fieldName} = ${fieldName} ?? ${getDiscriminatorDefault(arg, node)}`;
+        return `      ${fieldName} = ${fieldName} ?? ${argDefaultValues.get(arg)!.content}`;
       }
       return null;
     })
@@ -90,13 +135,17 @@ export function getInstructionPageFragment(
     .join("\n");
 
   const toMapFields = allArgs
-    .map(
-      (arg) =>
-        `      '${arg.name as string}': value.${camelCase(arg.name as string)},`,
-    )
+    .map((arg) => {
+      const value =
+        isOmittedDefaultArgument(arg) || isDiscriminatorArg(arg, node)
+          ? argDefaultValues.get(arg)!.content
+          : `value.${camelCase(arg.name as string)}`;
+      return `      '${arg.name as string}': ${value},`;
+    })
     .join("\n");
 
   const fromMapFields = allArgManifests
+    .filter(({ arg }) => !isOmittedDefaultArgument(arg))
     .map(({ arg, manifest }) => {
       const typeStr = manifest.type.content;
       const isNullable = typeStr.endsWith("?");
@@ -105,7 +154,20 @@ export function getInstructionPageFragment(
     })
     .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}({\n${dataCtorParams}\n  })${dataCtorInitializers ? ` :\n${dataCtorInitializers}` : ""};`
+    : `${dataCtorKeyword}${dataClassName}()${dataCtorInitializers ? ` :\n${dataCtorInitializers}` : ""};`;
   const dataEncoderName = `get${typeName}InstructionDataEncoder`;
   const dataDecoderName = `get${typeName}InstructionDataDecoder`;
   const dataCodecName = `get${typeName}InstructionDataCodec`;
@@ -155,7 +217,10 @@ export function getInstructionPageFragment(
       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}),`;
     })
@@ -165,19 +230,31 @@ export function getInstructionPageFragment(
   const dataConstruction = allArgs
     .map((arg) => {
       const fieldName = camelCase(arg.name as string);
-      if (isDiscriminatorArg(arg, node)) {
+      if (
+        isOmittedDefaultArgument(arg) ||
+        isDiscriminatorArg(arg, node)
+      ) {
         return ""; // Use default
       }
-      // Use 'arg_<name>' prefix to reference builder params without shadowing.
-      const typeStr2 = argManifestMap.get(arg)?.type.content;
       const skipDefault = arg.defaultValue?.kind === "accountBumpValueNode";
-      return `      ${fieldName}: ${fieldName}${arg.defaultValue != null && !skipDefault ? ` ?? ${getDefaultValue(arg, typeStr2)}` : ""},`;
+      return `      ${fieldName}: ${fieldName}${arg.defaultValue != null && !skipDefault ? ` ?? ${argDefaultValues.get(arg)!.content}` : ""},`;
     })
     .filter(Boolean)
     .join("\n");
 
   // Discriminator
   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[] = [
     fragment`// Auto-generated. Do not edit.
@@ -205,9 +282,7 @@ ${use("AccountRole", "solanaInstructions")}`,
   parts.push(fragment`
 @immutable
 class ${fragmentFromString(dataClassName)} {
-  ${fragmentFromString(dataCtorKeyword)}${fragmentFromString(dataClassName)}({
-${fragmentFromString(dataCtorParams)}
-  })${fragmentFromString(dataCtorInitializers ? ` :\n${dataCtorInitializers}` : "")};
+  ${fragmentFromString(dataCtorSignature)}
 
 ${fragmentFromString(dataFieldDecls)}
 }`);
@@ -232,12 +307,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)}() {
@@ -280,6 +350,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;
 }
@@ -305,23 +378,6 @@ function isDiscriminatorArg(
   );
 }
 
-function getDiscriminatorDefault(
-  arg: InstructionArgumentNode,
-  _node: InstructionNode,
-): string {
-  if (arg.defaultValue) {
-    if (arg.defaultValue.kind === "numberValueNode") {
-      return String(arg.defaultValue.number);
-    }
-    if (arg.defaultValue.kind === "bytesValueNode") {
-      const data = arg.defaultValue.data as string;
-      const bytes = data.match(/.{1,2}/g)?.map((b) => parseInt(b, 16)) ?? [];
-      return `Uint8List.fromList([${bytes.join(", ")}])`;
-    }
-  }
-  return "0";
-}
-
 function isConstDefaultValue(defaultValue: InstructionArgumentNode["defaultValue"]): boolean {
   if (!defaultValue) return false;
   switch (defaultValue.kind) {
@@ -335,36 +391,6 @@ function isConstDefaultValue(defaultValue: InstructionArgumentNode["defaultValue
   }
 }
 
-function getDefaultValue(
-  arg: InstructionArgumentNode,
-  typeStr?: string,
-): string {
-  if (!arg.defaultValue) return "null";
-  const isBigInt = typeStr === "BigInt";
-  const dv = arg.defaultValue;
-  switch (dv.kind) {
-    case "numberValueNode":
-      // Dart's `BigInt` requires a constructor; `0` is not assignable to `BigInt`.
-      return isBigInt ? `BigInt.from(${dv.number})` : 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: InstructionArgumentNode): boolean {
+  return arg.defaultValue != null && arg.defaultValueStrategy === "omitted";
 }

package/src/fragments/typePage.ts

@@ -1,4 +1,9 @@
-import type { DefinedTypeNode, StructFieldTypeNode, TypeNode } from "@codama/nodes";
+import type {
+  DefinedTypeNode,
+  EnumVariantTypeNode,
+  StructFieldTypeNode,
+  TypeNode,
+} from "@codama/nodes";
 import { resolveNestedTypeNode } from "@codama/nodes";
 import { visit } from "@codama/visitors-core";
 
@@ -30,13 +35,14 @@ export function getTypePageFragment(
 
   // Check what kind of type this is
   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") {
@@ -52,6 +58,7 @@ export function getTypePageFragment(
  */
 function getScalarEnumPageFragment(
   node: DefinedTypeNode,
+  enumVariants: EnumVariantTypeNode[],
   scope: RenderScope,
 ): Fragment {
   const name = node.name as string;
@@ -59,7 +66,7 @@ function getScalarEnumPageFragment(
   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 as string);
     return variantName;
   });
@@ -73,6 +80,18 @@ function getScalarEnumPageFragment(
   const resolvedSize = resolveNestedTypeNode(enumNode.size);
   const sizeType = resolvedSize.format ?? "u8";
   const sizeCodecName = getNumberCodecName(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
@@ -94,14 +113,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)},
   );
 }
 
@@ -115,6 +134,7 @@ Codec<${fragmentFromString(typeName)}, ${fragmentFromString(typeName)}> ${fragme
  */
 function getDataEnumPageFragment(
   node: DefinedTypeNode,
+  variants: EnumVariantTypeNode[],
   scope: RenderScope,
 ): Fragment {
   const name = node.name as string;
@@ -130,8 +150,8 @@ function getDataEnumPageFragment(
   // Collect all field type manifests from variants so we can merge their imports
   const allVariantManifests: { encoder: Fragment; decoder: Fragment; type: Fragment }[] = [];
 
-  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 as string);
     const variantClassName = scope.nameApi.sealedClassVariant(
       name,
@@ -163,7 +183,7 @@ function getDataEnumPageFragment(
       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 ?? [];
 
       // Visit each field type once and collect manifests
       const fieldManifests = fields.map((f: StructFieldTypeNode) => ({
@@ -271,7 +291,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);
@@ -384,7 +404,7 @@ function getStructPageFragment(
   const structNode = node.type;
   if (structNode.kind !== "structTypeNode") return emptyFragment();
 
-  const fields = structNode.fields;
+  const fields = structNode.fields ?? [];
 
   // Visit each field type once and collect manifests for reuse
   const fieldManifests = fields.map((f: StructFieldTypeNode) => ({

package/src/index.ts

@@ -3,6 +3,7 @@ export { getRenderMapVisitor } from "./visitors/getRenderMapVisitor.js";
 export { getTypeManifestVisitor } from "./visitors/getTypeManifestVisitor.js";
 export { DartImportMap, DART_EXTERNAL_PACKAGE_MAP } from "./utils/importMap.js";
 export { createDartNameApi } from "./utils/nameTransformers.js";
+export { normalizeRootNode } from "./utils/normalizeRootNode.js";
 export type { DartNameApi } from "./utils/nameTransformers.js";
 export type { RenderOptions, GetRenderMapOptions, RenderScope } from "./utils/options.js";
 export type { TypeManifest } from "./utils/typeManifest.js";

package/src/utils/discriminators.ts

@@ -0,0 +1,121 @@
+import type {
+  AccountNode,
+  ConstantValueNode,
+  InstructionNode,
+  StructFieldTypeNode,
+} from "@codama/nodes";
+import { resolveNestedTypeNode } from "@codama/nodes";
+import { visit } from "@codama/visitors-core";
+
+import type { Fragment } from "./fragment.js";
+import {
+  emptyFragment,
+  fragment,
+  fragmentFromString,
+  mergeFragments,
+  use,
+} from "./fragment.js";
+import type { RenderScope } from "./options.js";
+import { getDartValueFragment } from "./valueNodes.js";
+
+type DiscriminatedNode = AccountNode | InstructionNode;
+
+/**
+ * Generate decoder guards for every discriminator declared by a Codama node.
+ */
+export function getDiscriminatorValidationFragment(
+  node: DiscriminatedNode,
+  scope: RenderScope,
+): Fragment {
+  const discriminators = node.discriminators ?? [];
+  if (discriminators.length === 0) return emptyFragment();
+
+  const fields = getDiscriminatorFields(node);
+  const fragments = discriminators.map((discriminator): Fragment => {
+    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(
+          {
+            kind: "constantValueNode",
+            type: field.type,
+            value: field.defaultValue,
+          } as ConstantValueNode,
+          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 as string)} discriminator',
+      'expected': ${fragmentFromString(String(discriminator.size))},
+      'bytesLength': bytes.length - offset,
+    },
+  );
+}`;
+      }
+    }
+  });
+
+  return mergeFragments(fragments, (contents) => contents.join("\n"));
+}
+
+function getConstantValidationFragment(
+  constant: ConstantValueNode,
+  discriminatorOffset: number,
+  scope: RenderScope,
+): Fragment {
+  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: DiscriminatedNode,
+): readonly StructFieldTypeNode[] {
+  if (node.kind === "accountNode") {
+    return resolveNestedTypeNode(node.data).fields ?? [];
+  }
+  return (node.arguments ?? []).map(
+    (argument) =>
+      ({
+        ...argument,
+        kind: "structFieldTypeNode",
+      }) as StructFieldTypeNode,
+  );
+}

package/src/utils/exactDecoder.ts

@@ -0,0 +1,82 @@
+import type { Fragment } from "./fragment.js";
+import { fragment, fragmentFromString, use } from "./fragment.js";
+
+export interface TopLevelDecoderFragmentOptions {
+  readonly typeName: string;
+  readonly description: string;
+  readonly discriminatorValidation: Fragment;
+  readonly fromMapFields: string;
+  readonly requireExactConsumption: boolean;
+}
+
+/**
+ * Wrap a generated top-level struct decoder with discriminator and length
+ * validation.
+ *
+ * The wrapper preserves fixed/variable decoder metadata so it remains
+ * compatible with the matching generated encoder when combined into a codec.
+ */
+export function getTopLevelDecoderFragment({
+  typeName,
+  description,
+  discriminatorValidation,
+  fromMapFields,
+  requireExactConsumption,
+}: TopLevelDecoderFragmentOptions): Fragment {
+  const validation = discriminatorValidation.content
+    ? `    ${discriminatorValidation.content.replaceAll("\n", "\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;
+}

package/src/utils/formatCode.ts

@@ -2,11 +2,11 @@ import { execSync } from "node:child_process";
 
 /**
  * Format Dart code using `dart format`.
- * Falls back to returning the unformatted code if dart is not available.
+ * Falls back to returning the unformatted code if Dart is not available.
  */
 export function formatDartCode(code: string): string {
   try {
-    const result = execSync("dart format --fix -", {
+    const result = execSync("dart format --output=show", {
       input: code,
       encoding: "utf-8",
       timeout: 30_000,
@@ -23,13 +23,9 @@ export function formatDartCode(code: string): string {
  * Format all Dart files in a directory using `dart format`.
  */
 export function formatDartDirectory(dir: string): void {
-  try {
-    execSync(`dart format --fix "${dir}"`, {
-      encoding: "utf-8",
-      timeout: 60_000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-  } catch {
-    // Silently ignore if dart format is not available
-  }
+  execSync(`dart format "${dir}"`, {
+    encoding: "utf-8",
+    timeout: 60_000,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
 }

package/src/utils/index.ts

@@ -1,8 +1,12 @@
 export * from "./codecs.js";
+export * from "./discriminators.js";
+export * from "./exactDecoder.js";
 export * from "./formatCode.js";
 export * from "./fragment.js";
 export * from "./importMap.js";
 export * from "./nameTransformers.js";
+export * from "./normalizeRootNode.js";
 export * from "./options.js";
 export * from "./typeManifest.js";
+export * from "./valueNodes.js";
 export * from "./wellKnownAddresses.js";