@codama/renderers-js 1.3.0 → 1.3.2

package/dist/index.node.mjs

@@ -498,6 +498,7 @@ function getAccountSizeHelpersFragment(scope) {
 }
 
 // src/fragments/accountType.ts
+import { resolveNestedTypeNode } from "@codama/nodes";
 import { getLastNodeFromPath as getLastNodeFromPath4 } from "@codama/visitors-core";
 
 // src/fragments/type.ts
@@ -516,45 +517,57 @@ function getTypeFragment(scope) {
 }
 
 // src/fragments/typeDecoder.ts
+import { isDataEnum, isNode as isNode3 } from "@codama/nodes";
 function getTypeDecoderFragment(scope) {
-  const { name, manifest, nameApi, docs = [] } = scope;
+  const { name, node, manifest, nameApi, docs = [] } = scope;
+  const decoderType = typeof scope.size === "number" ? "FixedSizeDecoder" : "Decoder";
+  const useTypeCast = isNode3(node, "enumTypeNode") && isDataEnum(node) && typeof scope.size === "number";
   return fragmentFromTemplate("typeDecoder.njk", {
     decoderFunction: nameApi.decoderFunction(name),
+    decoderType,
     docs,
     looseName: nameApi.dataArgsType(name),
     manifest,
-    strictName: nameApi.dataType(name)
-  }).mergeImportsWith(manifest.decoder).addImports("solanaCodecsCore", "type Decoder");
+    strictName: nameApi.dataType(name),
+    useTypeCast
+  }).mergeImportsWith(manifest.decoder).addImports("solanaCodecsCore", `type ${decoderType}`);
 }
 
 // src/fragments/typeEncoder.ts
+import { isDataEnum as isDataEnum2, isNode as isNode4 } from "@codama/nodes";
 function getTypeEncoderFragment(scope) {
-  const { name, manifest, nameApi, docs = [] } = scope;
+  const { name, node, manifest, nameApi, docs = [] } = scope;
+  const encoderType = typeof scope.size === "number" ? "FixedSizeEncoder" : "Encoder";
+  const useTypeCast = isNode4(node, "enumTypeNode") && isDataEnum2(node) && typeof scope.size === "number";
   return fragmentFromTemplate("typeEncoder.njk", {
     docs,
     encoderFunction: nameApi.encoderFunction(name),
+    encoderType,
     looseName: nameApi.dataArgsType(name),
     manifest,
-    strictName: nameApi.dataType(name)
-  }).mergeImportsWith(manifest.encoder).addImports("solanaCodecsCore", "type Encoder");
+    strictName: nameApi.dataType(name),
+    useTypeCast
+  }).mergeImportsWith(manifest.encoder).addImports("solanaCodecsCore", `type ${encoderType}`);
 }
 
 // src/fragments/typeCodec.ts
 function getTypeCodecFragment(scope) {
   const { name, manifest, nameApi } = scope;
+  const codecType = typeof scope.size === "number" ? "FixedSizeCodec" : "Codec";
   return mergeFragments(
     [
       getTypeEncoderFragment({ ...scope, docs: scope.encoderDocs }),
       getTypeDecoderFragment({ ...scope, docs: scope.decoderDocs }),
       fragmentFromTemplate("typeCodec.njk", {
         codecFunction: nameApi.codecFunction(name),
+        codecType,
         decoderFunction: nameApi.decoderFunction(name),
         docs: scope.codecDocs,
         encoderFunction: nameApi.encoderFunction(name),
         looseName: nameApi.dataArgsType(name),
         manifest,
         strictName: nameApi.dataType(name)
-      }).addImports("solanaCodecsCore", ["type Codec", "combineCodec"])
+      }).addImports("solanaCodecsCore", [`type ${codecType}`, "combineCodec"])
     ],
     (renders) => renders.join("\n\n")
   );
@@ -578,7 +591,9 @@ function getAccountTypeFragment(scope) {
   return getTypeWithCodecFragment({
     manifest: typeManifest2,
     name: accountNode.name,
-    nameApi
+    nameApi,
+    node: resolveNestedTypeNode(accountNode.data),
+    size: scope.size
   });
 }
 
