Update enums codecs from latest Web3.js version

This PR updates the JS experimental renderer to use the latest version of the new Web3.js and adjusts the Data Enum and Scalar Enum codecs, now known as Discriminated Union and Enum codecs respectively.
metaplex-foundation · Mar 27, 2024 · 0434144 · 0434144
1 parent bc6e82c
commit 0434144
Show file tree

Hide file tree

Showing 31 changed files with 249 additions and 200 deletions.
diff --git a/.changeset/poor-lions-promise.md b/.changeset/poor-lions-promise.md
@@ -0,0 +1,5 @@
+---
+"@metaplex-foundation/kinobi": minor
+---
+
+Update enums codecs from latest Web3.js version on the JS experimental renderer
diff --git a/src/renderers/js-experimental/fragments/index.ts b/src/renderers/js-experimental/fragments/index.ts
@@ -23,7 +23,7 @@ export * from './programErrors';
 export * from './programInstructions';
 export * from './type';
 export * from './typeCodec';
-export * from './typeDataEnumHelpers';
 export * from './typeDecoder';
+export * from './typeDiscriminatedUnionHelpers';
 export * from './typeEncoder';
 export * from './typeWithCodec';
diff --git a/src/renderers/js-experimental/fragments/typeDataEnumHelpers.njk b/src/renderers/js-experimental/fragments/typeDataEnumHelpers.njk
diff --git a/src/renderers/js-experimental/fragments/typeDiscriminatedUnionHelpers.njk b/src/renderers/js-experimental/fragments/typeDiscriminatedUnionHelpers.njk
@@ -0,0 +1,23 @@
+// Data Enum Helpers.
+{% for variant in typeNode.variants %}
+  {% if variant.kind === 'enumStructVariantTypeNode' %}
+    export function {{ discriminatedUnionFunction }}(kind: '{{ getVariant(variant.name) }}', data: GetDiscriminatedUnionVariantContent<{{ looseName }}, '__kind', '{{ getVariant(variant.name) }}'>): GetDiscriminatedUnionVariant<{{ looseName }}, '__kind', '{{ getVariant(variant.name) }}'>;
+  {% elif variant.kind === 'enumTupleVariantTypeNode' %}
+    export function {{ discriminatedUnionFunction }}(kind: '{{ getVariant(variant.name) }}', data: GetDiscriminatedUnionVariantContent<{{ looseName }}, '__kind', '{{ getVariant(variant.name) }}'>['fields']): GetDiscriminatedUnionVariant<{{ looseName }}, '__kind', '{{ getVariant(variant.name) }}'>;
+  {% else %}
+    export function {{ discriminatedUnionFunction }}(kind: '{{ getVariant(variant.name) }}'): GetDiscriminatedUnionVariant<{{ looseName }}, '__kind', '{{ getVariant(variant.name) }}'>;
+  {% endif %}
+{% endfor %}
+export function {{ discriminatedUnionFunction }}<K extends {{ looseName }}['{{ discriminatedUnionDiscriminator }}'], Data>(
+  kind: K,
+  data?: Data,
+) {
+  return Array.isArray(data) ? { {{ discriminatedUnionDiscriminator }}: kind, fields: data } : { {{ discriminatedUnionDiscriminator }}: kind, ...(data ?? {}) };
+}
+
+export function {{ isDiscriminatedUnionFunction }}<K extends {{ strictName }}['{{ discriminatedUnionDiscriminator }}']>(
+  kind: K,
+  value: {{ strictName }},
+): value is {{ strictName }} & { {{ discriminatedUnionDiscriminator }}: K } {
+  return value.{{ discriminatedUnionDiscriminator }} === kind;
+};
diff --git a/...rimental/fragments/typeDataEnumHelpers.ts → ...ragments/typeDiscriminatedUnionHelpers.ts b/...rimental/fragments/typeDataEnumHelpers.ts → ...ragments/typeDiscriminatedUnionHelpers.ts
@@ -2,30 +2,31 @@ import { TypeNode, isDataEnum, isNode } from '../../../nodes';
 import type { GlobalFragmentScope } from '../getRenderMapVisitor';
 import { Fragment, fragment, fragmentFromTemplate } from './common';
 
