codama-renderers-dart 0.4.0 → 0.4.2

package/dist/index.browser.js

@@ -207,6 +207,60 @@ function emptyTypeManifest() {
   };
 }
 
+// src/utils/wellKnownAddresses.ts
+var WELL_KNOWN_ADDRESSES = /* @__PURE__ */ new Map([
+  // Agave / Solana native programs
+  ["11111111111111111111111111111111", "systemProgramAddress"],
+  ["AddressLookupTab1e1111111111111111111111111", "addressLookupTableProgramAddress"],
+  ["BPFLoader2111111111111111111111111111111111", "bpfLoaderProgramAddress"],
+  ["BPFLoader1111111111111111111111111111111111", "bpfLoaderDeprecatedProgramAddress"],
+  ["BPFLoaderUpgradeab1e11111111111111111111111", "bpfLoaderUpgradeableProgramAddress"],
+  ["ComputeBudget111111111111111111111111111111", "computeBudgetProgramAddress"],
+  ["Config1111111111111111111111111111111111111", "configProgramAddress"],
+  ["Ed25519SigVerify111111111111111111111111111", "ed25519ProgramAddress"],
+  ["Feature111111111111111111111111111111111111", "featureProgramAddress"],
+  ["1nc1nerator11111111111111111111111111111111", "incineratorAddress"],
+  ["LoaderV411111111111111111111111111111111111", "loaderV4ProgramAddress"],
+  ["NativeLoader1111111111111111111111111111", "nativeLoaderProgramAddress"],
+  ["KeccakSecp256k11111111111111111111111111111", "secp256k1ProgramAddress"],
+  ["Secp256r1SigVerify1111111111111111111111111", "secp256r1ProgramAddress"],
+  ["Stake11111111111111111111111111111111111111", "stakeProgramAddress"],
+  ["StakeConfig1111111111111111111111111111", "stakeConfigAddress"],
+  ["Vote111111111111111111111111111111111111111", "voteProgramAddress"],
+  ["ZkTokenProof1111111111111111111111111111111", "zkTokenProofProgramAddress"],
+  ["ZkE1Gama1Proof11111111111111111111111111111", "zkElgamalProofProgramAddress"],
+  // Sysvars
+  ["SysvarC1ock11111111111111111111111111111111", "sysvarClockAddress"],
+  ["Rent11111111111111111111111111111111111111", "sysvarRentAddress"],
+  ["11111111111111111111111111111111111111111111", "sysvarRecentBlockhashesAddress"],
+  // note: 44 chars
+  ["SysvarFees1111111111111111111111111111111111", "sysvarFeesAddress"],
+  ["Sysvar1nstruct1ons11111111111111111111111111", "sysvarInstructionsAddress"],
+  ["SysvarEpochSchedu1e111111111111111111111111", "sysvarEpochScheduleAddress"],
+  ["SysvarRewards111111111111111111111111111111", "sysvarRewardsAddress"],
+  ["SysvarStakeHistory1111111111111111111111111", "sysvarStakeHistoryAddress"],
+  ["SysvarS1otHashes111111111111111111111111111", "sysvarSlotHashesAddress"],
+  ["SysvarS1otHistory11111111111111111111111111", "sysvarSlotHistoryAddress"],
+  ["Sysvar1111111111111111111111111111111111111", "sysvarOwnerAddress"],
+  // SPL programs
+  ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", "tokenProgramAddress"],
+  ["TokenzQdBNb4qyze1S1U9AHB8MGXmNK1REkTPT5Z3Y", "token2022ProgramAddress"],
+  ["ATokenGPvbdGVxr1b2hvZbsiqW5xWH25ef7s3c8BnQKu", "associatedTokenProgramAddress"],
+  ["Memo1UhkJRfRhVq1sR7Y7Nto1s3J2mXTT3L6Wk4K2m6", "memoProgramAddress"],
+  ["MemoSq4gqABXKKYWVqKkV3m3kb1cTR7F2UMy9r6kFNK", "memoLegacyProgramAddress"],
+  // Metaplex programs
+  ["metaqbxxU9qX8rZXkmUJ7haCrXXz2W1PSUq1Rn3E1od", "tokenMetadataProgramAddress"],
+  ["BGUMAp9V1mQ2KV8t34L5u3gZsXYZaYDBdKkc1xYk1qA1", "mplBubblegumProgramAddress"],
+  ["auth9SigNpDKz4s8cHr3MFBPS1phbRKLSCN3aBe9sS", "authRulesProgramAddress"],
+  ["CoREENxT6tW1Ho6BW6W5Z4N41ci5Xz2mmrR2kErmM5TR", "metaplexCoreProgramAddress"],
+  ["cmtMqR4bPM9sEV3bPnJQq5s2EnYw4N5vQ8hWhEd1xzS", "splAccountCompressionProgramAddress"],
+  ["noopb9skMVngR5Qi4sczwFr1jU4V4F7nm8xzFQK9C", "noopProgramAddress"],
+  // Well-known mints
+  ["So11111111111111111111111111111111111111112", "wrappedSolAddress"],
+  ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "usdcAddress"],
+  ["Es9vMFrzaCERm6YKXx6bqKr1Rmd9b5v3J8rM5e4rfF4", "usdtAddress"]
+]);
+
 // src/visitors/getTypeManifestVisitor.ts
 function getTypeManifestVisitor(input) {
   const { nameApi, linkables, nonScalarEnums = [] } = input;
@@ -264,7 +318,8 @@ function getTypeManifestVisitor(input) {
       const dartType = getNumberDartType(format);
       const codecName = getNumberCodecName(format);
       return {
-        type: dartType === "BigInt" ? use("BigInt", "dartTypedData") : fragmentFromString(dartType),
+        // `BigInt` and other number types live in `dart:core` and need no import.
+        type: fragmentFromString(dartType),
         encoder: fragment`${use(
           `get${codecName}Encoder`,
           "solanaCodecsNumbers"
@@ -494,51 +549,55 @@ function getTypeManifestVisitor(input) {
     },
     visitOptionType(node, { self }) {
       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 noneValueExpr = node.fixed ? ", noneValue: const ZeroesNoneValue()" : "";
       return {
         type: fragment`${itemManifest.type}?`,
         encoder: fragment`${use(
           "getNullableEncoder",
           "solanaCodecsDataStructures"
-        )}(${itemManifest.encoder}${fragmentFromString(prefixExpr)})`,
+        )}<${fragmentFromString(itemTypeStr)}>(${itemManifest.encoder}${fragmentFromString(prefixExpr)}${fragmentFromString(noneValueExpr)})`,
         decoder: fragment`${use(
           "getNullableDecoder",
           "solanaCodecsDataStructures"
-        )}(${itemManifest.decoder}${fragmentFromString(prefixDecoderExpr)})`,
+        )}<${fragmentFromString(itemTypeStr)}>(${itemManifest.decoder}${fragmentFromString(prefixDecoderExpr)}${fragmentFromString(noneValueExpr)})`,
         value: emptyTypeManifest().value,
         isEnum: false
       };
     },
     visitRemainderOptionType(node, { self }) {
       const itemManifest = visit(node.item, self);
+      const itemTypeStr = itemManifest.type.content;
       return {
         type: fragment`${itemManifest.type}?`,
         encoder: fragment`${use(
           "getNullableEncoder",
           "solanaCodecsDataStructures"
-        )}(${itemManifest.encoder}, hasPrefix: false)`,
+        )}<${fragmentFromString(itemTypeStr)}>(${itemManifest.encoder}, hasPrefix: false)`,
         decoder: fragment`${use(
           "getNullableDecoder",
           "solanaCodecsDataStructures"
-        )}(${itemManifest.decoder}, hasPrefix: false)`,
+        )}<${fragmentFromString(itemTypeStr)}>(${itemManifest.decoder}, hasPrefix: false)`,
         value: emptyTypeManifest().value,
         isEnum: false
       };
     },
     visitZeroableOptionType(node, { self }) {
       const itemManifest = visit(node.item, self);
+      const itemTypeStr = itemManifest.type.content;
       return {
         type: fragment`${itemManifest.type}?`,
         encoder: fragment`${use(
           "getNullableEncoder",
           "solanaCodecsDataStructures"
-        )}(${itemManifest.encoder}, hasPrefix: false, noneValue: const ZeroesNoneValue())`,
+        )}<${fragmentFromString(itemTypeStr)}>(${itemManifest.encoder}, hasPrefix: false, noneValue: const ZeroesNoneValue())`,
         decoder: fragment`${use(
           "getNullableDecoder",
           "solanaCodecsDataStructures"
-        )}(${itemManifest.decoder}, hasPrefix: false, noneValue: const ZeroesNoneValue())`,
+        )}<${fragmentFromString(itemTypeStr)}>(${itemManifest.decoder}, hasPrefix: false, noneValue: const ZeroesNoneValue())`,
         value: emptyTypeManifest().value,
         isEnum: false
       };
@@ -561,7 +620,16 @@ function getTypeManifestVisitor(input) {
     },
     visitSizePrefixType(node, { self }) {
       const innerManifest = visit(node.type, self);
-      const prefixManifest = visit(node.prefix, self);
+      const bigIntFormats = /* @__PURE__ */ new Set(["u64", "u128", "i64", "i128"]);
+      let prefixManifest;
+      if (node.prefix.kind === "numberTypeNode" && bigIntFormats.has(node.prefix.format)) {
+        prefixManifest = {
+          encoder: fragment`${use("getU32Encoder", "solanaCodecsNumbers")}()`,
+          decoder: fragment`${use("getU32Decoder", "solanaCodecsNumbers")}()`
+        };
+      } else {
+        prefixManifest = visit(node.prefix, self);
+      }
       return {
         type: innerManifest.type,
         encoder: fragment`${use(
@@ -578,7 +646,7 @@ function getTypeManifestVisitor(input) {
     },
     visitHiddenPrefixType(node, { self }) {
       const innerManifest = visit(node.type, self);
-      const prefixes = node.prefix.map((p) => visit(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(
@@ -605,7 +673,7 @@ function getTypeManifestVisitor(input) {
     },
     visitHiddenSuffixType(node, { self }) {
       const innerManifest = visit(node.type, self);
-      const suffixes = node.suffix.map((s) => visit(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(
@@ -801,6 +869,42 @@ function getSetSizeExpression(node) {
       return "";
   }
 }
+function getHiddenAffixManifest(node, self) {
+  if (node?.kind !== "constantValueNode") {
+    const manifest = visit(node, self);
+    return { encoder: manifest.encoder, decoder: manifest.decoder };
+  }
+  const constantBytes = getConstantBytesExpression(node);
+  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") {
+    throw new Error(
+      `Unsupported hidden affix constant value kind: ${valueNode?.kind}`
+    );
+  }
+  const value = Number(valueNode.number);
+  if (typeNode?.kind === "numberTypeNode") {
+    return fragment`${use(`get${getNumberCodecName(typeNode.format)}Encoder`, "solanaCodecsNumbers")}().encode(${value})`;
+  }
+  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})`;
+  }
+  throw new Error(
+    `Unsupported hidden affix constant type kind: ${typeNode?.kind}`
+  );
+}
 
 // src/fragments/discriminatorConstants.ts
 function getDiscriminatorConstantsFragment(node, scope) {
@@ -866,10 +970,14 @@ function getAccountPageFragment(node, scope) {
     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}({
+${ctorParams}
+  });`;
   const eqChecks = fields.length === 0 ? "true" : fields.map(
     (f) => `${camelCase(f.name)} == other.${camelCase(f.name)}`
   ).join(" &&\n          ");
-  const hashFields = fields.map((f) => camelCase(f.name)).join(", ");
+  const hashFieldNames = fields.map((f) => camelCase(f.name));
+  const hashCodeExpr = hashFieldNames.length === 0 ? "0" : hashFieldNames.length === 1 ? `${hashFieldNames[0]}.hashCode` : `Object.hash(${hashFieldNames.join(", ")})`;
   const toStringFields = fields.map(
     (f) => `${camelCase(f.name)}: $${camelCase(f.name)}`
   ).join(", ");
@@ -916,9 +1024,7 @@ ${use("decodeAccount", "solanaAccounts")}
 
 @immutable
 class ${fragmentFromString(typeName)} {
-  const ${fragmentFromString(typeName)}({
-${fragmentFromString(ctorParams)}
-  });
+  ${fragmentFromString(ctorSignature)}
 
 ${fragmentFromString(fieldDecls)}
 
@@ -930,7 +1036,7 @@ ${fragmentFromString(fieldDecls)}
           ${fragmentFromString(eqChecks)};
 
   @override
-  int get hashCode => Object.hash(${fragmentFromString(hashFields)});
+  int get hashCode => ${fragmentFromString(hashCodeExpr)};
 
   @override
   String toString() => '${fragmentFromString(typeName)}(${fragmentFromString(toStringFields)})';
@@ -1081,13 +1187,20 @@ function getInstructionPageFragment(node, scope) {
     const fieldName = camelCase(arg.name);
     return `  final ${manifest.type.content} ${fieldName};`;
   }).join("\n");
-  const dataCtorParams = allArgManifests.map(({ arg }) => {
+  const dataCtorParams = allArgManifests.map(({ arg, manifest }) => {
     const fieldName = camelCase(arg.name);
     if (isDiscriminatorArg(arg, node)) {
-      return `    this.${fieldName} = ${getDiscriminatorDefault(arg)},`;
+      return isConstDefaultValue(arg.defaultValue) ? `    this.${fieldName} = ${getDiscriminatorDefault(arg)},` : `    ${manifest.type.content}? ${fieldName},`;
     }
     return `    required this.${fieldName},`;
   }).join("\n");
+  const dataCtorInitializers = allArgManifests.map(({ arg }) => {
+    const fieldName = camelCase(arg.name);
+    if (isDiscriminatorArg(arg, node) && !isConstDefaultValue(arg.defaultValue)) {
+      return `      ${fieldName} = ${fieldName} ?? ${getDiscriminatorDefault(arg)}`;
+    }
+    return null;
+  }).filter((value) => value !== null).join(",\n");
   const encFields = allArgManifests.map(({ arg, manifest }) => {
     return `    ('${arg.name}', ${manifest.encoder.content}),`;
   }).join("\n");
@@ -1103,9 +1216,14 @@ function getInstructionPageFragment(node, scope) {
     const accessor = isNullable ? `map['${arg.name}']` : `map['${arg.name}']!`;
     return `      ${camelCase(arg.name)}: ${accessor} as ${typeStr},`;
   }).join("\n");
+  const dataCtorKeyword = dataCtorInitializers ? "" : "const ";
   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 accountParams = accounts.map((acc) => {
     const fieldName = camelCase(acc.name);
     const isRequired = !(acc.isOptional ?? false);
@@ -1115,11 +1233,13 @@ function getInstructionPageFragment(node, scope) {
   const argParams = args.map((arg) => {
     const manifest = argManifestMap.get(arg);
     const fieldName = camelCase(arg.name);
+    const typeStr = manifest.type.content;
     const hasDefault = arg.defaultValue != null;
     if (hasDefault) {
-      return `  ${manifest.type.content}? ${fieldName},`;
+      const nullableType = typeStr.endsWith("?") ? typeStr : `${typeStr}?`;
+      return `  ${nullableType} ${fieldName},`;
     }
-    return `  required ${manifest.type.content} ${fieldName},`;
+    return `  required ${typeStr} ${fieldName},`;
   }).join("\n");
   const accountMetas = accounts.map((acc) => {
     const fieldName = camelCase(acc.name);
@@ -1161,9 +1281,10 @@ ${use("AccountRole", "solanaInstructions")}`
   parts.push(fragment`
 @immutable
 class ${fragmentFromString(dataClassName)} {
-  const ${fragmentFromString(dataClassName)}({
+  ${fragmentFromString(dataCtorKeyword)}${fragmentFromString(dataClassName)}({
 ${fragmentFromString(dataCtorParams)}
-  });
+  })${fragmentFromString(dataCtorInitializers ? ` :
+${dataCtorInitializers}` : "")};
 
 ${fragmentFromString(dataFieldDecls)}
 }`);
@@ -1200,20 +1321,20 @@ Codec<${fragmentFromString(dataClassName)}, ${fragmentFromString(dataClassName)}
   parts.push(fragment`
 /// Creates a [${fragmentFromString(typeName)}] instruction.
 Instruction ${fragmentFromString(instrFnName)}({
-  required Address programAddress,
+  required Address ${fragmentFromString(instrProgramParam)},
 ${fragmentFromString(accountParams)}
 ${fragmentFromString(argParams)}
 }) {
-  final data = ${fragmentFromString(dataClassName)}(
+  final instructionData = ${fragmentFromString(dataClassName)}(
 ${fragmentFromString(dataConstruction)}
   );
 
   return Instruction(
-    programAddress: programAddress,
+    programAddress: ${fragmentFromString(instrProgramParam)},
     accounts: [
 ${fragmentFromString(accountMetas)}
     ],
-    data: ${fragmentFromString(dataEncoderName)}().encode(data),
+    data: ${fragmentFromString(dataEncoderName)}().encode(instructionData),
   );
 }`);
   parts.push(fragment`
@@ -1248,9 +1369,26 @@ function getDiscriminatorDefault(arg, _node) {
     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) {
+    case "numberValueNode":
+    case "booleanValueNode":
+    case "stringValueNode":
+    case "noneValueNode":
+      return true;
+    default:
+      return false;
+  }
+}
 function getDefaultValue(arg) {
   if (!arg.defaultValue) return "null";
   const dv = arg.defaultValue;
@@ -1261,10 +1399,20 @@ function getDefaultValue(arg) {
       return String(dv.boolean);
     case "stringValueNode":
       return `'${dv.string}'`;
-    case "publicKeyValueNode":
+    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";
   }
@@ -1274,6 +1422,9 @@ function getPdaPageFragment(node, scope) {
   const findFnName = scope.nameApi.pdaFindFunction(name);
   const seedsClassName = `${pascalCase(name)}Seeds`;
   const seeds = node.seeds ?? [];
+  const hasByteSeeds = seeds.some(
+    (seed) => seed.kind === "constantPdaSeedNode" && seed.value.kind === "bytesValueNode"
+  );
   const variableSeeds = seeds.filter(
     (s) => s.kind === "variablePdaSeedNode"
   );
@@ -1281,44 +1432,65 @@ function getPdaPageFragment(node, scope) {
     (s) => s.kind === "constantPdaSeedNode"
   );
   const hasSeedsClass = variableSeeds.length > 0;
+  const seedManifests = [];
   const seedFieldDecls = variableSeeds.map((s) => {
     if (s.kind !== "variablePdaSeedNode") return "";
     const manifest = visit(s.type, scope.typeManifestVisitor);
+    seedManifests.push(manifest);
     return `  final ${manifest.type.content} ${camelCase(s.name)};`;
   }).join("\n");
   const seedCtorParams = variableSeeds.map((s) => {
     if (s.kind !== "variablePdaSeedNode") return "";
     return `    required this.${camelCase(s.name)},`;
   }).join("\n");
-  const seedBytesList = [];
+  const seedValues = [];
   for (const seed of seeds) {
     if (seed.kind === "constantPdaSeedNode") {
       if (seed.value.kind === "bytesValueNode") {
-        seedBytesList.push(`    ...${bytesValueToDart(seed.value.data)},`);
+        seedValues.push(`    Uint8List.fromList(${bytesValueToDart(seed.value.data)}),`);
       } else if (seed.value.kind === "stringValueNode") {
-        seedBytesList.push(`    ...utf8.encode('${seed.value.string}'),`);
+        seedValues.push(`    '${seed.value.string}',`);
       } else if (seed.value.kind === "publicKeyValueNode") {
-        seedBytesList.push(`    ...getAddressEncoder().encode(Address('${seed.value.publicKey}')),`);
+        const wellKnownSeedName = WELL_KNOWN_ADDRESSES.get(seed.value.publicKey);
+        if (wellKnownSeedName) {
+          use(wellKnownSeedName, "solanaAddresses");
+          seedValues.push(
+            `    getAddressEncoder().encode(${wellKnownSeedName}),`
+          );
+        } else {
+          seedValues.push(
+            `    getAddressEncoder().encode(Address('${seed.value.publicKey}')),`
+          );
+        }
       } else if (seed.value.kind === "numberValueNode") {
         const manifest = visit(seed.type, scope.typeManifestVisitor);
-        seedBytesList.push(`    ...${manifest.encoder.content}.encode(${seed.value.number}),`);
+        seedManifests.push(manifest);
+        seedValues.push(`    ${manifest.encoder.content}.encode(${seed.value.number}),`);
       }
     } else if (seed.kind === "variablePdaSeedNode") {
       const manifest = visit(seed.type, scope.typeManifestVisitor);
-      seedBytesList.push(
-        `    ...${manifest.encoder.content}.encode(seeds.${camelCase(seed.name)}),`
+      seedManifests.push(manifest);
+      seedValues.push(
+        `    ${manifest.encoder.content}.encode(seeds.${camelCase(seed.name)}),`
       );
     }
   }
-  const programIdParam = node.programId ? `Address programAddress = const Address('${node.programId}')` : "required Address programAddress";
+  const wellKnownProgramName = node.programId ? WELL_KNOWN_ADDRESSES.get(node.programId) : void 0;
+  if (wellKnownProgramName) {
+    use(wellKnownProgramName, "solanaAddresses");
+  }
+  const programIdParam = node.programId ? wellKnownProgramName ? `Address programAddress = ${wellKnownProgramName}` : `Address programAddress = const Address('${node.programId}')` : "required Address programAddress";
+  const typedDataImport = hasByteSeeds ? use("Uint8List", "dartTypedData") : fragmentFromString("");
+  const metaImport = hasSeedsClass ? use("immutable", "meta") : fragmentFromString("");
   const parts = [
     fragment`// Auto-generated. Do not edit.
 // ignore_for_file: type=lint
 
-${use("Uint8List", "dartTypedData")}
-${use("immutable", "meta")}
+${typedDataImport}
+${metaImport}
 ${use("Address", "solanaAddresses")}
-${use("getAddressEncoder", "solanaAddresses")}`
+${use("getAddressEncoder", "solanaAddresses")}
+${use("getProgramDerivedAddress", "solanaAddresses")}`
   ];
   if (hasSeedsClass) {
     parts.push(fragment`
@@ -1338,14 +1510,21 @@ Future<(Address, int)> ${fragmentFromString(findFnName)}({
 ${fragmentFromString(seedsParam)}
   ${fragmentFromString(programIdParam)},
 }) async {
-  final seedBytes = <int>[
-${fragmentFromString(seedBytesList.join("\n"))}
+  final seedValues = <Object>[
+${fragmentFromString(seedValues.join("\n"))}
   ];
 
-  // TODO: Call getProgramDerivedAddress with seedBytes and programAddress
-  throw UnimplementedError('PDA derivation not yet implemented');
+  return getProgramDerivedAddress(
+    programAddress: programAddress,
+    seeds: seedValues,
+  );
 }`);
-  return mergeFragments(parts, (cs) => cs.join("\n"));
+  const result = mergeFragments(parts, (cs) => cs.join("\n"));
+  for (const manifest of seedManifests) {
+    result.imports.mergeWith(manifest.encoder.imports);
+    result.imports.mergeWith(manifest.type.imports);
+  }
+  return result;
 }
 function bytesValueToDart(hex) {
   const clean = hex.replace(/^0x/, "");
@@ -1360,15 +1539,25 @@ function bytesValueToDart(hex) {
 function getProgramPageFragment(node, scope) {
   const name = node.name;
   const addressConstName = scope.nameApi.programAddressConstant(name);
-  const parts = [
-    fragment`// Auto-generated. Do not edit.
+  const wellKnownName = WELL_KNOWN_ADDRESSES.get(node.publicKey);
+  const addressDeclaration = wellKnownName ? addressConstName === wellKnownName ? fragment`// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+/// The address of the ${fragmentFromString(pascalCase(name))} program.
+export 'package:solana_kit_addresses/solana_kit_addresses.dart' show ${fragmentFromString(wellKnownName)};` : fragment`${use(wellKnownName, "solanaAddresses")}
+
+// Auto-generated. Do not edit.
+// ignore_for_file: type=lint
+
+/// The address of the ${fragmentFromString(pascalCase(name))} program.
+const ${fragmentFromString(addressConstName)} = ${fragmentFromString(wellKnownName)};` : fragment`// Auto-generated. Do not edit.
 // ignore_for_file: type=lint
 
 ${use("Address", "solanaAddresses")}
 
 /// The address of the ${fragmentFromString(pascalCase(name))} program.
-const ${fragmentFromString(addressConstName)} = Address('${fragmentFromString(node.publicKey)}');`
-  ];
+const ${fragmentFromString(addressConstName)} = Address('${fragmentFromString(node.publicKey)}');`;
+  const parts = [addressDeclaration];
   const accounts = node.accounts ?? [];
   if (accounts.length > 0) {
     const accountVariants = accounts.map((acc) => `  ${camelCase(acc.name)},`).join("\n");
@@ -1466,6 +1655,8 @@ function getDataEnumPageFragment(node, scope) {
   const variantClasses = [];
   const encoderVariants = [];
   const decoderVariants = [];
+  const encodeCases = [];
+  const decodeCases = [];
   const allVariantManifests = [];
   for (let i = 0; i < enumNode.variants.length; i++) {
     const variant = enumNode.variants[i];
@@ -1491,8 +1682,10 @@ function getDataEnumPageFragment(node, scope) {
         `(${i}, getStructEncoder(<(String, Encoder<Object?>)>[]))`
       );
       decoderVariants.push(
-        `(${i}, getStructDecoder(<(String, Decoder<Object?>)>[]).map((_) => const ${variantClassName}()))`
+        `(${i}, transformDecoder<Map<String, Object?>, Map<String, Object?>>(getStructDecoder(<(String, Decoder<Object?>)>[]), (Map<String, Object?> map, Uint8List bytes, int offset) => <String, Object?>{}))`
       );
+      encodeCases.push(`${variantClassName}() => <String, Object?>{'__kind': ${i}},`);
+      decodeCases.push(`case ${i}: return const ${variantClassName}();`);
     } else if (variant.kind === "enumStructVariantTypeNode") {
       const resolvedStruct = resolveNestedTypeNode(variant.struct);
       const fields = resolvedStruct.fields;
@@ -1507,13 +1700,16 @@ function getDataEnumPageFragment(node, scope) {
         return `  final ${manifest.type.content} ${camelCase(f.name)};`;
       }).join("\n");
       const ctorParams = fields.map((f) => `    required this.${camelCase(f.name)},`).join("\n");
-      const eqChecks = fields.map((f) => `${camelCase(f.name)} == other.${camelCase(f.name)}`).join(" &&\n          ");
-      const hashFields = fields.map((f) => camelCase(f.name)).join(", ");
+      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 toStringFields = fields.map((f) => `${camelCase(f.name)}: $${camelCase(f.name)}`).join(", ");
       variantClasses.push(`final class ${variantClassName} extends ${typeName} {
-  const ${variantClassName}({
-${ctorParams}
-  });
+${ctorSignature}
 
 ${fieldDecls}
 
@@ -1524,7 +1720,7 @@ ${fieldDecls}
           ${eqChecks};
 
   @override
-  int get hashCode => Object.hash(${hashFields});
+  int get hashCode => ${hashExpression};
 
   @override
   String toString() => '${typeName}.${variantClassName}(${toStringFields})';
@@ -1543,15 +1739,19 @@ ${fieldDecls}
           return `${camelCase(f.name)}: ${accessor} as ${typeStr}`;
         }
       ).join(", ");
-      const toMapFields = fields.map(
+      fields.map(
         (f) => `'${f.name}': value.${camelCase(f.name)}`
       ).join(", ");
       encoderVariants.push(
-        `(${i}, transformEncoder(getStructEncoder([${encFields}]), (${variantClassName} value) => <String, Object?>{${toMapFields}}))`
+        `(${i}, getStructEncoder([${encFields}]))`
       );
       decoderVariants.push(
-        `(${i}, transformDecoder(getStructDecoder([${decFields}]), (Map<String, Object?> map, Uint8List bytes, int offset) => ${variantClassName}(${fromMapFields})))`
+        `(${i}, transformDecoder<Map<String, Object?>, Map<String, Object?>>(getStructDecoder([${decFields}]), (Map<String, Object?> map, Uint8List bytes, int offset) => map))`
       );
+      const structPattern = fields.length === 0 ? "" : fields.map((f) => `${camelCase(f.name)}: final ${camelCase(f.name)}`).join(", ");
+      const structMapEntries = fields.length === 0 ? "" : `, ${fields.map((f) => `'${f.name}': ${camelCase(f.name)}`).join(", ")}`;
+      encodeCases.push(`${variantClassName}(${structPattern}) => <String, Object?>{'__kind': ${i}${structMapEntries}},`);
+      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;
@@ -1575,11 +1775,13 @@ ${fieldDecls}
   String toString() => '${typeName}.${variantClassName}($value)';
 }`);
         encoderVariants.push(
-          `(${i}, transformEncoder(${manifest.encoder.content}, (${variantClassName} value) => value.value))`
+          `(${i}, transformEncoder<${manifest.type.content}, Map<String, Object?>>(${manifest.encoder.content}, (Map<String, Object?> map) => map['value']! as ${manifest.type.content}))`
         );
         decoderVariants.push(
-          `(${i}, transformDecoder(${manifest.decoder.content}, (${manifest.type.content} value, Uint8List bytes, int offset) => ${variantClassName}(value)))`
+          `(${i}, transformDecoder<${manifest.type.content}, Map<String, Object?>>(${manifest.decoder.content}, (${manifest.type.content} value, Uint8List bytes, int offset) => <String, Object?>{'value': value}))`
         );
+        encodeCases.push(`${variantClassName}(value: final value) => <String, Object?>{'__kind': ${i}, 'value': value},`);
+        decodeCases.push(`case ${i}: return ${variantClassName}(map['value']! as ${manifest.type.content});`);
       }
     }
   }
@@ -1593,7 +1795,6 @@ ${fieldDecls}
 // ignore_for_file: type=lint
 
 ${use("Uint8List", "dartTypedData")}
-${use("immutable", "meta")}
 ${use("Encoder", "solanaCodecsCore")}
 ${use("Decoder", "solanaCodecsCore")}
 ${use("Codec", "solanaCodecsCore")}
@@ -1614,15 +1815,28 @@ sealed class ${fragmentFromString(typeName)} {
 ${fragmentFromString(variantClasses.join("\n\n"))}
 
 Encoder<${fragmentFromString(typeName)}> ${fragmentFromString(encoderName)}() {
-  return getDiscriminatedUnionEncoder([
-    ${fragmentFromString(encoderVariants.join(",\n    "))},
-  ], size: get${fragmentFromString(sizeCodecName)}Encoder());
+  return transformEncoder<Map<String, Object?>, ${fragmentFromString(typeName)}>(
+    getDiscriminatedUnionEncoder([
+      ${fragmentFromString(encoderVariants.join(",\n      "))},
+    ], size: get${fragmentFromString(sizeCodecName)}Encoder()),
+    (${fragmentFromString(typeName)} value) => switch (value) {
+      ${fragmentFromString(encodeCases.join("\n      "))}
+    },
+  );
 }
 
 Decoder<${fragmentFromString(typeName)}> ${fragmentFromString(decoderName)}() {
-  return getDiscriminatedUnionDecoder([
-    ${fragmentFromString(decoderVariants.join(",\n    "))},
-  ], size: get${fragmentFromString(sizeCodecName)}Decoder());
+  return transformDecoder<Map<String, Object?>, ${fragmentFromString(typeName)}>(
+    getDiscriminatedUnionDecoder([
+      ${fragmentFromString(decoderVariants.join(",\n      "))},
+    ], size: get${fragmentFromString(sizeCodecName)}Decoder()),
+    (Map<String, Object?> map, Uint8List bytes, int offset) {
+      switch (map['__kind']) {
+        ${fragmentFromString(decodeCases.join("\n        "))}
+      }
+      throw StateError('Unsupported ${typeName} discriminator: \${map['__kind']}');
+    },
+  );
 }
 
 Codec<${fragmentFromString(typeName)}, ${fragmentFromString(typeName)}> ${fragmentFromString(codecName)}() {
@@ -1649,10 +1863,13 @@ function getStructPageFragment(node, scope) {
     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}({
+${ctorParams}
+  });`;
   const eqChecks = fields.length === 0 ? "true" : fields.map(
     (f) => `${camelCase(f.name)} == other.${camelCase(f.name)}`
   ).join(" &&\n          ");
-  const hashFields = fields.map((f) => camelCase(f.name)).join(", ");
+  fields.length === 0 ? "runtimeType" : fields.map((f) => camelCase(f.name)).join(", ");
   const toStringFields = fields.map(
     (f) => `${camelCase(f.name)}: $${camelCase(f.name)}`
   ).join(", ");
@@ -1690,9 +1907,7 @@ ${use("getStructDecoder", "solanaCodecsDataStructures")}
 
 @immutable
 class ${fragmentFromString(typeName)} {
-  const ${fragmentFromString(typeName)}({
-${fragmentFromString(ctorParams)}
-  });
+${fragmentFromString(ctorSignature)}
 
 ${fragmentFromString(fieldDecls)}
 
@@ -1704,7 +1919,7 @@ ${fragmentFromString(fieldDecls)}
           ${fragmentFromString(eqChecks)};
 
   @override
-  int get hashCode => Object.hash(${fragmentFromString(hashFields)});
+  int get hashCode => ${fragmentFromString(getHashExpression(fields.map((f) => camelCase(f.name))))};
 
   @override
   String toString() => '${fragmentFromString(typeName)}(${fragmentFromString(toStringFields)})';
@@ -1775,6 +1990,11 @@ Codec<${fragmentFromString(typeName)}, ${fragmentFromString(typeName)}> ${fragme
   return combineCodec(${fragmentFromString(encoderName)}(), ${fragmentFromString(decoderName)}());
 }`;
 }
+function getHashExpression(fields) {
+  if (fields.length === 0) return "runtimeType.hashCode";
+  if (fields.length === 1) return `${fields[0]}.hashCode`;
+  return `Object.hash(${fields.join(", ")})`;
+}
 function getNumberCodecName2(format) {
   switch (format) {
     case "u8":
@@ -1843,7 +2063,9 @@ function getRenderMapVisitor(options = {}) {
           visit(node.program, self),
           ...node.additionalPrograms.map((p) => visit(p, self))
         ];
-        return mergeRenderMaps(programMaps);
+        const mergedProgramMap = mergeRenderMaps(programMaps);
+        const categoryMaps = getSharedCategoryIndexMaps(mergedProgramMap);
+        return mergeRenderMaps([mergedProgramMap, ...categoryMaps]);
       },
       visitProgram(node, { self }) {
         const programName = node.name;
@@ -1890,66 +2112,12 @@ function getRenderMapVisitor(options = {}) {
           maps.push(errorMap);
         }
         const categories = [];
-        if (accountFiles.length > 0) {
-          categories.push("accounts");
-          let indexMap = createRenderMap();
-          indexMap = addToRenderMap(
-            indexMap,
-            "accounts/accounts.dart",
-            getIndexPageFragment(accountFiles)
-          );
-          maps.push(indexMap);
-        }
-        if (instructionFiles.length > 0) {
-          categories.push("instructions");
-          let indexMap = createRenderMap();
-          indexMap = addToRenderMap(
-            indexMap,
-            "instructions/instructions.dart",
-            getIndexPageFragment(instructionFiles)
-          );
-          maps.push(indexMap);
-        }
-        if (typeFiles.length > 0) {
-          categories.push("types");
-          let indexMap = createRenderMap();
-          indexMap = addToRenderMap(
-            indexMap,
-            "types/types.dart",
-            getIndexPageFragment(typeFiles)
-          );
-          maps.push(indexMap);
-        }
-        if (pdaFiles.length > 0) {
-          categories.push("pdas");
-          let indexMap = createRenderMap();
-          indexMap = addToRenderMap(
-            indexMap,
-            "pdas/pdas.dart",
-            getIndexPageFragment(pdaFiles)
-          );
-          maps.push(indexMap);
-        }
-        if (errorFiles.length > 0) {
-          categories.push("errors");
-          let indexMap = createRenderMap();
-          indexMap = addToRenderMap(
-            indexMap,
-            "errors/errors.dart",
-            getIndexPageFragment(errorFiles)
-          );
-          maps.push(indexMap);
-        }
-        if (programFiles.length > 0) {
-          categories.push("programs");
-          let indexMap = createRenderMap();
-          indexMap = addToRenderMap(
-            indexMap,
-            "programs/programs.dart",
-            getIndexPageFragment(programFiles)
-          );
-          maps.push(indexMap);
-        }
+        if (accountFiles.length > 0) categories.push("accounts");
+        if (instructionFiles.length > 0) categories.push("instructions");
+        if (typeFiles.length > 0) categories.push("types");
+        if (pdaFiles.length > 0) categories.push("pdas");
+        if (errorFiles.length > 0) categories.push("errors");
+        if (programFiles.length > 0) categories.push("programs");
         if (categories.length > 0) {
           let rootMap = createRenderMap();
           rootMap = addToRenderMap(
@@ -1994,6 +2162,41 @@ function getRenderMapVisitor(options = {}) {
     (v) => recordLinkablesOnFirstVisitVisitor(v, linkables)
   );
 }
+function getSharedCategoryIndexMaps(renderMap) {
+  const categories = /* @__PURE__ */ new Map();
+  const categoryIndexNames = {
+    accounts: "accounts.dart",
+    instructions: "instructions.dart",
+    types: "types.dart",
+    pdas: "pdas.dart",
+    errors: "errors.dart",
+    programs: "programs.dart"
+  };
+  for (const renderPath of renderMap.keys()) {
+    const match = renderPath.match(
+      /^(accounts|instructions|types|pdas|errors|programs)\/([^/]+\.dart)$/
+    );
+    if (!match) continue;
+    const [, category, fileName] = match;
+    if (fileName === categoryIndexNames[category]) continue;
+    if (!categories.has(category)) {
+      categories.set(category, /* @__PURE__ */ new Set());
+    }
+    categories.get(category).add(fileName);
+  }
+  const maps = [];
+  for (const [category, files] of categories.entries()) {
+    const sortedFiles = [...files].sort();
+    let map = createRenderMap();
+    map = addToRenderMap(
+      map,
+      `${category}/${categoryIndexNames[category]}`,
+      getIndexPageFragment(sortedFiles)
+    );
+    maps.push(map);
+  }
+  return maps;
+}
 
 // src/visitors/renderVisitor.ts
 function renderVisitor(outputDir, options = {}) {