@@ -587,7 +602,7 @@ import {
   constantDiscriminatorNode,
   constantValueNode,
   constantValueNodeFromBytes,
-  isNode as isNode3,
+  isNode as isNode5,
   isNodeFilter as isNodeFilter2
 } from "@codama/nodes";
 import { visit } from "@codama/visitors-core";
@@ -595,13 +610,13 @@ import { getBase64Decoder } from "@solana/codecs-strings";
 function getDiscriminatorConditionFragment(scope) {
   return mergeFragments(
     scope.discriminators.flatMap((discriminator) => {
-      if (isNode3(discriminator, "sizeDiscriminatorNode")) {
+      if (isNode5(discriminator, "sizeDiscriminatorNode")) {
         return [getSizeConditionFragment(discriminator, scope)];
       }
-      if (isNode3(discriminator, "constantDiscriminatorNode")) {
+      if (isNode5(discriminator, "constantDiscriminatorNode")) {
         return [getByteConditionFragment(discriminator, scope)];
       }
-      if (isNode3(discriminator, "fieldDiscriminatorNode")) {
+      if (isNode5(discriminator, "fieldDiscriminatorNode")) {
         return [getFieldConditionFragment(discriminator, scope)];
       }
       return [];
@@ -625,7 +640,7 @@ function getFieldConditionFragment(discriminator, scope) {
       `Field discriminator "${discriminator.name}" does not have a matching argument with default value.`
     );
   }
-  if (isNode3(field.type, "arrayTypeNode") && isNode3(field.type.item, "numberTypeNode") && field.type.item.format === "u8" && isNode3(field.type.count, "fixedCountNode") && isNode3(field.defaultValue, "arrayValueNode") && field.defaultValue.items.every(isNodeFilter2("numberValueNode"))) {
+  if (isNode5(field.type, "arrayTypeNode") && isNode5(field.type.item, "numberTypeNode") && field.type.item.format === "u8" && isNode5(field.type.count, "fixedCountNode") && isNode5(field.defaultValue, "arrayValueNode") && field.defaultValue.items.every(isNodeFilter2("numberValueNode"))) {
     const base64Bytes = getBase64Decoder().decode(
       new Uint8Array(field.defaultValue.items.map((node) => node.number))
     );
@@ -695,7 +710,7 @@ function getDefaultAddress(defaultValue, programId, linkables) {
 }
 
 // src/fragments/instructionByteDelta.ts
-import { assertIsNode, camelCase as camelCase3, isNode as isNode4 } from "@codama/nodes";
+import { assertIsNode, camelCase as camelCase3, isNode as isNode6 } from "@codama/nodes";
 import { getLastNodeFromPath as getLastNodeFromPath6 } from "@codama/visitors-core";
 function getInstructionByteDeltaFragment(scope) {
   const { byteDeltas } = getLastNodeFromPath6(scope.instructionPath);
@@ -709,16 +724,16 @@ const byteDelta: number = [${r.join(",")}].reduce((a, b) => a + b, 0);`
 }
 function getByteDeltaFragment(byteDelta, scope) {
   const bytesFragment = (() => {
-    if (isNode4(byteDelta.value, "numberValueNode")) {
+    if (isNode6(byteDelta.value, "numberValueNode")) {
       return getNumberValueNodeFragment(byteDelta);
     }
-    if (isNode4(byteDelta.value, "argumentValueNode")) {
+    if (isNode6(byteDelta.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment(byteDelta);
     }
-    if (isNode4(byteDelta.value, "accountLinkNode")) {
+    if (isNode6(byteDelta.value, "accountLinkNode")) {
       return getAccountLinkNodeFragment(byteDelta, scope);
     }
-    if (isNode4(byteDelta.value, "resolverValueNode")) {
+    if (isNode6(byteDelta.value, "resolverValueNode")) {
       return getResolverValueNodeFragment(byteDelta, scope);
     }
     return null;
@@ -756,6 +771,7 @@ function getResolverValueNodeFragment(byteDelta, scope) {
 }
 
 // src/fragments/instructionData.ts
+import { structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes2 } from "@codama/nodes";
 import { getLastNodeFromPath as getLastNodeFromPath7 } from "@codama/visitors-core";
 function getInstructionDataFragment(scope) {
   const { instructionPath, dataArgsManifest, nameApi, customInstructionData } = scope;
@@ -767,14 +783,16 @@ function getInstructionDataFragment(scope) {
   return getTypeWithCodecFragment({
     manifest: dataArgsManifest,
     name: instructionDataName,
-    nameApi
+    nameApi,
+    node: structTypeNodeFromInstructionArgumentNodes2(instructionNode.arguments),
+    size: scope.size
   });
 }
 
 // src/fragments/discriminatorConstants.ts
 import {
   camelCase as camelCase4,
-  isNode as isNode5,
+  isNode as isNode7,
   isNodeFilter as isNodeFilter3,
   VALUE_NODES
 } from "@codama/nodes";
@@ -805,7 +823,7 @@ function getConstantDiscriminatorConstantFragment(discriminatorNode, scope) {
 function getFieldDiscriminatorConstantFragment(discriminatorNode, scope) {
   const { fields, prefix, typeManifestVisitor } = scope;
   const field = fields.find((f) => f.name === discriminatorNode.name);
-  if (!field || !field.defaultValue || !isNode5(field.defaultValue, VALUE_NODES)) {
+  if (!field || !field.defaultValue || !isNode7(field.defaultValue, VALUE_NODES)) {
     return null;
   }
   const name = camelCase4(`${prefix}_${discriminatorNode.name}`);
@@ -843,18 +861,18 @@ function getInstructionExtraArgsFragment(scope) {
 }
 
 // src/fragments/instructionFunction.ts
-import { camelCase as camelCase9, isNode as isNode10, isNodeFilter as isNodeFilter4, pascalCase as pascalCase5 } from "@codama/nodes";
+import { camelCase as camelCase9, isNode as isNode12, isNodeFilter as isNodeFilter4, pascalCase as pascalCase5 } from "@codama/nodes";
 import {
   findProgramNodeFromPath as findProgramNodeFromPath3,
   getLastNodeFromPath as getLastNodeFromPath12
 } from "@codama/visitors-core";
 
 // src/fragments/instructionInputResolved.ts
-import { camelCase as camelCase6, isNode as isNode7, parseOptionalAccountStrategy } from "@codama/nodes";
+import { camelCase as camelCase6, isNode as isNode9, parseOptionalAccountStrategy } from "@codama/nodes";
 import { getLastNodeFromPath as getLastNodeFromPath9 } from "@codama/visitors-core";
 
 // src/fragments/instructionInputDefault.ts
-import { camelCase as camelCase5, isNode as isNode6 } from "@codama/nodes";
+import { camelCase as camelCase5, isNode as isNode8 } from "@codama/nodes";
 import { visit as visit3 } from "@codama/visitors-core";
 function getInstructionInputDefaultFragment(scope) {
   const { input, optionalAccountStrategy, asyncResolvers, useAsync, nameApi, typeManifestVisitor, getImportFrom } = scope;
@@ -867,7 +885,7 @@ function getInstructionInputDefaultFragment(scope) {
   const { defaultValue } = input;
   const defaultFragment = (renderedValue, isWritable) => {
     const inputName = camelCase5(input.name);
-    if (input.kind === "instructionAccountNode" && isNode6(defaultValue, "resolverValueNode")) {
+    if (input.kind === "instructionAccountNode" && isNode8(defaultValue, "resolverValueNode")) {
       return fragment(`accounts.${inputName} = { ...accounts.${inputName}, ...${renderedValue} };`);
     }
     if (input.kind === "instructionAccountNode" && isWritable === void 0) {
@@ -895,17 +913,17 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       }
       return defaultFragment(`expectAddress(accounts.${name}.value)`).addImports("shared", "expectAddress");
     case "pdaValueNode":
-      if (isNode6(defaultValue.pda, "pdaNode")) {
+      if (isNode8(defaultValue.pda, "pdaNode")) {
         const pdaProgram = defaultValue.pda.programId ? fragment(
           `'${defaultValue.pda.programId}' as Address<'${defaultValue.pda.programId}'>`
         ).addImports("solanaAddresses", "type Address") : fragment("programAddress");
         const pdaSeeds2 = defaultValue.pda.seeds.flatMap((seed) => {
-          if (isNode6(seed, "constantPdaSeedNode") && isNode6(seed.value, "programIdValueNode")) {
+          if (isNode8(seed, "constantPdaSeedNode") && isNode8(seed.value, "programIdValueNode")) {
             return [
               fragment(`getAddressEncoder().encode(${pdaProgram.render})`).mergeImportsWith(pdaProgram).addImports("solanaAddresses", "getAddressEncoder")
             ];
           }
-          if (isNode6(seed, "constantPdaSeedNode") && !isNode6(seed.value, "programIdValueNode")) {
+          if (isNode8(seed, "constantPdaSeedNode") && !isNode8(seed.value, "programIdValueNode")) {
             const typeManifest2 = visit3(seed.type, typeManifestVisitor);
             const valueManifest2 = visit3(seed.value, typeManifestVisitor);
             return [
@@ -914,18 +932,18 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
               ).mergeImportsWith(typeManifest2.encoder, valueManifest2.value)
             ];
           }
-          if (isNode6(seed, "variablePdaSeedNode")) {
+          if (isNode8(seed, "variablePdaSeedNode")) {
             const typeManifest2 = visit3(seed.type, typeManifestVisitor);
             const valueSeed = defaultValue.seeds.find((s) => s.name === seed.name)?.value;
             if (!valueSeed) return [];
-            if (isNode6(valueSeed, "accountValueNode")) {
+            if (isNode8(valueSeed, "accountValueNode")) {
               return [
                 fragment(
                   `${typeManifest2.encoder.render}.encode(expectAddress(accounts.${camelCase5(valueSeed.name)}.value))`
                 ).mergeImportsWith(typeManifest2.encoder).addImports("shared", "expectAddress")
               ];
             }
-            if (isNode6(valueSeed, "argumentValueNode")) {
+            if (isNode8(valueSeed, "argumentValueNode")) {
               return [
                 fragment(
                   `${typeManifest2.encoder.render}.encode(expectSome(args.${camelCase5(valueSeed.name)}))`
@@ -950,12 +968,12 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       const pdaFunction = nameApi.pdaFindFunction(defaultValue.pda.name);
       const pdaArgs = [];
       const pdaSeeds = defaultValue.seeds.map((seed) => {
-        if (isNode6(seed.value, "accountValueNode")) {
+        if (isNode8(seed.value, "accountValueNode")) {
           return fragment(
             `${seed.name}: expectAddress(accounts.${camelCase5(seed.value.name)}.value)`
           ).addImports("shared", "expectAddress");
         }
-        if (isNode6(seed.value, "argumentValueNode")) {
+        if (isNode8(seed.value, "argumentValueNode")) {
           return fragment(`${seed.name}: expectSome(args.${camelCase5(seed.value.name)})`).addImports(
             "shared",
             "expectSome"
@@ -1018,14 +1036,14 @@ accounts.${inputName}.isWritable = ${isWritable ? "true" : "false"}`
       }
       const negatedCondition = !ifTrueRenderer;
       let condition = "true";
-      if (isNode6(defaultValue.condition, "resolverValueNode")) {
+      if (isNode8(defaultValue.condition, "resolverValueNode")) {
         const conditionalResolverFunction = nameApi.resolverFunction(defaultValue.condition.name);
         conditionalFragment.addImports(getImportFrom(defaultValue.condition), conditionalResolverFunction).addFeatures(["instruction:resolverScopeVariable"]);
         const conditionalResolverAwait = useAsync && asyncResolvers.includes(defaultValue.condition.name) ? "await " : "";
         condition = `${conditionalResolverAwait}${conditionalResolverFunction}(resolverScope)`;
         condition = negatedCondition ? `!${condition}` : condition;
       } else {
-        const comparedInputName = isNode6(defaultValue.condition, "accountValueNode") ? `accounts.${camelCase5(defaultValue.condition.name)}.value` : `args.${camelCase5(defaultValue.condition.name)}`;
+        const comparedInputName = isNode8(defaultValue.condition, "accountValueNode") ? `accounts.${camelCase5(defaultValue.condition.name)}.value` : `args.${camelCase5(defaultValue.condition.name)}`;
         if (defaultValue.value) {
           const comparedValue = visit3(defaultValue.value, typeManifestVisitor).value;
           conditionalFragment.mergeImportsWith(comparedValue).mergeFeaturesWith(comparedValue);
@@ -1076,7 +1094,7 @@ function getInstructionInputResolvedFragment(scope) {
     const camelName = camelCase6(input.name);
     return [
       inputFragment.mapRender(
-        (r) => isNode7(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
+        (r) => isNode9(input, "instructionArgumentNode") ? `if (!args.${camelName}) {
 ${r}
 }` : `if (!accounts.${camelName}.value) {
 ${r}
@@ -1097,7 +1115,7 @@ ${r}
 import {
   camelCase as camelCase7,
   getAllInstructionArguments,
-  isNode as isNode8,
+  isNode as isNode10,
   parseDocs,
   pascalCase as pascalCase4
 } from "@codama/nodes";
@@ -1135,7 +1153,7 @@ function getAccountsFragment(scope) {
     const resolvedAccount = resolvedInputs.find(
       (input) => input.kind === "instructionAccountNode" && input.name === account.name
     );
-    const hasDefaultValue = !!resolvedAccount.defaultValue && !isNode8(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
+    const hasDefaultValue = !!resolvedAccount.defaultValue && !isNode10(resolvedAccount.defaultValue, ["identityValueNode", "payerValueNode"]) && (useAsync || !isAsyncDefaultValue(resolvedAccount.defaultValue, asyncResolvers));
     const accountDocs = parseDocs(account.docs);
     const docblock = accountDocs.length > 0 ? jsDocblock(accountDocs) : "";
     const optionalSign = hasDefaultValue || resolvedAccount.isOptional ? "?" : "";
@@ -1194,7 +1212,7 @@ function getExtraArgumentsFragment(scope) {
 }
 function getArgumentFragment(arg, argsType, resolvedInputs, renamedArgs) {
   const resolvedArg = resolvedInputs.find(
-    (input) => isNode8(input, "instructionArgumentNode") && input.name === arg.name
+    (input) => isNode10(input, "instructionArgumentNode") && input.name === arg.name
   );
   if (arg.defaultValue && arg.defaultValueStrategy === "omitted") return null;
   const renamedName = renamedArgs.get(arg.name) ?? arg.name;
@@ -1203,7 +1221,7 @@ function getArgumentFragment(arg, argsType, resolvedInputs, renamedArgs) {
 }
 function getRemainingAccountsFragment(instructionNode) {
   const fragments = (instructionNode.remainingAccounts ?? []).flatMap((remainingAccountsNode) => {
-    if (isNode8(remainingAccountsNode.value, "resolverValueNode")) return [];
+    if (isNode10(remainingAccountsNode.value, "resolverValueNode")) return [];
     const { name } = remainingAccountsNode.value;
     const allArguments = getAllInstructionArguments(instructionNode);
     const argumentExists = allArguments.some((arg) => arg.name === name);
@@ -1227,7 +1245,7 @@ import {
   assertIsNode as assertIsNode2,
   camelCase as camelCase8,
   getAllInstructionArguments as getAllInstructionArguments2,
-  isNode as isNode9
+  isNode as isNode11
 } from "@codama/nodes";
 import { getLastNodeFromPath as getLastNodeFromPath11 } from "@codama/visitors-core";
 function getInstructionRemainingAccountsFragment(scope) {
@@ -1242,10 +1260,10 @@ const remainingAccounts: AccountMeta[] = ${r.length === 1 ? r[0] : `[...${r.join
 }
 function getRemainingAccountsFragment2(remainingAccounts, scope) {
   const remainingAccountsFragment = (() => {
-    if (isNode9(remainingAccounts.value, "argumentValueNode")) {
+    if (isNode11(remainingAccounts.value, "argumentValueNode")) {
       return getArgumentValueNodeFragment2(remainingAccounts, scope);
     }
-    if (isNode9(remainingAccounts.value, "resolverValueNode")) {
+    if (isNode11(remainingAccounts.value, "resolverValueNode")) {
       return getResolverValueNodeFragment2(remainingAccounts, scope);
     }
     return null;
@@ -1327,7 +1345,7 @@ function getInstructionFunctionFragment(scope) {
   const hasExtraArgs = (instructionNode.extraArguments ?? []).filter(
     (field) => argIsNotOmitted(field) && (argIsDependent(field) || argHasDefaultValue(field))
   ).length > 0;
-  const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => isNode10(value, "argumentValueNode")).length > 0;
+  const hasRemainingAccountArgs = (instructionNode.remainingAccounts ?? []).filter(({ value }) => isNode12(value, "argumentValueNode")).length > 0;
   const hasAnyArgs = hasDataArgs || hasExtraArgs || hasRemainingAccountArgs;
   const hasInput = hasAccounts || hasAnyArgs;
   const instructionDataName = nameApi.instructionDataType(instructionNode.name);
@@ -1526,7 +1544,7 @@ function getInstructionTypeFragment(scope) {
 }
 
 // src/fragments/pdaFunction.ts
-import { isNode as isNode11, isNodeFilter as isNodeFilter5 } from "@codama/nodes";
+import { isNode as isNode13, isNodeFilter as isNodeFilter5 } from "@codama/nodes";
 import { findProgramNodeFromPath as findProgramNodeFromPath6, getLastNodeFromPath as getLastNodeFromPath15, visit as visit4 } from "@codama/visitors-core";
 function getPdaFunctionFragment(scope) {
   const { pdaPath, typeManifestVisitor, nameApi } = scope;
@@ -1534,12 +1552,12 @@ function getPdaFunctionFragment(scope) {
   const programNode = findProgramNodeFromPath6(pdaPath);
   const imports = new ImportMap();
   const seeds = pdaNode.seeds.map((seed) => {
-    if (isNode11(seed, "variablePdaSeedNode")) {
+    if (isNode13(seed, "variablePdaSeedNode")) {
       const seedManifest2 = visit4(seed.type, typeManifestVisitor);
       imports.mergeWith(seedManifest2.looseType, seedManifest2.encoder);
       return { ...seed, typeManifest: seedManifest2 };
     }
-    if (isNode11(seed.value, "programIdValueNode")) {
+    if (isNode13(seed.value, "programIdValueNode")) {
       imports.add("solanaAddresses", "getAddressEncoder");
       return seed;
     }
@@ -1569,7 +1587,7 @@ function getProgramFragment(scope) {
 }
 
 // src/fragments/programAccounts.ts
-import { resolveNestedTypeNode } from "@codama/nodes";
+import { resolveNestedTypeNode as resolveNestedTypeNode2 } from "@codama/nodes";
 function getProgramAccountsFragment(scope) {
   if (scope.programNode.accounts.length === 0) return fragment("");
   return mergeFragments(
@@ -1603,7 +1621,7 @@ function getProgramAccountsIdentifierFunctionFragment(scope) {
         dataName: "data",
         discriminators: account.discriminators ?? [],
         ifTrue: `return ${programAccountsEnum}.${variant};`,
-        struct: resolveNestedTypeNode(account.data)
+        struct: resolveNestedTypeNode2(account.data)
       });
     }),
     (r) => r.join("\n")
@@ -1636,7 +1654,7 @@ function getProgramErrorsFragment(scope) {
 // src/fragments/programInstructions.ts
 import {
   getAllInstructionsWithSubs,
-  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes2
+  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes3
 } from "@codama/nodes";
 function getProgramInstructionsFragment(scope) {
   if (scope.programNode.instructions.length === 0) return fragment("");
@@ -1682,7 +1700,7 @@ function getProgramInstructionsIdentifierFunctionFragment(scope) {
         dataName: "data",
         discriminators: instruction.discriminators ?? [],
         ifTrue: `return ${programInstructionsEnum}.${variant};`,
-        struct: structTypeNodeFromInstructionArgumentNodes2(instruction.arguments)
+        struct: structTypeNodeFromInstructionArgumentNodes3(instruction.arguments)
       });
     }),
     (r) => r.join("\n")
@@ -1717,10 +1735,10 @@ function getProgramInstructionsParsedUnionTypeFragment(scope) {
 }
 
 // src/fragments/typeDiscriminatedUnionHelpers.ts
-import { isDataEnum, isNode as isNode12 } from "@codama/nodes";
+import { isDataEnum as isDataEnum3, isNode as isNode14 } from "@codama/nodes";
 function getTypeDiscriminatedUnionHelpersFragment(scope) {
   const { name, typeNode, nameApi } = scope;
-  const isDiscriminatedUnion = isNode12(typeNode, "enumTypeNode") && isDataEnum(typeNode);
+  const isDiscriminatedUnion = isNode14(typeNode, "enumTypeNode") && isDataEnum3(typeNode);
   if (!isDiscriminatedUnion) {
     return fragment("");
   }
@@ -1773,13 +1791,14 @@ import {
   getAllInstructionsWithSubs as getAllInstructionsWithSubs2,
   getAllPdas,
   getAllPrograms,
-  resolveNestedTypeNode as resolveNestedTypeNode3,
-  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes4
+  resolveNestedTypeNode as resolveNestedTypeNode4,
+  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes5
 } from "@codama/nodes";
 import { RenderMap } from "@codama/renderers-core";
 import {
   extendVisitor as extendVisitor2,
   findProgramNodeFromPath as findProgramNodeFromPath7,
+  getByteSizeVisitor,
   getResolvedInstructionInputsVisitor,
   LinkableDictionary as LinkableDictionary3,
   NodeStack as NodeStack2,
@@ -1793,16 +1812,16 @@ import {
 // src/getTypeManifestVisitor.ts
 import {
   camelCase as camelCase10,
-  isNode as isNode13,
+  isNode as isNode15,
   isNodeFilter as isNodeFilter6,
   isScalarEnum,
   parseDocs as parseDocs2,
   REGISTERED_TYPE_NODE_KINDS,
   REGISTERED_VALUE_NODE_KINDS,
-  resolveNestedTypeNode as resolveNestedTypeNode2,
+  resolveNestedTypeNode as resolveNestedTypeNode3,
   structFieldTypeNode,
   structTypeNode,
-  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes3
+  structTypeNodeFromInstructionArgumentNodes as structTypeNodeFromInstructionArgumentNodes4
 } from "@codama/nodes";
 import {
   extendVisitor,
@@ -1874,7 +1893,7 @@ function getTypeManifestVisitor(input) {
         const decoderImports = new ImportMap().add("solanaCodecsDataStructures", "getBooleanDecoder");
         let sizeEncoder = "";
         let sizeDecoder = "";
-        const resolvedSize = resolveNestedTypeNode2(booleanType.size);
+        const resolvedSize = resolveNestedTypeNode3(booleanType.size);
         if (resolvedSize.format !== "u8" || resolvedSize.endian !== "le") {
           const size = visit5(booleanType.size, self);
           encoderImports.mergeWith(size.encoder);
@@ -1925,7 +1944,7 @@ function getTypeManifestVisitor(input) {
         return manifest;
       },
       visitConstantValue(node, { self }) {
-        if (isNode13(node.type, "bytesTypeNode") && isNode13(node.value, "bytesValueNode")) {
+        if (isNode15(node.type, "bytesTypeNode") && isNode15(node.value, "bytesValueNode")) {
           return visit5(node.value, self);
         }
         return {
@@ -2026,7 +2045,7 @@ function getTypeManifestVisitor(input) {
         const decoderImports = new ImportMap();
         const encoderOptions = [];
         const decoderOptions = [];
-        const enumSize = resolveNestedTypeNode2(enumType.size);
+        const enumSize = resolveNestedTypeNode3(enumType.size);
         if (enumSize.format !== "u8" || enumSize.endian !== "le") {
           const sizeManifest = visit5(enumType.size, self);
           encoderImports.mergeWith(sizeManifest.encoder);
@@ -2082,7 +2101,7 @@ function getTypeManifestVisitor(input) {
         const enumFunction = nameApi.discriminatedUnionFunction(node.enum.name);
         const importFrom = getImportFrom(node.enum);
         const enumNode = linkables.get([...stack.getPath(), node.enum])?.type;
-        const isScalar = enumNode && isNode13(enumNode, "enumTypeNode") ? isScalarEnum(enumNode) : !nonScalarEnums.includes(node.enum.name);
+        const isScalar = enumNode && isNode15(enumNode, "enumTypeNode") ? isScalarEnum(enumNode) : !nonScalarEnums.includes(node.enum.name);
         if (!node.value && isScalar) {
           const variantName2 = nameApi.enumVariant(node.variant);
           manifest.value.setRender(`${enumName}.${variantName2}`).addImports(importFrom, enumName);
@@ -2127,7 +2146,7 @@ function getTypeManifestVisitor(input) {
           strict: nameApi.dataType(instructionDataName)
         };
         const link = customInstructionData.get(instruction.name)?.linkNode;
-        const struct = structTypeNodeFromInstructionArgumentNodes3(instruction.arguments);
+        const struct = structTypeNodeFromInstructionArgumentNodes4(instruction.arguments);
         const manifest = link ? visit5(link, self) : visit5(struct, self);
         parentName = null;
         return manifest;
@@ -2194,7 +2213,7 @@ function getTypeManifestVisitor(input) {
         childManifest.looseType.mapRender((r) => `OptionOrNullable<${r}>`).addImports("solanaOptions", "type OptionOrNullable");
         const encoderOptions = [];
         const decoderOptions = [];
-        const optionPrefix = resolveNestedTypeNode2(optionType.prefix);
+        const optionPrefix = resolveNestedTypeNode3(optionType.prefix);
         if (optionPrefix.format !== "u8" || optionPrefix.endian !== "le") {
           const prefixManifest = visit5(optionType.prefix, self);
           childManifest.encoder.mergeImportsWith(prefixManifest.encoder);
@@ -2468,19 +2487,19 @@ ${jsDocblock(structFieldDocs)}` : "";
   );
 }
 function getArrayLikeSizeOption(count, visitor) {
-  if (isNode13(count, "fixedCountNode")) {
+  if (isNode15(count, "fixedCountNode")) {
     return {
       decoder: fragment(`size: ${count.value}`),
       encoder: fragment(`size: ${count.value}`)
     };
   }
-  if (isNode13(count, "remainderCountNode")) {
+  if (isNode15(count, "remainderCountNode")) {
     return {
       decoder: fragment(`size: 'remainder'`),
       encoder: fragment(`size: 'remainder'`)
     };
   }
-  const prefix = resolveNestedTypeNode2(count.prefix);
+  const prefix = resolveNestedTypeNode3(count.prefix);
   if (prefix.format === "u32" && prefix.endian === "le") {
     return { decoder: fragment(""), encoder: fragment("") };
   }
@@ -2582,6 +2601,7 @@ function getRenderMapVisitor(options = {}) {
     stack
   });
   const resolvedInstructionInputVisitor = getResolvedInstructionInputsVisitor();
+  const byteSizeVisitor = getByteSizeVisitor(linkables, { stack });
   const globalScope = {
     asyncResolvers,
     customAccountData,
@@ -2609,9 +2629,10 @@ function getRenderMapVisitor(options = {}) {
         const scope = {
           ...globalScope,
           accountPath,
+          size: visit6(node, byteSizeVisitor),
           typeManifest: visit6(node, typeManifestVisitor)
         };
-        const fields = resolveNestedTypeNode3(node.data).fields;
+        const fields = resolveNestedTypeNode4(node.data).fields;
         const accountDiscriminatorConstantsFragment = getDiscriminatorConstantsFragment({
           ...scope,
           discriminatorNodes: node.discriminators ?? [],
@@ -2649,6 +2670,8 @@ function getRenderMapVisitor(options = {}) {
           encoderDocs: [],
           manifest: visit6(node, typeManifestVisitor),
           name: node.name,
+          node: node.type,
+          size: visit6(node, byteSizeVisitor),
           typeDocs: node.docs,
           typeNode: node.type
         };
@@ -2685,13 +2708,14 @@ function getRenderMapVisitor(options = {}) {
           extraArgsManifest: visit6(
             definedTypeNode2({
               name: instructionExtraName,
-              type: structTypeNodeFromInstructionArgumentNodes4(node.extraArguments ?? [])
+              type: structTypeNodeFromInstructionArgumentNodes5(node.extraArguments ?? [])
             }),
             typeManifestVisitor
           ),
           instructionPath,
           renamedArgs: getRenamedArgsMap(node),
-          resolvedInputs: visit6(node, resolvedInstructionInputVisitor)
+          resolvedInputs: visit6(node, resolvedInstructionInputVisitor),
+          size: visit6(node, byteSizeVisitor)
         };
         const instructionDiscriminatorConstantsFragment = getDiscriminatorConstantsFragment({
           ...scope,