-export function getTypeDataEnumHelpersFragment(
+export function getTypeDiscriminatedUnionHelpersFragment(
   scope: Pick<GlobalFragmentScope, 'nameApi'> & {
     name: string;
     typeNode: TypeNode;
   }
 ): Fragment {
   const { name, typeNode, nameApi } = scope;
-  const isDataEnumNode =
+  const isDiscriminatedUnion =
     isNode(typeNode, 'enumTypeNode') && isDataEnum(typeNode);
 
-  if (!isDataEnumNode) {
+  if (!isDiscriminatedUnion) {
     return fragment('');
   }
 
-  return fragmentFromTemplate('typeDataEnumHelpers.njk', {
+  return fragmentFromTemplate('typeDiscriminatedUnionHelpers.njk', {
     strictName: nameApi.dataType(name),
     looseName: nameApi.dataArgsType(name),
-    dataEnumDiscriminator: nameApi.dataEnumDiscriminator(name),
-    getVariant: (variant: string) => nameApi.dataEnumVariant(variant),
-    dataEnumFunction: nameApi.dataEnumFunction(name),
-    isDataEnumFunction: nameApi.isDataEnumFunction(name),
+    discriminatedUnionDiscriminator:
+      nameApi.discriminatedUnionDiscriminator(name),
+    getVariant: (variant: string) => nameApi.discriminatedUnionVariant(variant),
+    discriminatedUnionFunction: nameApi.discriminatedUnionFunction(name),
+    isDiscriminatedUnionFunction: nameApi.isDiscriminatedUnionFunction(name),
     typeNode,
   }).addImports('solanaCodecsDataStructures', [
-    'GetDataEnumKindContent',
-    'GetDataEnumKind',
+    'GetDiscriminatedUnionVariantContent',
+    'GetDiscriminatedUnionVariant',
   ]);
 }
diff --git a/src/renderers/js-experimental/getRenderMapVisitor.ts b/src/renderers/js-experimental/getRenderMapVisitor.ts
@@ -49,7 +49,7 @@ import {
   getProgramErrorsFragment,
   getProgramFragment,
   getProgramInstructionsFragment,
-  getTypeDataEnumHelpersFragment,
+  getTypeDiscriminatedUnionHelpersFragment,
   getTypeWithCodecFragment,
 } from './fragments';
 import {
@@ -447,10 +447,13 @@ export function getRenderMapVisitor(options: GetRenderMapOptions = {}) {
           };
 
           const typeWithCodecFragment = getTypeWithCodecFragment(scope);
-          const typeDataEnumHelpersFragment =
-            getTypeDataEnumHelpersFragment(scope);
+          const typeDiscriminatedUnionHelpersFragment =
+            getTypeDiscriminatedUnionHelpersFragment(scope);
           const imports = new ImportMap()
-            .mergeWith(typeWithCodecFragment, typeDataEnumHelpersFragment)
+            .mergeWith(
+              typeWithCodecFragment,
+              typeDiscriminatedUnionHelpersFragment
+            )
             .remove('generatedTypes', [
               nameApi.dataType(node.name),
               nameApi.dataArgsType(node.name),
@@ -467,7 +470,7 @@ export function getRenderMapVisitor(options: GetRenderMapOptions = {}) {
                 generatedTypes: '.',
               }),
               typeWithCodecFragment,
-              typeDataEnumHelpersFragment,
+              typeDiscriminatedUnionHelpersFragment,
             })
           );
         },

diff --git a/src/renderers/js-experimental/getTypeManifestVisitor.ts b/src/renderers/js-experimental/getTypeManifestVisitor.ts
@@ -171,28 +171,28 @@ export function getTypeManifestVisitor(input: {
               );
             }
             const variantNames = enumType.variants.map(({ name }) =>
-              nameApi.scalarEnumVariant(name)
+              nameApi.enumVariant(name)
             );
             return {
               isEnum: true,
               strictType: fragment(`{ ${variantNames.join(', ')} }`),
               looseType: fragment(`{ ${variantNames.join(', ')} }`),
               encoder: fragment(
-                `getScalarEnumEncoder(${
+                `getEnumEncoder(${
                   currentParentName.strict + encoderOptionsAsString
                 })`,
                 encoderImports.add(
                   'solanaCodecsDataStructures',
-                  'getScalarEnumEncoder'
+                  'getEnumEncoder'
                 )
               ),
               decoder: fragment(
-                `getScalarEnumDecoder(${
+                `getEnumDecoder(${
                   currentParentName.strict + decoderOptionsAsString
                 })`,
                 decoderImports.add(
                   'solanaCodecsDataStructures',
-                  'getScalarEnumDecoder'
+                  'getEnumDecoder'
                 )
               ),
             };
@@ -205,24 +205,32 @@ export function getTypeManifestVisitor(input: {
           );
           mergedManifest.encoder
             .mapRender(
-              (r) => `getDataEnumEncoder([${r}]${encoderOptionsAsString})`
+              (r) =>
+                `getDiscriminatedUnionEncoder([${r}]${encoderOptionsAsString})`
             )
             .mergeImportsWith(encoderImports)
-            .addImports('solanaCodecsDataStructures', ['getDataEnumEncoder']);
+            .addImports('solanaCodecsDataStructures', [
+              'getDiscriminatedUnionEncoder',
+            ]);
           mergedManifest.decoder
             .mapRender(
-              (r) => `getDataEnumDecoder([${r}]${decoderOptionsAsString})`
+              (r) =>
+                `getDiscriminatedUnionDecoder([${r}]${decoderOptionsAsString})`
             )
             .mergeImportsWith(decoderImports)
-            .addImports('solanaCodecsDataStructures', ['getDataEnumDecoder']);
+            .addImports('solanaCodecsDataStructures', [
+              'getDiscriminatedUnionDecoder',
+            ]);
           return mergedManifest;
         },
 
         visitEnumEmptyVariantType(enumEmptyVariantType) {
-          const discriminator = nameApi.dataEnumDiscriminator(
+          const discriminator = nameApi.discriminatedUnionDiscriminator(
+            enumEmptyVariantType.name
+          );
+          const name = nameApi.discriminatedUnionVariant(
             enumEmptyVariantType.name
           );
-          const name = nameApi.dataEnumVariant(enumEmptyVariantType.name);
           const kindAttribute = `${discriminator}: "${name}"`;
           return {
             isEnum: false,
@@ -240,10 +248,12 @@ export function getTypeManifestVisitor(input: {
         },
 
         visitEnumStructVariantType(enumStructVariantType, { self }) {
-          const discriminator = nameApi.dataEnumDiscriminator(
+          const discriminator = nameApi.discriminatedUnionDiscriminator(
+            enumStructVariantType.name
+          );
+          const name = nameApi.discriminatedUnionVariant(
             enumStructVariantType.name
           );
-          const name = nameApi.dataEnumVariant(enumStructVariantType.name);
           const kindAttribute = `${discriminator}: "${name}"`;
           const structManifest = visit(enumStructVariantType.struct, self);
           structManifest.strictType.mapRender(
@@ -258,10 +268,12 @@ export function getTypeManifestVisitor(input: {
         },
 
         visitEnumTupleVariantType(enumTupleVariantType, { self }) {
-          const discriminator = nameApi.dataEnumDiscriminator(
+          const discriminator = nameApi.discriminatedUnionDiscriminator(
+            enumTupleVariantType.name
+          );
+          const name = nameApi.discriminatedUnionVariant(
             enumTupleVariantType.name
           );
-          const name = nameApi.dataEnumVariant(enumTupleVariantType.name);
           const kindAttribute = `${discriminator}: "${name}"`;
           const struct = structTypeNode([
             structFieldTypeNode({

diff --git a/src/renderers/js-experimental/nameTransformers.ts b/src/renderers/js-experimental/nameTransformers.ts
@@ -40,11 +40,11 @@ export type NameTransformerKey =
   | 'accountFetchFromSeedsFunction'
   | 'accountFetchMaybeFromSeedsFunction'
   | 'accountGetSizeFunction'
-  | 'scalarEnumVariant'
-  | 'dataEnumDiscriminator'
-  | 'dataEnumVariant'
-  | 'dataEnumFunction'
-  | 'isDataEnumFunction'
+  | 'enumVariant'
+  | 'discriminatedUnionDiscriminator'
+  | 'discriminatedUnionVariant'
+  | 'discriminatedUnionFunction'
+  | 'isDiscriminatedUnionFunction'
   | 'instructionAsyncInputType'
   | 'instructionSyncInputType'
   | 'instructionType'
@@ -111,11 +111,11 @@ export const DEFAULT_NAME_TRANSFORMERS: NameTransformers = {
   accountFetchMaybeFromSeedsFunction: (name) =>
     `fetchMaybe${pascalCase(name)}FromSeeds`,
   accountGetSizeFunction: (name) => `get${pascalCase(name)}Size`,
-  scalarEnumVariant: (name) => `${pascalCase(name)}`,
-  dataEnumDiscriminator: () => '__kind',
-  dataEnumVariant: (name) => `${pascalCase(name)}`,
-  dataEnumFunction: (name) => `${camelCase(name)}`,
-  isDataEnumFunction: (name) => `is${pascalCase(name)}`,
+  enumVariant: (name) => `${pascalCase(name)}`,
+  discriminatedUnionDiscriminator: () => '__kind',
+  discriminatedUnionVariant: (name) => `${pascalCase(name)}`,
+  discriminatedUnionFunction: (name) => `${camelCase(name)}`,
+  isDiscriminatedUnionFunction: (name) => `is${pascalCase(name)}`,
   instructionAsyncInputType: (name) => `${pascalCase(name)}AsyncInput`,
   instructionSyncInputType: (name) => `${pascalCase(name)}Input`,
   instructionType: (name) => `${pascalCase(name)}Instruction`,

diff --git a/src/renderers/js-experimental/renderValueNodeVisitor.ts b/src/renderers/js-experimental/renderValueNodeVisitor.ts
@@ -24,7 +24,7 @@ export function renderValueNodeVisitor(input: {
     },
     visitEnumValue(node) {
       const enumName = nameApi.dataType(node.enum.name);
-      const enumFunction = nameApi.dataEnumFunction(node.enum.name);
+      const enumFunction = nameApi.discriminatedUnionFunction(node.enum.name);
       const importFrom = node.enum.importFrom ?? 'generatedTypes';
 
       const enumNode = linkables.get(node.enum)?.type;
@@ -34,14 +34,14 @@ export function renderValueNodeVisitor(input: {
           : !nonScalarEnums.includes(node.enum.name);
 
       if (!node.value && isScalar) {
-        const variantName = nameApi.scalarEnumVariant(node.variant);
+        const variantName = nameApi.enumVariant(node.variant);
         return fragment(`${enumName}.${variantName}`).addImports(
           importFrom,
           enumName
         );
       }
 
-      const variantName = nameApi.dataEnumVariant(node.variant);
+      const variantName = nameApi.discriminatedUnionVariant(node.variant);
       if (!node.value) {
         return fragment(`${enumFunction}('${variantName}')`).addImports(
           importFrom,

diff --git a/src/renderers/js-experimental/templates/definedTypesPage.njk b/src/renderers/js-experimental/templates/definedTypesPage.njk
@@ -5,5 +5,5 @@
 {{ imports }}
 
 {{ typeWithCodecFragment }}
-{{ typeDataEnumHelpersFragment }}
+{{ typeDiscriminatedUnionHelpersFragment }}
 {% endblock %}
diff --git a/test/packages/js-experimental/src/generated/types/authorityType.ts b/test/packages/js-experimental/src/generated/types/authorityType.ts
@@ -11,8 +11,8 @@ import {
   Decoder,
   Encoder,
   combineCodec,
-  getScalarEnumDecoder,
-  getScalarEnumEncoder,
+  getEnumDecoder,
+  getEnumEncoder,
 } from '@solana/codecs';
 
 export enum AuthorityType {
@@ -25,11 +25,11 @@ export enum AuthorityType {
 export type AuthorityTypeArgs = AuthorityType;
 
 export function getAuthorityTypeEncoder(): Encoder<AuthorityTypeArgs> {
-  return getScalarEnumEncoder(AuthorityType);
+  return getEnumEncoder(AuthorityType);
 }
 
 export function getAuthorityTypeDecoder(): Decoder<AuthorityType> {
-  return getScalarEnumDecoder(AuthorityType);
+  return getEnumDecoder(AuthorityType);
 }
 
 export function getAuthorityTypeCodec(): Codec<

diff --git a/test/packages/js-experimental/src/generated/types/burnArgs.ts b/test/packages/js-experimental/src/generated/types/burnArgs.ts
@@ -11,8 +11,8 @@ import {
   Decoder,
   Encoder,
   combineCodec,
-  getScalarEnumDecoder,
-  getScalarEnumEncoder,
+  getEnumDecoder,
+  getEnumEncoder,
   getU64Decoder,
   getU64Encoder,
 } from '@solana/codecs';
@@ -24,11 +24,11 @@ export enum BurnArgs {
 export type BurnArgsArgs = BurnArgs;
 
 export function getBurnArgsEncoder(): Encoder<BurnArgsArgs> {
-  return getScalarEnumEncoder(BurnArgs, { size: getU64Encoder() });
+  return getEnumEncoder(BurnArgs, { size: getU64Encoder() });
 }
 
 export function getBurnArgsDecoder(): Decoder<BurnArgs> {
-  return getScalarEnumDecoder(BurnArgs, { size: getU64Decoder() });
+  return getEnumDecoder(BurnArgs, { size: getU64Decoder() });
 }
 
 export function getBurnArgsCodec(): Codec<BurnArgsArgs, BurnArgs> {