Fully Support Anchor 0.30.0 IDL Seed Spec (#42)

* feat: express anchor account and arg seed definitions in instructions as defaultValue on the instruction account

* test(renders-js): e2e test for anchor v01 version of the IDL

* Update e2e pnpm-lock files

* Fix double type in union

* Remove hex utility export

* Resolve nested struct type of account data and throw arg error when missing

* Add test for account path of length 2

* Simplify types

* Ignore PDA default values if some seeds have nested paths

---------

Co-authored-by: Loris Leiva <[email protected]>

Author: kespinola

.changeset/forty-chefs-know.md

@@ -0,0 +1,7 @@
+---
+"@kinobi-so/nodes-from-anchor": minor
+"@kinobi-so/errors": minor
+"@kinobi-so/nodes": minor
+---
+
+set anchor account seed definitions on instructions as defaultValue for the associated instruction account. Removes hoisting PDAs to the program node for the time being.

packages/errors/src/codes.ts

@@ -52,6 +52,9 @@ export const KINOBI_ERROR__VISITORS__RENDER_MAP_KEY_NOT_FOUND = 1200011 as const
 // Reserve error codes in the range [2100000-2100999].
 export const KINOBI_ERROR__ANCHOR__UNRECOGNIZED_IDL_TYPE = 2100000 as const;
 export const KINOBI_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING = 2100001 as const;
+export const KINOBI_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING = 2100002 as const;
+export const KINOBI_ERROR__ANCHOR__TYPE_PATH_MISSING = 2100003 as const;
+export const KINOBI_ERROR__ANCHOR__SEED_KIND_UNIMPLEMENTED = 2100004 as const;
 
 /**
  * A union of every Kinobi error code
@@ -70,6 +73,9 @@ export const KINOBI_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING = 2100001 as const;
  */
 export type KinobiErrorCode =
     | typeof KINOBI_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING
+    | typeof KINOBI_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING
+    | typeof KINOBI_ERROR__ANCHOR__SEED_KIND_UNIMPLEMENTED
+    | typeof KINOBI_ERROR__ANCHOR__TYPE_PATH_MISSING
     | typeof KINOBI_ERROR__ANCHOR__UNRECOGNIZED_IDL_TYPE
     | typeof KINOBI_ERROR__LINKED_NODE_NOT_FOUND
     | typeof KINOBI_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE

packages/errors/src/context.ts

@@ -19,6 +19,10 @@ import {
 } from '@kinobi-so/node-types';
 
 import {
+    KINOBI_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING,
+    KINOBI_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING,
+    KINOBI_ERROR__ANCHOR__SEED_KIND_UNIMPLEMENTED,
+    KINOBI_ERROR__ANCHOR__TYPE_PATH_MISSING,
     KINOBI_ERROR__ANCHOR__UNRECOGNIZED_IDL_TYPE,
     KINOBI_ERROR__LINKED_NODE_NOT_FOUND,
     KINOBI_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE,
@@ -50,6 +54,19 @@ type DefaultUnspecifiedErrorContextToUndefined<T> = {
  *   - Don't change or remove members of an error's context.
  */
 export type KinobiErrorContext = DefaultUnspecifiedErrorContextToUndefined<{
+    [KINOBI_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING]: {
+        name: string;
+    };
+    [KINOBI_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING]: {
+        name: string;
+    };
+    [KINOBI_ERROR__ANCHOR__SEED_KIND_UNIMPLEMENTED]: {
+        kind: string;
+    };
+    [KINOBI_ERROR__ANCHOR__TYPE_PATH_MISSING]: {
+        idlType: string;
+        path: string;
+    };
     [KINOBI_ERROR__ANCHOR__UNRECOGNIZED_IDL_TYPE]: {
         idlType: string;
     };

packages/errors/src/messages.ts

@@ -5,6 +5,9 @@
 
 import {
     KINOBI_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING,
+    KINOBI_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING,
+    KINOBI_ERROR__ANCHOR__SEED_KIND_UNIMPLEMENTED,
+    KINOBI_ERROR__ANCHOR__TYPE_PATH_MISSING,
     KINOBI_ERROR__ANCHOR__UNRECOGNIZED_IDL_TYPE,
     KINOBI_ERROR__LINKED_NODE_NOT_FOUND,
     KINOBI_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE,
@@ -37,6 +40,9 @@ export const KinobiErrorMessages: Readonly<{
     [P in KinobiErrorCode]: string;
 }> = {
     [KINOBI_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING]: 'Account type [$name] is missing from the IDL types.',
+    [KINOBI_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING]: 'Argument name [$name] is missing from the instruction definition.',
+    [KINOBI_ERROR__ANCHOR__SEED_KIND_UNIMPLEMENTED]: 'Seed kind [$kind] is not implemented.',
+    [KINOBI_ERROR__ANCHOR__TYPE_PATH_MISSING]: 'Field type is missing for path [$path] in [$idlType].',
     [KINOBI_ERROR__ANCHOR__UNRECOGNIZED_IDL_TYPE]: 'Unrecognized Anchor IDL type [$idlType].',
     [KINOBI_ERROR__LINKED_NODE_NOT_FOUND]: 'Could not find linked node [$name] from [$kind].',
     [KINOBI_ERROR__NODE_FILESYSTEM_FUNCTION_UNAVAILABLE]:

packages/nodes-from-anchor/README.md

@@ -1,3 +1,26 @@
 # Kinobi ➤ Nodes From Anchor
 
-TODO
+Parse Anchor IDL version `0.0` or `0.1` (from Anchor `0.30`) into Kinobi node definitions.
+
+```javascript
+// node ./kinobi.mjs
+
+import path from 'path';
+import { renderRustVisitor, renderJavaScriptVisitor } from '@kinobi-so/renderers';
+import { rootNodeFromAnchor } from '@kinobi-so/nodes-from-anchor';
+import { readJson } from '@kinobi-so/renderers-core';
+import { visit } from '@kinobi-so/visitors-core';
+
+const clientDir = path.join(__dirname, 'clients');
+
+const idlPath = path.join(__dirname, 'target', 'idl', 'anchor_program.json');
+const idl = readJson(idlPath);
+
+const node = rootNodeFromAnchor(idl);
+
+const sdkName = idl.metadata.name;
+
+await visit(node, renderJavaScriptVisitor(path.join(clientDir, 'js', sdkName, 'src', 'generated')));
+
+visit(node, renderRustVisitor(path.join(clientDir, 'rust', sdkName, 'src', 'generated'), { format: true }));
+```

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

@@ -1,6 +1,8 @@
 import { BytesValueNode, bytesValueNode, pascalCase, snakeCase } from '@kinobi-so/nodes';
 import { sha256 } from '@noble/hashes/sha256';
 
+import { hex } from './utils';
+
 export const getAnchorDiscriminatorV01 = (discriminator: number[]): BytesValueNode => {
     return bytesValueNode('base16', hex(new Uint8Array(discriminator)));
 };
@@ -14,7 +16,3 @@ export const getAnchorAccountDiscriminatorV00 = (idlName: string): BytesValueNod
     const hash = sha256(`account:${pascalCase(idlName)}`).slice(0, 8);
     return bytesValueNode('base16', hex(hash));
 };
-
-function hex(bytes: Uint8Array): string {
-    return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');
-}

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

@@ -0,0 +1,3 @@
+export function hex(bytes: number[] | Uint8Array): string {
+    return (bytes as number[]).reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');
+}

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

@@ -16,15 +16,11 @@ import { IdlV01Account, IdlV01TypeDef } from './idl';
 import { typeNodeFromAnchorV01 } from './typeNodes';
 
 export function accountNodeFromAnchorV01(idl: IdlV01Account, types: IdlV01TypeDef[]): AccountNode {
-    const idlName = idl.name;
-    const name = camelCase(idlName);
-
-    const type = types.find(t => t.name === idl.name);
+    const name = camelCase(idl.name);
+    const type = types.find(({ name }) => name === idl.name);
 
     if (!type) {
-        throw new KinobiError(KINOBI_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING, {
-            name,
-        });
+        throw new KinobiError(KINOBI_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING, { name: idl.name });
     }
 
     const data = typeNodeFromAnchorV01(type.type);

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

@@ -1,25 +1,129 @@
-import { InstructionAccountNode, instructionAccountNode, publicKeyValueNode } from '@kinobi-so/nodes';
+import {
+    KINOBI_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING,
+    KINOBI_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING,
+    KINOBI_ERROR__ANCHOR__SEED_KIND_UNIMPLEMENTED,
+    KINOBI_ERROR__ANCHOR__TYPE_PATH_MISSING,
+    KinobiError,
+} from '@kinobi-so/errors';
+import {
+    AccountNode,
+    accountValueNode,
+    argumentValueNode,
+    camelCase,
+    constantPdaSeedNodeFromBytes,
+    InstructionAccountNode,
+    instructionAccountNode,
+    InstructionArgumentNode,
+    pdaNode,
+    PdaSeedNode,
+    PdaSeedValueNode,
+    pdaSeedValueNode,
+    PdaValueNode,
+    pdaValueNode,
+    publicKeyTypeNode,
+    PublicKeyValueNode,
+    publicKeyValueNode,
+    resolveNestedTypeNode,
+    variablePdaSeedNode,
+} from '@kinobi-so/nodes';
 
-import { IdlV01InstructionAccount, IdlV01InstructionAccountItem } from './idl';
+import { hex } from '../utils';
+import { IdlV01InstructionAccount, IdlV01InstructionAccountItem, IdlV01Seed } from './idl';
 
-export function instructionAccountNodesFromAnchorV01(idl: IdlV01InstructionAccountItem[]): InstructionAccountNode[] {
+export function instructionAccountNodesFromAnchorV01(
+    allAccounts: AccountNode[],
+    instructionArguments: InstructionArgumentNode[],
+    idl: IdlV01InstructionAccountItem[],
+): InstructionAccountNode[] {
     return idl.flatMap(account =>
         'accounts' in account
-            ? instructionAccountNodesFromAnchorV01(account.accounts)
-            : [instructionAccountNodeFromAnchorV01(account)],
+            ? instructionAccountNodesFromAnchorV01(allAccounts, instructionArguments, account.accounts)
+            : [instructionAccountNodeFromAnchorV01(allAccounts, instructionArguments, account)],
     );
 }
 
-export function instructionAccountNodeFromAnchorV01(idl: IdlV01InstructionAccount): InstructionAccountNode {
+export function instructionAccountNodeFromAnchorV01(
+    allAccounts: AccountNode[],
+    instructionArguments: InstructionArgumentNode[],
+    idl: IdlV01InstructionAccount,
+): InstructionAccountNode {
     const isOptional = idl.optional ?? false;
     const docs = idl.docs ?? [];
     const isSigner = idl.signer ?? false;
     const isWritable = idl.writable ?? false;
     const name = idl.name ?? '';
-    let defaultValue = undefined;
+    let defaultValue: PdaValueNode | PublicKeyValueNode | undefined;
 
     if (idl.address) {
         defaultValue = publicKeyValueNode(idl.address, name);
+    } else if (idl.pda) {
+        // TODO: Handle seeds with nested paths.
+        // Currently, we gracefully ignore PDA default values if we encounter seeds with nested paths.
+        const seedsWithNestedPaths = idl.pda.seeds.some(seed => 'path' in seed && seed.path.includes('.'));
+        if (!seedsWithNestedPaths) {
+            const [seeds, lookups] = idl.pda.seeds.reduce(
+                ([seeds, lookups], seed: IdlV01Seed) => {
+                    const kind = seed.kind;
+
+                    switch (kind) {
+                        case 'const':
+                            return [[...seeds, constantPdaSeedNodeFromBytes('base16', hex(seed.value))], lookups];
+                        case 'account': {
+                            const path = seed.path.split('.');
+                            if (path.length === 1) {
+                                return [
+                                    [...seeds, variablePdaSeedNode(seed.path, publicKeyTypeNode())],
+                                    [...lookups, pdaSeedValueNode(seed.path, accountValueNode(seed.path))],
+                                ];
+                            } else if (path.length === 2) {
+                                // TODO: Handle nested account paths.
+                                // Currently, this scenario is never reached.
+
+                                const accountName = camelCase(seed.account ?? '');
+                                const accountNode = allAccounts.find(({ name }) => name === accountName);
+                                if (!accountNode) {
+                                    throw new KinobiError(KINOBI_ERROR__ANCHOR__ACCOUNT_TYPE_MISSING, { kind });
+                                }
+
+                                const fieldName = camelCase(path[1]);
+                                const accountFields = resolveNestedTypeNode(accountNode.data).fields;
+                                const fieldNode = accountFields.find(({ name }) => name === fieldName);
+                                if (!fieldNode) {
+                                    throw new KinobiError(KINOBI_ERROR__ANCHOR__TYPE_PATH_MISSING, {
+                                        idlType: seed.account,
+                                        path: seed.path,
+                                    });
+                                }
+
+                                const seedName = camelCase(seed.path);
+                                return [[...seeds, variablePdaSeedNode(seedName, fieldNode.type)], []];
+                            } else {
+                                throw new KinobiError(KINOBI_ERROR__ANCHOR__TYPE_PATH_MISSING, {
+                                    idlType: seed,
+                                    path: seed.path,
+                                });
+                            }
+                        }
+                        case 'arg': {
+                            const argumentNode = instructionArguments.find(({ name }) => name === seed.path);
+                            if (!argumentNode) {
+                                throw new KinobiError(KINOBI_ERROR__ANCHOR__ARGUMENT_TYPE_MISSING, { name: seed.path });
+                            }
+
+                            return [
+                                [...seeds, variablePdaSeedNode(seed.path, argumentNode.type)],
+                                [...lookups, pdaSeedValueNode(seed.path, argumentValueNode(seed.path))],
+                            ];
+                        }
+                        default:
+                            throw new KinobiError(KINOBI_ERROR__ANCHOR__SEED_KIND_UNIMPLEMENTED, { kind });
+                    }
+                },
+                <[PdaSeedNode[], PdaSeedValueNode[]]>[[], []],
+            );
+
+            defaultValue = pdaValueNode(pdaNode({ name, seeds }), lookups);
+        }
     }
 
     return instructionAccountNode({

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

@@ -1,4 +1,5 @@
 import {
+    AccountNode,
     bytesTypeNode,
     camelCase,
     fieldDiscriminatorNode,
@@ -13,7 +14,7 @@ import { IdlV01Instruction } from './idl';
 import { instructionAccountNodesFromAnchorV01 } from './InstructionAccountNode';
 import { instructionArgumentNodeFromAnchorV01 } from './InstructionArgumentNode';
 
-export function instructionNodeFromAnchorV01(idl: IdlV01Instruction): InstructionNode {
+export function instructionNodeFromAnchorV01(allAccounts: AccountNode[], idl: IdlV01Instruction): InstructionNode {
     const name = idl.name;
     let dataArguments = idl.args.map(instructionArgumentNodeFromAnchorV01);
 
@@ -27,7 +28,7 @@ export function instructionNodeFromAnchorV01(idl: IdlV01Instruction): Instructio
     const discriminators = [fieldDiscriminatorNode('discriminator')];
 
     return instructionNode({
-        accounts: instructionAccountNodesFromAnchorV01(idl.accounts ?? []),
+        accounts: instructionAccountNodesFromAnchorV01(allAccounts, dataArguments, idl.accounts ?? []),
         arguments: dataArguments,
         discriminators,
         docs: idl.docs ?? [],