Unwrap generics from Anchor (#913)

Author: lorisleiva

.changeset/four-bears-shave.md

@@ -0,0 +1,6 @@
+---
+'@codama/nodes-from-anchor': patch
+'@codama/errors': patch
+---
+
+Unwrap generic types and constants from Anchor IDLs when converting them to Codama IDLs.

packages/errors/src/codes.ts

@@ -61,6 +61,7 @@ export const CODAMA_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING = 2100002;
 export const CODAMA_ERROR__ANCHOR__TYPE_PATH_MISSING = 2100003;
 export const CODAMA_ERROR__ANCHOR__SEED_KIND_UNIMPLEMENTED = 2100004;
 export const CODAMA_ERROR__ANCHOR__PROGRAM_ID_KIND_UNIMPLEMENTED = 2100005;
+export const CODAMA_ERROR__ANCHOR__GENERIC_TYPE_MISSING = 2100006;
 
 // Renderers-related errors.
 // Reserve error codes in the range [2800000-2800999].
@@ -84,6 +85,7 @@ export const CODAMA_ERROR__RENDERERS__UNSUPPORTED_NODE = 2800000;
 export type CodamaErrorCode =
     | typeof CODAMA_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING
     | typeof CODAMA_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING
+    | typeof CODAMA_ERROR__ANCHOR__GENERIC_TYPE_MISSING
     | typeof CODAMA_ERROR__ANCHOR__PROGRAM_ID_KIND_UNIMPLEMENTED
     | typeof CODAMA_ERROR__ANCHOR__SEED_KIND_UNIMPLEMENTED
     | typeof CODAMA_ERROR__ANCHOR__TYPE_PATH_MISSING

packages/errors/src/context.ts

@@ -22,6 +22,7 @@ import {
 import {
     CODAMA_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING,
     CODAMA_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING,
+    CODAMA_ERROR__ANCHOR__GENERIC_TYPE_MISSING,
     CODAMA_ERROR__ANCHOR__PROGRAM_ID_KIND_UNIMPLEMENTED,
     CODAMA_ERROR__ANCHOR__SEED_KIND_UNIMPLEMENTED,
     CODAMA_ERROR__ANCHOR__TYPE_PATH_MISSING,
@@ -69,6 +70,9 @@ export type CodamaErrorContext = DefaultUnspecifiedErrorContextToUndefined<{
     [CODAMA_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING]: {
         name: string;
     };
+    [CODAMA_ERROR__ANCHOR__GENERIC_TYPE_MISSING]: {
+        name: string;
+    };
     [CODAMA_ERROR__ANCHOR__PROGRAM_ID_KIND_UNIMPLEMENTED]: {
         kind: string;
     };

packages/errors/src/messages.ts

@@ -6,6 +6,7 @@
 import {
     CODAMA_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING,
     CODAMA_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING,
+    CODAMA_ERROR__ANCHOR__GENERIC_TYPE_MISSING,
     CODAMA_ERROR__ANCHOR__PROGRAM_ID_KIND_UNIMPLEMENTED,
     CODAMA_ERROR__ANCHOR__SEED_KIND_UNIMPLEMENTED,
     CODAMA_ERROR__ANCHOR__TYPE_PATH_MISSING,
@@ -49,6 +50,7 @@ export const CodamaErrorMessages: Readonly<{
 }> = {
     [CODAMA_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING]: 'Account type [$name] is missing from the IDL types.',
     [CODAMA_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING]: 'Argument name [$name] is missing from the instruction definition.',
+    [CODAMA_ERROR__ANCHOR__GENERIC_TYPE_MISSING]: 'Generic type [$name] is missing from the IDL types.',
     [CODAMA_ERROR__ANCHOR__PROGRAM_ID_KIND_UNIMPLEMENTED]: 'Program ID kind [$kind] is not implemented.',
     [CODAMA_ERROR__ANCHOR__SEED_KIND_UNIMPLEMENTED]: 'Seed kind [$kind] is not implemented.',
     [CODAMA_ERROR__ANCHOR__TYPE_PATH_MISSING]: 'Field type is missing for path [$path] in [$idlType].',

packages/nodes-from-anchor/src/discriminators.ts

@@ -1,5 +1,5 @@
 import { BytesValueNode, bytesValueNode, pascalCase, snakeCase } from '@codama/nodes';
-import { sha256 } from '@noble/hashes/sha256';
+import { sha256 } from '@noble/hashes/sha2';
 
 import { hex } from './utils';
 

packages/nodes-from-anchor/src/v01/AccountNode.ts

@@ -12,18 +12,23 @@ import {
 } from '@codama/nodes';
 
 import { getAnchorDiscriminatorV01 } from './../discriminators';
-import { IdlV01Account, IdlV01TypeDef } from './idl';
+import type { IdlV01Account, IdlV01TypeDef } from './idl';
 import { typeNodeFromAnchorV01 } from './typeNodes';
+import type { GenericsV01 } from './unwrapGenerics';
 
-export function accountNodeFromAnchorV01(idl: IdlV01Account, types: IdlV01TypeDef[]): AccountNode {
+export function accountNodeFromAnchorV01(
+    idl: IdlV01Account,
+    types: IdlV01TypeDef[],
+    generics: GenericsV01,
+): AccountNode {
     const name = camelCase(idl.name);
     const type = types.find(({ name }) => name === idl.name);
 
     if (!type) {
         throw new CodamaError(CODAMA_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING, { name: idl.name });
     }
 
-    const data = typeNodeFromAnchorV01(type.type);
+    const data = typeNodeFromAnchorV01(type.type, generics);
     assertIsNode(data, 'structTypeNode');
 
     const discriminator = structFieldTypeNode({
@@ -39,9 +44,3 @@ export function accountNodeFromAnchorV01(idl: IdlV01Account, types: IdlV01TypeDe
         name,
     });
 }
-
-export function accountNodeFromAnchorV01WithTypeDefinition(types: IdlV01TypeDef[]) {
-    return function (idl: IdlV01Account): AccountNode {
-        return accountNodeFromAnchorV01(idl, types);
-    };
-}

packages/nodes-from-anchor/src/v01/DefinedTypeNode.ts

@@ -1,11 +1,12 @@
 import { DefinedTypeNode, definedTypeNode } from '@codama/nodes';
 
-import { IdlV01TypeDef } from './idl';
+import type { IdlV01TypeDef } from './idl';
 import { typeNodeFromAnchorV01 } from './typeNodes';
+import type { GenericsV01 } from './unwrapGenerics';
 
-export function definedTypeNodeFromAnchorV01(idl: Partial<IdlV01TypeDef>): DefinedTypeNode {
+export function definedTypeNodeFromAnchorV01(idl: Partial<IdlV01TypeDef>, generics: GenericsV01): DefinedTypeNode {
     const name = idl.name ?? '';
     const idlType = idl.type ?? { fields: [], kind: 'struct' };
-    const type = typeNodeFromAnchorV01(idlType);
+    const type = typeNodeFromAnchorV01(idlType, generics);
     return definedTypeNode({ docs: idl.docs, name, type });
 }

packages/nodes-from-anchor/src/v01/InstructionArgumentNode.ts

@@ -1,12 +1,13 @@
 import { InstructionArgumentNode, instructionArgumentNode } from '@codama/nodes';
 
-import { IdlV01Field } from './idl';
+import type { IdlV01Field } from './idl';
 import { typeNodeFromAnchorV01 } from './typeNodes';
+import type { GenericsV01 } from './unwrapGenerics';
 
-export function instructionArgumentNodeFromAnchorV01(idl: IdlV01Field): InstructionArgumentNode {
+export function instructionArgumentNodeFromAnchorV01(idl: IdlV01Field, generics: GenericsV01): InstructionArgumentNode {
     return instructionArgumentNode({
         docs: idl.docs ?? [],
         name: idl.name,
-        type: typeNodeFromAnchorV01(idl.type),
+        type: typeNodeFromAnchorV01(idl.type, generics),
     });
 }

packages/nodes-from-anchor/src/v01/InstructionNode.ts

@@ -10,13 +10,18 @@ import {
 } from '@codama/nodes';
 
 import { getAnchorDiscriminatorV01 } from '../discriminators';
-import { IdlV01Instruction } from './idl';
+import type { IdlV01Instruction } from './idl';
 import { instructionAccountNodesFromAnchorV01 } from './InstructionAccountNode';
 import { instructionArgumentNodeFromAnchorV01 } from './InstructionArgumentNode';
+import type { GenericsV01 } from './unwrapGenerics';
 
-export function instructionNodeFromAnchorV01(allAccounts: AccountNode[], idl: IdlV01Instruction): InstructionNode {
+export function instructionNodeFromAnchorV01(
+    allAccounts: AccountNode[],
+    idl: IdlV01Instruction,
+    generics: GenericsV01,
+): InstructionNode {
     const name = idl.name;
-    let dataArguments = idl.args.map(instructionArgumentNodeFromAnchorV01);
+    let dataArguments = idl.args.map(arg => instructionArgumentNodeFromAnchorV01(arg, generics));
 
     const discriminatorField = instructionArgumentNode({
         defaultValue: getAnchorDiscriminatorV01(idl.discriminator),

packages/nodes-from-anchor/src/v01/ProgramNode.ts

@@ -1,27 +1,29 @@
 import { ProgramNode, programNode, ProgramVersion } from '@codama/nodes';
 
-import { accountNodeFromAnchorV01WithTypeDefinition } from './AccountNode';
+import { accountNodeFromAnchorV01 } from './AccountNode';
 import { definedTypeNodeFromAnchorV01 } from './DefinedTypeNode';
 import { errorNodeFromAnchorV01 } from './ErrorNode';
 import { IdlV01 } from './idl';
 import { instructionNodeFromAnchorV01 } from './InstructionNode';
+import { extractGenerics } from './unwrapGenerics';
 
 export function programNodeFromAnchorV01(idl: IdlV01): ProgramNode {
-    const types = idl.types ?? [];
+    const [types, generics] = extractGenerics(idl.types ?? []);
     const accounts = idl.accounts ?? [];
     const instructions = idl.instructions ?? [];
     const errors = idl.errors ?? [];
 
     const filteredTypes = types.filter(type => !accounts.some(account => account.name === type.name));
-    const definedTypes = filteredTypes.map(definedTypeNodeFromAnchorV01);
-    const accountNodeFromAnchorV01 = accountNodeFromAnchorV01WithTypeDefinition(types);
-    const accountNodes = accounts.map(accountNodeFromAnchorV01);
+    const definedTypes = filteredTypes.map(type => definedTypeNodeFromAnchorV01(type, generics));
+    const accountNodes = accounts.map(account => accountNodeFromAnchorV01(account, types, generics));
 
     return programNode({
         accounts: accountNodes,
         definedTypes,
         errors: errors.map(errorNodeFromAnchorV01),
-        instructions: instructions.map(instruction => instructionNodeFromAnchorV01(accountNodes, instruction)),
+        instructions: instructions.map(instruction =>
+            instructionNodeFromAnchorV01(accountNodes, instruction, generics),
+        ),
         name: idl.metadata.name,
         origin: 'anchor',
         publicKey: idl.address,