codama-renderers-dart 0.5.1 → 0.5.4

package/dist/index.browser.js

@@ -2,13 +2,13 @@ import { existsSync, mkdirSync, writeFileSync } from 'fs';
 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 { execFileSync } from 'child_process';
 import { resolveNestedTypeNode, getAllInstructionsWithSubs } from '@codama/nodes';
 import { CodamaError, CODAMA_ERROR__UNEXPECTED_NODE_KIND } from '@codama/errors';
 
 // src/visitors/renderVisitor.ts
 function formatDartDirectory(dir) {
-  execSync(`dart format "${dir}"`, {
+  execFileSync("dart", ["format", "--", dir], {
     encoding: "utf-8",
     timeout: 6e4,
     stdio: ["pipe", "pipe", "pipe"]
@@ -78,13 +78,89 @@ function setEmptyCollection(record, key) {
 
 // src/utils/nameTransformers.ts
 function pascalCase(str) {
+  assertSafeName(str);
   return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (c) => c.toUpperCase());
 }
+var DART_RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "abstract",
+  "as",
+  "assert",
+  "async",
+  "augment",
+  "await",
+  "base",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "covariant",
+  "default",
+  "deferred",
+  "do",
+  "dynamic",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "extension",
+  "external",
+  "factory",
+  "false",
+  "final",
+  "finally",
+  "for",
+  "get",
+  "hide",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "interface",
+  "is",
+  "late",
+  "library",
+  "mixin",
+  "native",
+  "new",
+  "null",
+  "of",
+  "on",
+  "operator",
+  "part",
+  "required",
+  "rethrow",
+  "return",
+  "sealed",
+  "set",
+  "show",
+  "static",
+  "super",
+  "switch",
+  "sync",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typedef",
+  "var",
+  "void",
+  "when",
+  "while",
+  "with",
+  "yield"
+]);
+function escapeDartIdentifier(name) {
+  return DART_RESERVED_WORDS.has(name) ? `${name}_` : name;
+}
 function camelCase(str) {
   const pascal = pascalCase(str);
-  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  const cased = pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  return escapeDartIdentifier(cased);
 }
 function snakeCase(str) {
+  assertSafeName(str);
   return str.replace(/([A-Z])/g, "_$1").replace(/[-\s]+/g, "_").replace(/^_/, "").replace(/_+/g, "_").toLowerCase();
 }
 function createDartNameApi() {
@@ -110,6 +186,11 @@ function createDartNameApi() {
     discriminatorConstant: (name) => `${camelCase(name)}Discriminator`
   };
 }
+function assertSafeName(name) {
+  if (!/^[a-zA-Z0-9_ -]*$/.test(name)) {
+    throw new Error(`Invalid Dart node name: ${JSON.stringify(name)}`);
+  }
+}
 
 // src/utils/codecs.ts
 function bytesToDartHexList(bytes) {
@@ -320,10 +401,19 @@ var WELL_KNOWN_ADDRESSES = /* @__PURE__ */ new Map([
 function getDartValueFragment(value, dartType) {
   switch (value.kind) {
     case "numberValueNode":
+      if (typeof value.number !== "number" || !Number.isFinite(value.number)) {
+        throw new Error("Invalid Dart number: expected a finite number");
+      }
+      if (dartType === "BigInt" && !Number.isSafeInteger(value.number)) {
+        throw new Error("Invalid Dart BigInt: expected a safe integer");
+      }
       return fragmentFromString(
         dartType === "BigInt" ? `BigInt.from(${value.number})` : String(value.number)
       );
     case "booleanValueNode":
+      if (typeof value.boolean !== "boolean") {
+        throw new Error("Invalid Dart boolean: expected a boolean");
+      }
       return fragmentFromString(String(value.boolean));
     case "stringValueNode":
       return fragmentFromString(toDartStringLiteral(value.string));
@@ -367,6 +457,12 @@ function isConstDartValueNode(value) {
 function toDartStringLiteral(value) {
   return `'${value.replaceAll("\\", "\\\\").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("	", "\\t").replaceAll("\b", "\\b").replaceAll("\f", "\\f").replaceAll("$", "\\$").replaceAll("'", "\\'")}'`;
 }
+function getNonNegativeInteger(value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error("Expected a non-negative safe integer value");
+  }
+  return String(value);
+}
 
 // src/utils/discriminators.ts
 function getDiscriminatorValidationFragment(node, scope) {
@@ -567,23 +663,12 @@ function getTypeManifestVisitor(input) {
     }
   );
   return extendVisitor(baseVisitor, {
-    visitNumberType(node, { self }) {
-      const { format, endian } = node;
-      const endianSuffix = endian === "be" ? ", NumberCodecConfig(endian: Endian.big)" : "";
-      const endianDecoderSuffix = endian === "be" ? ", NumberCodecConfig(endian: Endian.big)" : "";
-      const dartType = getNumberDartType(format);
-      const codecName = getNumberCodecName(format);
+    visitNumberType(node) {
       return {
         // `BigInt` and other number types live in `dart:core` and need no import.
-        type: fragmentFromString(dartType),
-        encoder: fragment`${use(
-          `get${codecName}Encoder`,
-          "solanaCodecsNumbers"
-        )}(${endianSuffix ? fragmentFromString(endianSuffix.slice(2)) : fragmentFromString("")})`,
-        decoder: fragment`${use(
-          `get${codecName}Decoder`,
-          "solanaCodecsNumbers"
-        )}(${endianDecoderSuffix ? fragmentFromString(endianDecoderSuffix.slice(2)) : fragmentFromString("")})`,
+        type: fragmentFromString(getNumberDartType(node.format)),
+        encoder: getNumberCodecExpression(node, "Encoder"),
+        decoder: getNumberCodecExpression(node, "Decoder"),
         value: emptyTypeManifest().value,
         isEnum: false
       };
@@ -670,7 +755,7 @@ function getTypeManifestVisitor(input) {
         encoder: fragment`${use(
           "getArrayEncoder",
           "solanaCodecsDataStructures"
-        )}<${itemType}>(${itemEncoder}${encoderSizeExpr})`,
+        )}(${itemEncoder}${encoderSizeExpr})`,
         decoder: fragment`${use(
           "getArrayDecoder",
           "solanaCodecsDataStructures"
@@ -726,18 +811,28 @@ function getTypeManifestVisitor(input) {
         typeFragment.imports.mergeWith(m.type.imports);
       }
       const encoderListStr = encoderList.map((e) => e.content).join(", ");
+      const decoderListStr = decoderList.map((d) => d.content).join(", ");
+      let tupleEncoderFn = "getTupleEncoder";
+      let tupleDecoderFn = "getTupleDecoder";
+      let tupleEncoderArgs = `[${encoderListStr}]`;
+      let tupleDecoderArgs = `[${decoderListStr}]`;
+      if (itemManifests.length === 2) {
+        tupleEncoderFn = "getTuple2Encoder";
+        tupleDecoderFn = "getTuple2Decoder";
+        tupleEncoderArgs = encoderListStr;
+        tupleDecoderArgs = decoderListStr;
+      }
       const encoderFrag = fragment`${use(
-        "getTupleEncoder",
+        tupleEncoderFn,
         "solanaCodecsDataStructures"
-      )}([${fragmentFromString(encoderListStr)}])`;
+      )}(${tupleEncoderArgs})`;
       for (const e of encoderList) {
         encoderFrag.imports.mergeWith(e.imports);
       }
-      const decoderListStr = decoderList.map((d) => d.content).join(", ");
       const decoderFrag = fragment`${use(
-        "getTupleDecoder",
+        tupleDecoderFn,
         "solanaCodecsDataStructures"
-      )}([${fragmentFromString(decoderListStr)}])`;
+      )}(${tupleDecoderArgs})`;
       for (const d of decoderList) {
         decoderFrag.imports.mergeWith(d.imports);
       }
@@ -754,7 +849,7 @@ function getTypeManifestVisitor(input) {
       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 encoderFields = fields.map((f, i) => `(${toDartStringLiteral(fieldNames[i])}, ${f.encoder.content})`).join(", ");
       const encoderFrag = fragment`${use(
         "getStructEncoder",
         "solanaCodecsDataStructures"
@@ -762,7 +857,7 @@ function getTypeManifestVisitor(input) {
       for (const f of fields) {
         encoderFrag.imports.mergeWith(f.encoder.imports);
       }
-      const decoderFields = fields.map((f, i) => `('${fieldNames[i]}', ${f.decoder.content})`).join(", ");
+      const decoderFields = fields.map((f, i) => `(${toDartStringLiteral(fieldNames[i])}, ${f.decoder.content})`).join(", ");
       const decoderFrag = fragment`${use(
         "getStructDecoder",
         "solanaCodecsDataStructures"
@@ -816,19 +911,22 @@ function getTypeManifestVisitor(input) {
       const itemManifest = visit(node.item, self);
       const itemTypeStr = itemManifest.type.content;
       const resolvedPrefix = resolveNestedTypeNode(node.prefix);
-      const prefixExpr = resolvedPrefix.format !== "u8" ? `, prefix: ${getNumberCodecExpression(resolvedPrefix.format, "Encoder")}` : "";
-      const prefixDecoderExpr = resolvedPrefix.format !== "u8" ? `, prefix: ${getNumberCodecExpression(resolvedPrefix.format, "Decoder")}` : "";
+      const prefixExpr = resolvedPrefix.format !== "u8" ? fragment`, prefix: ${getNumberCodecExpression(resolvedPrefix, "Encoder")}` : "";
+      const prefixDecoderExpr = resolvedPrefix.format !== "u8" ? fragment`, prefix: ${getNumberCodecExpression(resolvedPrefix, "Decoder")}` : "";
       const noneValueExpr = node.fixed ? ", noneValue: const ZeroesNoneValue()" : "";
       return {
         type: fragment`${itemManifest.type}?`,
         encoder: fragment`${use(
           "getNullableEncoder",
           "solanaCodecsDataStructures"
-        )}<${fragmentFromString(itemTypeStr)}>(${itemManifest.encoder}${fragmentFromString(prefixExpr)}${fragmentFromString(noneValueExpr)})`,
+        )}<${fragmentFromString(itemTypeStr)}>(${use(
+          "transformEncoder",
+          "solanaCodecsCore"
+        )}(${itemManifest.encoder}, (${fragmentFromString(itemTypeStr)} value) => value)${prefixExpr}${fragmentFromString(noneValueExpr)})`,
         decoder: fragment`${use(
           "getNullableDecoder",
           "solanaCodecsDataStructures"
-        )}<${fragmentFromString(itemTypeStr)}>(${itemManifest.decoder}${fragmentFromString(prefixDecoderExpr)}${fragmentFromString(noneValueExpr)})`,
+        )}<${fragmentFromString(itemTypeStr)}>(${itemManifest.decoder}${prefixDecoderExpr}${fragmentFromString(noneValueExpr)})`,
         value: emptyTypeManifest().value,
         isEnum: false
       };
@@ -874,11 +972,11 @@ function getTypeManifestVisitor(input) {
         encoder: fragment`${use(
           "fixEncoderSize",
           "solanaCodecsCore"
-        )}(${innerManifest.encoder}, ${fragmentFromString(String(node.size))}, allowTruncation: false)`,
+        )}(${innerManifest.encoder}, ${fragmentFromString(getNonNegativeInteger(node.size))}, allowTruncation: false)`,
         decoder: fragment`${use(
           "fixDecoderSize",
           "solanaCodecsCore"
-        )}(${innerManifest.decoder}, ${fragmentFromString(String(node.size))})`,
+        )}(${innerManifest.decoder}, ${fragmentFromString(getNonNegativeInteger(node.size))})`,
         value: innerManifest.value,
         isEnum: innerManifest.isEnum
       };
@@ -888,10 +986,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);
+        const numberManifest = visit(node.prefix, self);
         prefixManifest = {
-          encoder: fragment`transformEncoder(${use(`get${codecName}Encoder`, "solanaCodecsNumbers")}(), (size) => BigInt.from(size))`,
-          decoder: fragment`transformDecoder(${use(`get${codecName}Decoder`, "solanaCodecsNumbers")}(), (size, _, __) => size.toInt())`
+          encoder: fragment`${use("transformEncoder", "solanaCodecsCore")}(${numberManifest.encoder}, (size) => BigInt.from(size))`,
+          decoder: fragment`${use("transformDecoder", "solanaCodecsCore")}(${numberManifest.decoder}, (size, _, __) => size.toInt())`
         };
       } else {
         prefixManifest = visit(node.prefix, self);
@@ -982,10 +1080,10 @@ function getTypeManifestVisitor(input) {
       };
     },
     visitPreOffsetType(node, { self }) {
-      return visit(node.type, self);
+      return getOffsetManifest(node, self);
     },
     visitPostOffsetType(node, { self }) {
-      return visit(node.type, self);
+      return getOffsetManifest(node, self);
     },
     visitSolAmountType(node, { self }) {
       return visit(node.number, self);
@@ -1074,16 +1172,17 @@ function getNumberCodecName(format) {
       return "U8";
   }
 }
-function getNumberCodecExpression(format, codecType) {
-  const name = getNumberCodecName(format);
-  return `get${name}${codecType}()`;
+function getNumberCodecExpression(node, codecType) {
+  const name = getNumberCodecName(node.format);
+  const config = node.endian === "be" ? fragment`${use("NumberCodecConfig", "solanaCodecsNumbers")}(endian: ${use("Endian", "dartTypedData")}.big)` : "";
+  return fragment`${use(`get${name}${codecType}`, "solanaCodecsNumbers")}(${config})`;
 }
 function getArraySizeExpression(node, codecType) {
   if (!("count" in node) || !node.count) return "";
   const count = node.count;
   switch (count.kind) {
     case "fixedCountNode":
-      return `, size: FixedArraySize(${count.value})`;
+      return `, size: FixedArraySize(${getNonNegativeInteger(count.value)})`;
     case "remainderCountNode":
       return ", size: RemainderArraySize()";
     case "prefixedCountNode": {
@@ -1091,7 +1190,7 @@ function getArraySizeExpression(node, codecType) {
       if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
         return "";
       }
-      return `, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix.format, codecType)})`;
+      return fragment`, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix, codecType)})`;
     }
     default:
       return "";
@@ -1102,7 +1201,7 @@ function getMapSizeExpression(node, codecType) {
   const count = node.count;
   switch (count.kind) {
     case "fixedCountNode":
-      return `, size: FixedArraySize(${count.value})`;
+      return `, size: FixedArraySize(${getNonNegativeInteger(count.value)})`;
     case "remainderCountNode":
       return ", size: RemainderArraySize()";
     case "prefixedCountNode": {
@@ -1110,7 +1209,7 @@ function getMapSizeExpression(node, codecType) {
       if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
         return "";
       }
-      return `, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix.format, codecType)})`;
+      return fragment`, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix, codecType)})`;
     }
     default:
       return "";
@@ -1121,7 +1220,7 @@ function getSetSizeExpression(node, codecType) {
   const count = node.count;
   switch (count.kind) {
     case "fixedCountNode":
-      return `, size: FixedArraySize(${count.value})`;
+      return `, size: FixedArraySize(${getNonNegativeInteger(count.value)})`;
     case "remainderCountNode":
       return ", size: RemainderArraySize()";
     case "prefixedCountNode": {
@@ -1129,7 +1228,7 @@ function getSetSizeExpression(node, codecType) {
       if (resolvedPrefix.format === "u32" && (!resolvedPrefix.endian || resolvedPrefix.endian === "le")) {
         return "";
       }
-      return `, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix.format, codecType)})`;
+      return fragment`, size: PrefixedArraySize(${getNumberCodecExpression(resolvedPrefix, codecType)})`;
     }
     default:
       return "";
@@ -1140,36 +1239,61 @@ function getHiddenAffixManifest(node, self) {
     const manifest = visit(node, self);
     return { encoder: manifest.encoder, decoder: manifest.decoder };
   }
-  const constantBytes = getConstantBytesExpression(node);
+  const constantBytes = getConstantBytesExpression(node, self);
   return {
     encoder: fragment`${use("getConstantEncoder", "solanaCodecsDataStructures")}(${constantBytes})`,
     decoder: fragment`${use("getConstantDecoder", "solanaCodecsDataStructures")}(${constantBytes})`
   };
 }
-function getConstantBytesExpression(node) {
-  const valueNode = node.value;
-  const typeNode = node.type;
-  if (valueNode?.kind !== "numberValueNode") {
+function getConstantBytesExpression(node, self) {
+  if (node.value.kind !== "numberValueNode") {
     throw new Error(
-      `Unsupported hidden affix constant value kind: ${valueNode?.kind}`
+      `Unsupported hidden affix constant value kind: ${node.value.kind}`
     );
   }
-  const value = Number(valueNode.number);
-  if (typeNode?.kind === "numberTypeNode") {
-    return fragment`${use(`get${getNumberCodecName(typeNode.format)}Encoder`, "solanaCodecsNumbers")}().encode(${value})`;
+  const manifest = visit(node.type, self);
+  if (!["int", "BigInt", "double"].includes(manifest.type.content)) {
+    throw new Error(`Unsupported hidden affix constant type kind: ${node.type.kind}`);
   }
-  if (typeNode?.kind === "preOffsetTypeNode") {
-    const inner = typeNode.type;
-    if (inner?.kind !== "numberTypeNode") {
-      throw new Error(
-        `Unsupported hidden affix pre-offset inner type kind: ${inner?.kind}`
-      );
-    }
-    return fragment`${use("padLeftEncoder", "solanaCodecsCore")}(${use(`get${getNumberCodecName(inner.format)}Encoder`, "solanaCodecsNumbers")}(), ${typeNode.offset}).encode(${value})`;
+  const value = getDartValueFragment(node.value, manifest.type.content);
+  return fragment`${manifest.encoder}.encode(${value})`;
+}
+function getOffsetManifest(node, self) {
+  if (!Number.isSafeInteger(node.offset)) {
+    throw new Error("Expected a safe integer for a codec offset");
   }
-  throw new Error(
-    `Unsupported hidden affix constant type kind: ${typeNode?.kind}`
-  );
+  const manifest = visit(node.type, self);
+  const pre = node.kind === "preOffsetTypeNode";
+  const key = pre ? "preOffset" : "postOffset";
+  if (node.strategy === "padded") {
+    const side = pre ? "Left" : "Right";
+    const offset = getNonNegativeInteger(node.offset);
+    return {
+      ...manifest,
+      encoder: fragment`${use(`pad${side}Encoder`, "solanaCodecsCore")}(${manifest.encoder}, ${offset})`,
+      decoder: fragment`${use(`pad${side}Decoder`, "solanaCodecsCore")}(${manifest.decoder}, ${offset})`
+    };
+  }
+  let expression;
+  switch (node.strategy) {
+    case "absolute":
+      expression = node.offset < 0 ? `scope.wrapBytes(${node.offset})` : String(node.offset);
+      break;
+    case "relative":
+      expression = `scope.${key} + ${node.offset}`;
+      break;
+    case "preOffset":
+      expression = `scope.preOffset + ${node.offset}`;
+      break;
+    default:
+      throw new Error(`Unsupported offset strategy: ${node.strategy}`);
+  }
+  const config = fragment`${use("OffsetConfig", "solanaCodecsCore")}(${key}: (scope) => ${expression})`;
+  return {
+    ...manifest,
+    encoder: fragment`${use("offsetEncoder", "solanaCodecsCore")}(${manifest.encoder}, ${config})`,
+    decoder: fragment`${use("offsetDecoder", "solanaCodecsCore")}(${manifest.decoder}, ${config})`
+  };
 }
 
 // src/fragments/discriminatorConstants.ts
@@ -1302,7 +1426,7 @@ ${ctorParams}
   const decodeFnName = scope.nameApi.accountDecodeFunction(name);
   const sizeFragment = node.size != null ? fragment`
 /// The size of the [${fragmentFromString(typeName)}] account data in bytes.
-const int ${fragmentFromString(scope.nameApi.accountSizeConstant(name))} = ${fragmentFromString(String(node.size))};` : emptyFragment();
+const int ${fragmentFromString(scope.nameApi.accountSizeConstant(name))} = ${fragmentFromString(getNonNegativeInteger(node.size))};` : emptyFragment();
   const discFragment = getDiscriminatorConstantsFragment(node, scope);
   const discriminatorValidation = getDiscriminatorValidationFragment(
     node,
@@ -1416,9 +1540,10 @@ function getErrorPageFragment(programNode, scope) {
       programName,
       err.name
     );
+    getNonNegativeInteger(err.code);
     const hexCode = `0x${err.code.toString(16)}`;
-    const docs = err.docs?.length ? err.docs.map((d) => `/// ${d}`).join("\n") + "\n" : "";
-    const message = err.message ? `/// Message: "${err.message}"
+    const docs = err.docs?.length ? err.docs.map(toDartDocComment).join("\n") + "\n" : "";
+    const message = err.message ? `${toDartDocComment(`Message: "${err.message}"`)}
 ` : "";
     return `${docs}${message}const int ${constName} = ${hexCode}; // ${err.code}`;
   }).join("\n\n");
@@ -1428,7 +1553,7 @@ function getErrorPageFragment(programNode, scope) {
       err.name
     );
     const message = err.message ?? err.name;
-    return `    ${constName}: '${escapeString(message)}',`;
+    return `    ${constName}: ${toDartStringLiteral(message)},`;
   }).join("\n");
   const errorMessageFnName = scope.nameApi.errorMessageFunction(programName);
   const isErrorFnName = `is${pascalCase(programName)}Error`;
@@ -1454,8 +1579,8 @@ bool ${fragmentFromString(isErrorFnName)}(int code) {
   return _${fragmentFromString(camelCase(programName))}ErrorMessages.containsKey(code);
 }`;
 }
-function escapeString(str) {
-  return str.replace(/'/g, "\\'").replace(/\n/g, "\\n");
+function toDartDocComment(value) {
+  return value.split(/\r\n?|\n/).map((line) => `/// ${line}`).join("\n");
 }
 
 // src/fragments/indexPage.ts
@@ -1581,10 +1706,28 @@ ${dataCtorInitializers}` : ""};`;
   const dataEncoderName = `get${typeName}InstructionDataEncoder`;
   const dataDecoderName = `get${typeName}InstructionDataDecoder`;
   const dataCodecName = `get${typeName}InstructionDataCodec`;
-  const argNames = new Set(args.map((a) => camelCase(a.name)));
-  const accountNames = new Set(accounts.map((a) => camelCase(a.name)));
-  const hasProgramAddressCollision = argNames.has("programAddress") || accountNames.has("programAddress");
-  const instrProgramParam = hasProgramAddressCollision ? "instructionProgramAddress" : "programAddress";
+  const usedNames = /* @__PURE__ */ new Set([
+    ...args.map((arg) => camelCase(arg.name)),
+    ...accounts.map((account) => camelCase(account.name))
+  ]);
+  const instrProgramParam = reserveName(
+    usedNames.has("programAddress") ? "instructionProgramAddress" : "programAddress",
+    usedNames
+  );
+  const instructionDataLocal = reserveName("instructionData", usedNames);
+  const signerParams = /* @__PURE__ */ new Map();
+  for (const account of accounts) {
+    if (account.isSigner === "either") {
+      signerParams.set(
+        account,
+        reserveName(`${camelCase(account.name)}IsSigner`, usedNames)
+      );
+    }
+  }
+  const signerParamDeclarations = [...signerParams.values()].map((parameter) => `  bool ${parameter} = true,`).join("\n");
+  const signerParamDocs = [...signerParams.entries()].map(
+    ([account, parameter]) => `/// Set [${parameter}] to false when [${camelCase(account.name)}] does not sign (for example, a multisig authority).`
+  ).join("\n");
   const accountParams = accounts.map((acc) => {
     const fieldName = camelCase(acc.name);
     const isRequired = !(acc.isOptional ?? false);
@@ -1604,7 +1747,7 @@ ${dataCtorInitializers}` : ""};`;
   }).join("\n");
   const accountMetas = accounts.map((acc) => {
     const fieldName = camelCase(acc.name);
-    const role = getAccountRole(acc);
+    const role = getAccountRole(acc, signerParams.get(acc));
     const isOptional = acc.isOptional ?? false;
     if (isOptional) {
       if (optionalAccountStrategy === "omitted") {
@@ -1687,13 +1830,15 @@ Codec<${fragmentFromString(dataClassName)}, ${fragmentFromString(dataClassName)}
   return combineCodec(${fragmentFromString(dataEncoderName)}(), ${fragmentFromString(dataDecoderName)}());
 }`);
   parts.push(fragment`
-/// Creates a [${fragmentFromString(typeName)}] instruction.
+/// Creates a [${fragmentFromString(typeName)}] instruction.${fragmentFromString(signerParamDocs ? `
+${signerParamDocs}` : "")}
 Instruction ${fragmentFromString(instrFnName)}({
   required Address ${fragmentFromString(instrProgramParam)},
 ${fragmentFromString(accountParams)}
-${fragmentFromString(argParams)}
+${fragmentFromString(argParams)}${fragmentFromString(signerParamDeclarations ? `
+${signerParamDeclarations}` : "")}
 }) {
-  final instructionData = ${fragmentFromString(dataClassName)}(
+  final ${instructionDataLocal} = ${fragmentFromString(dataClassName)}(
 ${fragmentFromString(dataConstruction)}
   );
 
@@ -1702,7 +1847,7 @@ ${fragmentFromString(dataConstruction)}
     accounts: [
 ${fragmentFromString(accountMetas)}
     ],
-    data: ${fragmentFromString(dataEncoderName)}().encode(instructionData),
+    data: ${fragmentFromString(dataEncoderName)}().encode(${instructionDataLocal}),
   );
 }`);
   parts.push(fragment`
@@ -1721,13 +1866,20 @@ ${fragmentFromString(dataClassName)} ${fragmentFromString(parseFnName)}(Instruct
   }
   return result;
 }
-function getAccountRole(acc) {
-  const isSigner = acc.isSigner === true || acc.isSigner === "either";
-  const isWritable = acc.isWritable ?? false;
-  if (isSigner && isWritable) return "AccountRole.writableSigner";
-  if (isSigner) return "AccountRole.readonlySigner";
-  if (isWritable) return "AccountRole.writable";
-  return "AccountRole.readonly";
+function reserveName(preferredName, usedNames) {
+  let name = preferredName;
+  while (usedNames.has(name)) {
+    name = `${name}_`;
+  }
+  usedNames.add(name);
+  return name;
+}
+function getAccountRole(acc, signerParameter) {
+  const role = acc.isWritable ? "AccountRole.writable" : "AccountRole.readonly";
+  if (signerParameter) {
+    return `${signerParameter} ? ${role}Signer : ${role}`;
+  }
+  return acc.isSigner === true ? `${role}Signer` : role;
 }
 function isDiscriminatorArg(arg, node) {
   const discriminators = node.discriminators ?? [];
@@ -1780,9 +1932,9 @@ function getPdaPageFragment(node, scope) {
   for (const seed of seeds) {
     if (seed.kind === "constantPdaSeedNode") {
       if (seed.value.kind === "bytesValueNode") {
-        seedValues.push(`    Uint8List.fromList(${bytesValueToDart(seed.value.data)}),`);
+        seedValues.push(`    ${getDartValueFragment(seed.value).content},`);
       } else if (seed.value.kind === "stringValueNode") {
-        seedValues.push(`    '${seed.value.string}',`);
+        seedValues.push(`    ${toDartStringLiteral(seed.value.string)},`);
       } else if (seed.value.kind === "publicKeyValueNode") {
         const wellKnownSeedName = WELL_KNOWN_ADDRESSES.get(seed.value.publicKey);
         if (wellKnownSeedName) {
@@ -1792,13 +1944,14 @@ function getPdaPageFragment(node, scope) {
           );
         } else {
           seedValues.push(
-            `    getAddressEncoder().encode(Address('${seed.value.publicKey}')),`
+            `    getAddressEncoder().encode(Address(${toDartStringLiteral(seed.value.publicKey)})),`
           );
         }
       } else if (seed.value.kind === "numberValueNode") {
         const manifest = visit(seed.type, scope.typeManifestVisitor);
         seedManifests.push(manifest);
-        seedValues.push(`    ${manifest.encoder.content}.encode(${seed.value.number}),`);
+        const value = getDartValueFragment(seed.value, manifest.type.content);
+        seedValues.push(`    ${manifest.encoder.content}.encode(${value.content}),`);
       }
     } else if (seed.kind === "variablePdaSeedNode") {
       const manifest = visit(seed.type, scope.typeManifestVisitor);
@@ -1812,7 +1965,7 @@ function getPdaPageFragment(node, scope) {
   if (wellKnownProgramName) {
     use(wellKnownProgramName, "solanaAddresses");
   }
-  const programIdParam = node.programId ? wellKnownProgramName ? `Address programAddress = ${wellKnownProgramName}` : `Address programAddress = const Address('${node.programId}')` : "required Address programAddress";
+  const programIdParam = node.programId ? wellKnownProgramName ? `Address programAddress = ${wellKnownProgramName}` : `Address programAddress = const Address(${toDartStringLiteral(node.programId)})` : "required Address programAddress";
   const typedDataImport = hasByteSeeds ? use("Uint8List", "dartTypedData") : fragmentFromString("");
   const metaImport = hasSeedsClass ? use("immutable", "meta") : fragmentFromString("");
   const parts = [
@@ -1859,14 +2012,6 @@ ${fragmentFromString(seedValues.join("\n"))}
   }
   return result;
 }
-function bytesValueToDart(hex) {
-  const clean = hex.replace(/^0x/, "");
-  const pairs = [];
-  for (let i = 0; i < clean.length; i += 2) {
-    pairs.push(`0x${clean.slice(i, i + 2)}`);
-  }
-  return `[${pairs.join(", ")}]`;
-}
 function getProgramPageFragment(node, scope) {
   const name = node.name;
   const addressConstName = scope.nameApi.programAddressConstant(name);
@@ -1887,7 +2032,7 @@ const ${fragmentFromString(addressConstName)} = ${fragmentFromString(wellKnownNa
 ${use("Address", "solanaAddresses")}
 
 /// The address of the ${fragmentFromString(pascalCase(name))} program.
-const ${fragmentFromString(addressConstName)} = Address('${fragmentFromString(node.publicKey)}');`;
+const ${fragmentFromString(addressConstName)} = Address(${fragmentFromString(toDartStringLiteral(node.publicKey))});`;
   const parts = [addressDeclaration];
   const accounts = node.accounts ?? [];
   if (accounts.length > 0) {
@@ -2028,7 +2173,7 @@ function getValueFragment(value, dartType) {
     case "booleanValueNode":
       return fragmentFromString(String(value.boolean));
     case "stringValueNode":
-      return fragmentFromString(`'${value.string.replaceAll("'", "\\'")}'`);
+      return fragmentFromString(toDartStringLiteral(value.string));
     case "bytesValueNode": {
       const clean = value.data.replace(/^0x/, "");
       const bytes = clean.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16)) ?? [];
@@ -2126,6 +2271,7 @@ function getDataEnumPageFragment(node, variants, scope) {
   const decoderVariants = [];
   const encodeCases = [];
   const decodeCases = [];
+  let pageHasListEnums = false;
   const allVariantManifests = [];
   for (let i = 0; i < variants.length; i++) {
     const variant = variants[i];
@@ -2173,10 +2319,14 @@ function getDataEnumPageFragment(node, variants, scope) {
       const ctorSignature = fields.length === 0 ? `  const ${variantClassName}();` : `  const ${variantClassName}({
 ${ctorParams}
   });`;
-      const eqChecks = fields.length === 0 ? "true" : fields.map((f) => `${camelCase(f.name)} == other.${camelCase(f.name)}`).join(" &&\n          ");
-      const hashExpression = getHashExpression(
-        fields.map((f) => camelCase(f.name))
-      );
+      const eqChecks = fields.length === 0 ? "true" : fields.map((f, index) => {
+        const fieldName = camelCase(f.name);
+        return isListManifest(fieldManifests[index].manifest) ? `_listEquals(${fieldName}, other.${fieldName})` : `${fieldName} == other.${fieldName}`;
+      }).join(" &&\n          ");
+      const hashExpression = getValueHashExpression(fields, fieldManifests);
+      if (fieldManifests.some(({ manifest }) => isListManifest(manifest))) {
+        pageHasListEnums = true;
+      }
       const toStringFields = fields.map((f) => `${camelCase(f.name)}: $${camelCase(f.name)}`).join(", ");
       variantClasses.push(`final class ${variantClassName} extends ${typeName} {
 ${ctorSignature}
@@ -2282,7 +2432,7 @@ sealed class ${fragmentFromString(typeName)} {
   const ${fragmentFromString(typeName)}();
 }
 
-${fragmentFromString(variantClasses.join("\n\n"))}
+${fragmentFromString(variantClasses.join("\n\n"))}${pageHasListEnums ? LIST_VALUE_HELPERS : ""}
 
 Encoder<${fragmentFromString(typeName)}> ${fragmentFromString(encoderName)}() {
   return transformEncoder<Map<String, Object?>, ${fragmentFromString(typeName)}>(
@@ -2325,6 +2475,7 @@ function getStructPageFragment(node, scope) {
   const structNode = node.type;
   if (structNode.kind !== "structTypeNode") return emptyFragment();
   const fields = structNode.fields ?? [];
+  let pageHasListStructs = false;
   const fieldManifests = fields.map((f) => ({
     field: f,
     manifest: visit(f.type, scope.typeManifestVisitor)
@@ -2336,10 +2487,13 @@ function getStructPageFragment(node, scope) {
   const ctorSignature = fields.length === 0 ? `  const ${typeName}();` : `  const ${typeName}({
 ${ctorParams}
   });`;
-  const eqChecks = fields.length === 0 ? "true" : fields.map(
-    (f) => `${camelCase(f.name)} == other.${camelCase(f.name)}`
-  ).join(" &&\n          ");
-  fields.length === 0 ? "runtimeType" : fields.map((f) => camelCase(f.name)).join(", ");
+  const eqChecks = fields.length === 0 ? "true" : fieldManifests.map(({ field: f, manifest }, index) => {
+    const fieldName = camelCase(f.name);
+    return isListManifest(manifest) ? `_listEquals(${fieldName}, other.${fieldName})` : `${fieldName} == other.${fieldName}`;
+  }).join(" &&\n          ");
+  if (fieldManifests.some(({ manifest }) => isListManifest(manifest))) {
+    pageHasListStructs = true;
+  }
   const toStringFields = fields.map(
     (f) => `${camelCase(f.name)}: $${camelCase(f.name)}`
   ).join(", ");
@@ -2389,12 +2543,14 @@ ${fragmentFromString(fieldDecls)}
           ${fragmentFromString(eqChecks)};
 
   @override
-  int get hashCode => ${fragmentFromString(getHashExpression(fields.map((f) => camelCase(f.name))))};
+  int get hashCode => ${fragmentFromString(
+    getValueHashExpression(fields, fieldManifests)
+  )};
 
   @override
   String toString() => '${fragmentFromString(typeName)}(${fragmentFromString(toStringFields)})';
 }
-
+${pageHasListStructs ? LIST_VALUE_HELPERS : ""}
 Encoder<${fragmentFromString(typeName)}> ${fragmentFromString(encoderName)}() {
   final structEncoder = getStructEncoder(<(String, Encoder<Object?>)>[
 ${fragmentFromString(encFields)}
@@ -2460,6 +2616,56 @@ Codec<${fragmentFromString(typeName)}, ${fragmentFromString(typeName)}> ${fragme
   return combineCodec(${fragmentFromString(encoderName)}(), ${fragmentFromString(decoderName)}());
 }`;
 }
+function isListManifest(manifest) {
+  return manifest.type.content.startsWith("List<") || manifest.type.content === "Uint8List";
+}
+var LIST_VALUE_HELPERS = `
+bool _listEquals<T>(List<T>? a, List<T>? b) {
+  if (identical(a, b)) return true;
+  if (a == null || b == null) return a == b;
+  if (a.length != b.length) return false;
+  for (var i = 0; i < a.length; i++) {
+    final left = a[i];
+    final right = b[i];
+    if (left is List<Object?> && right is List<Object?>) {
+      if (!_listEquals(left, right)) return false;
+    } else if (left != right) {
+      return false;
+    }
+  }
+  return true;
+}
+
+Object? _deepHash(Object? value) {
+  if (value is List<Object?>) {
+    return Object.hashAll(value.map(_deepHash));
+  }
+  return value;
+}
+
+int _listHashCode<T>(List<T>? a) {
+  if (a == null) return 0;
+  return Object.hashAll(a.map(_deepHash));
+}
+`;
+function getValueHashExpression(fields, fieldManifests) {
+  const fieldNames = fields.map(
+    (f) => camelCase(f.name)
+  );
+  const hasListFields = fieldManifests.some(
+    ({ manifest }) => isListManifest(manifest)
+  );
+  if (!hasListFields) {
+    return getHashExpression(fieldNames);
+  }
+  if (fieldNames.length === 1) {
+    return `_listHashCode(${fieldNames[0]})`;
+  }
+  const hashArgs = fields.map(
+    (f, index) => isListManifest(fieldManifests[index].manifest) ? `_listHashCode(${camelCase(f.name)})` : camelCase(f.name)
+  );
+  return `Object.hash(${hashArgs.join(", ")})`;
+}
 function getHashExpression(fields) {
   if (fields.length === 0) return "runtimeType.hashCode";
   if (fields.length === 1) return `${fields[0]}.hashCode`;
@@ -2533,9 +2739,12 @@ function getRenderMapVisitor(options = {}) {
           visit(node.program, self),
           ...(node.additionalPrograms ?? []).map((p) => visit(p, self))
         ];
-        const mergedProgramMap = mergeRenderMaps(programMaps);
+        const mergedProgramMap = mergeRenderMapsWithoutCollisions(programMaps);
         const categoryMaps = getSharedCategoryIndexMaps(mergedProgramMap);
-        return mergeRenderMaps([mergedProgramMap, ...categoryMaps]);
+        return mergeRenderMapsWithoutCollisions([
+          mergedProgramMap,
+          ...categoryMaps
+        ]);
       },
       visitProgram(node, { self }) {
         const programName = node.name;
@@ -2597,7 +2806,7 @@ function getRenderMapVisitor(options = {}) {
           );
           maps.push(rootMap);
         }
-        return mergeRenderMaps(maps);
+        return mergeRenderMapsWithoutCollisions(maps);
       },
       visitAccount(node, { self }) {
         const fileName = `${snakeCase(node.name)}.dart`;
@@ -2632,6 +2841,18 @@ function getRenderMapVisitor(options = {}) {
     (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)
   );
 }
+function mergeRenderMapsWithoutCollisions(maps) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const map of maps) {
+    for (const path of map.keys()) {
+      if (paths.has(path)) {
+        throw new Error(`Duplicate generated path "${path}"`);
+      }
+      paths.add(path);
+    }
+  }
+  return mergeRenderMaps(maps);
+}
 function getSharedCategoryIndexMaps(renderMap) {
   const categories = /* @__PURE__ */ new Map();
   const categoryIndexNames = {
@@ -2648,7 +2869,6 @@ function getSharedCategoryIndexMaps(renderMap) {
     );
     if (!match) continue;
     const [, category, fileName] = match;
-    if (fileName === categoryIndexNames[category]) continue;
     if (!categories.has(category)) {
       categories.set(category, /* @__PURE__ */ new Set());
     }
@@ -2678,9 +2898,6 @@ function renderVisitor(outputDir, options = {}) {
   } = options;
   return rootNodeVisitor((root) => {
     const normalizedRoot = normalizeRootNode(root);
-    if (deleteFolderBeforeRendering && existsSync(outputDir)) {
-      deleteDirectory(outputDir);
-    }
     const renderMap = visit(
       normalizedRoot,
       getRenderMapVisitor({ nameApi, dependencyMap })
@@ -2692,12 +2909,9 @@ function renderVisitor(outputDir, options = {}) {
         typePathMap[`definedType:${match[1]}`] = renderPath;
       }
     }
+    const files = [];
     for (const [filePath, frag] of renderMap.entries()) {
       const fullPath = join(outputDir, filePath);
-      const dir = dirname(fullPath);
-      if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-      }
       const fileDir = dirname(filePath);
       const internalMap = {};
       for (const [key, typePath] of Object.entries(typePathMap)) {
@@ -2712,6 +2926,13 @@ function renderVisitor(outputDir, options = {}) {
         internalMap[key] = rel;
       }
       const content = resolveFragmentContent(frag, dependencyMap ?? {}, internalMap);
+      files.push([fullPath, content]);
+    }
+    if (deleteFolderBeforeRendering && existsSync(outputDir)) {
+      deleteDirectory(outputDir);
+    }
+    for (const [fullPath, content] of files) {
+      mkdirSync(dirname(fullPath), { recursive: true });
       writeFileSync(fullPath, content, "utf-8");
     }
     if (formatCode) {