Use SolanaErrors for generated errors

Author: lorisleiva

src/fragments/discriminatorCondition.ts

@@ -91,7 +91,6 @@ function getFieldConditionFragment(
 ): Fragment {
     const field = scope.struct.fields.find(f => f.name === discriminator.name);
     if (!field || !field.defaultValue) {
-        // TODO: Coded error.
         throw new Error(
             `Field discriminator "${discriminator.name}" does not have a matching argument with default value.`,
         );

src/fragments/instructionParseFunction.ts

@@ -120,9 +120,10 @@ function getFunctionFragment(
 
     let accountHelpers: Fragment | undefined;
     if (hasAccounts) {
+        const solanaError = use('SolanaError', 'solanaErrors');
+        const solanaErrorCode = use('SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS', 'solanaErrors');
         accountHelpers = fragment`if (instruction.accounts.length < ${minimumNumberOfAccounts}) {
-  // TODO: Coded error.
-  throw new Error('Not enough accounts');
+  throw new ${solanaError}(${solanaErrorCode}, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: ${minimumNumberOfAccounts} });
 }
 let accountIndex = 0;
 const getNextAccount = () => {

src/fragments/programAccounts.ts

@@ -1,8 +1,6 @@
 import { ProgramNode, resolveNestedTypeNode } from '@codama/nodes';
-import { mapFragmentContent } from '@codama/renderers-core';
-import { pipe } from '@codama/visitors-core';
 
-import { addFragmentImports, Fragment, fragment, mergeFragments, RenderScope } from '../utils';
+import { Fragment, fragment, mergeFragments, RenderScope, use } from '../utils';
 import { getDiscriminatorConditionFragment } from './discriminatorCondition';
 
 export function getProgramAccountsFragment(
@@ -45,32 +43,28 @@ function getProgramAccountsIdentifierFunctionFragment(
     const programAccountsEnum = nameApi.programAccountsEnum(programNode.name);
     const programAccountsIdentifierFunction = nameApi.programAccountsIdentifierFunction(programNode.name);
 
-    return pipe(
-        mergeFragments(
-            accountsWithDiscriminators.map((account): Fragment => {
-                const variant = nameApi.programAccountsEnumVariant(account.name);
-                return getDiscriminatorConditionFragment({
-                    ...scope,
-                    dataName: 'data',
-                    discriminators: account.discriminators ?? [],
-                    ifTrue: `return ${programAccountsEnum}.${variant};`,
-                    struct: resolveNestedTypeNode(account.data),
-                });
-            }),
-            c => c.join('\n'),
-        ),
-        f =>
-            mapFragmentContent(
-                f,
-                discriminators =>
-                    `export function ${programAccountsIdentifierFunction}(` +
-                    `account: { data: ReadonlyUint8Array } | ReadonlyUint8Array` +
-                    `): ${programAccountsEnum} {\n` +
-                    `const data = 'data' in account ? account.data : account;\n` +
-                    `${discriminators}\n` +
-                    `throw new Error("The provided account could not be identified as a ${programNode.name} account.")\n` +
-                    `}`,
-            ),
-        f => addFragmentImports(f, 'solanaCodecsCore', ['type ReadonlyUint8Array']),
+    const discriminatorsFragment = mergeFragments(
+        accountsWithDiscriminators.map((account): Fragment => {
+            const variant = nameApi.programAccountsEnumVariant(account.name);
+            return getDiscriminatorConditionFragment({
+                ...scope,
+                dataName: 'data',
+                discriminators: account.discriminators ?? [],
+                ifTrue: `return ${programAccountsEnum}.${variant};`,
+                struct: resolveNestedTypeNode(account.data),
+            });
+        }),
+        c => c.join('\n'),
     );
+
+    const readonlyUint8Array = use('type ReadonlyUint8Array', 'solanaCodecsCore');
+    // TODO(loris): Waiting for Kit to have this missing error code.
+    // const solanaError = use('SolanaError', 'solanaErrors');
+    // const solanaErrorCode = use('SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT', 'solanaErrors');
+
+    return fragment`export function ${programAccountsIdentifierFunction}(account: { data: ${readonlyUint8Array} } | ${readonlyUint8Array}): ${programAccountsEnum} {
+    const data = 'data' in account ? account.data : account;
+    ${discriminatorsFragment}
+    throw new Error("The provided account could not be identified as a ${programNode.name} account.");
+}`;
 }

src/fragments/programInstructions.ts

@@ -4,10 +4,8 @@ import {
     ProgramNode,
     structTypeNodeFromInstructionArgumentNodes,
 } from '@codama/nodes';
-import { mapFragmentContent } from '@codama/renderers-core';
-import { pipe } from '@codama/visitors-core';
 
-import { addFragmentImports, Fragment, fragment, mergeFragments, RenderScope, use } from '../utils';
+import { Fragment, fragment, mergeFragments, RenderScope, use } from '../utils';
 import { getDiscriminatorConditionFragment } from './discriminatorCondition';
 
 export function getProgramInstructionsFragment(
@@ -76,22 +74,15 @@ function getProgramInstructionsIdentifierFunctionFragment(
         c => c.join('\n'),
     );
 
-    return pipe(
-        discriminatorsFragment,
-        f =>
-            mapFragmentContent(
-                f,
-                discriminators =>
-                    `export function ${programInstructionsIdentifierFunction}(` +
-                    `instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array` +
-                    `): ${programInstructionsEnum} {\n` +
-                    `const data = 'data' in instruction ? instruction.data : instruction;\n` +
-                    `${discriminators}\n` +
-                    `throw new Error("The provided instruction could not be identified as a ${programNode.name} instruction.")\n` +
-                    `}`,
-            ),
-        f => addFragmentImports(f, 'solanaCodecsCore', ['type ReadonlyUint8Array']),
-    );
+    const readonlyUint8Array = use('type ReadonlyUint8Array', 'solanaCodecsCore');
+    const solanaError = use('SolanaError', 'solanaErrors');
+    const solanaErrorCode = use('SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION', 'solanaErrors');
+
+    return fragment`export function ${programInstructionsIdentifierFunction}(instruction: { data: ${readonlyUint8Array} } | ${readonlyUint8Array}): ${programInstructionsEnum} {
+    const data = 'data' in instruction ? instruction.data : instruction;
+    ${discriminatorsFragment}
+    throw new ${solanaError}(${solanaErrorCode}, { instructionData: data, programName: "${programNode.name}" });
+}`;
 }
 
 function getProgramInstructionsParsedUnionTypeFragment(
@@ -159,6 +150,9 @@ function getProgramInstructionsParseFunctionFragment(
         c => c.join('\n'),
     );
 
+    const solanaError = use('SolanaError', 'solanaErrors');
+    const solanaErrorCode = use('SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE', 'solanaErrors');
+
     return fragment`
         export function ${parseFunction}<TProgram extends string>(
             instruction: ${use('type Instruction', 'solanaInstructions')}<TProgram> 
@@ -167,7 +161,7 @@ function getProgramInstructionsParseFunctionFragment(
             const instructionType = ${programInstructionsIdentifierFunction}(instruction);
             switch (instructionType) {
                 ${switchCases}
-                default: throw new Error(\`Unrecognized instruction type: \${instructionType as string}\`);
+                default: throw new ${solanaError}(${solanaErrorCode}, { instructionType: instructionType as string, programName: "${programNode.name}" });
             }
         }`;
 }

test/e2e/anchor/src/generated/instructions/createGuard.ts

@@ -26,6 +26,8 @@ import {
     getU32Encoder,
     getUtf8Decoder,
     getUtf8Encoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+    SolanaError,
     transformEncoder,
     type AccountMeta,
     type AccountSignerMeta,
@@ -457,8 +459,10 @@ export function parseCreateGuardInstruction<TProgram extends string, TAccountMet
         InstructionWithData<ReadonlyUint8Array>,
 ): ParsedCreateGuardInstruction<TProgram, TAccountMetas> {
     if (instruction.accounts.length < 8) {
-        // TODO: Coded error.
-        throw new Error('Not enough accounts');
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 8,
+        });
     }
     let accountIndex = 0;
     const getNextAccount = () => {

test/e2e/anchor/src/generated/instructions/execute.ts

@@ -18,6 +18,8 @@ import {
     getStructEncoder,
     getU64Decoder,
     getU64Encoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+    SolanaError,
     transformEncoder,
     type AccountMeta,
     type Address,
@@ -334,8 +336,10 @@ export function parseExecuteInstruction<TProgram extends string, TAccountMetas e
         InstructionWithData<ReadonlyUint8Array>,
 ): ParsedExecuteInstruction<TProgram, TAccountMetas> {
     if (instruction.accounts.length < 7) {
-        // TODO: Coded error.
-        throw new Error('Not enough accounts');
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 7,
+        });
     }
     let accountIndex = 0;
     const getNextAccount = () => {

test/e2e/anchor/src/generated/instructions/initialize.ts

@@ -16,6 +16,8 @@ import {
     getProgramDerivedAddress,
     getStructDecoder,
     getStructEncoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+    SolanaError,
     transformEncoder,
     type AccountMeta,
     type AccountSignerMeta,
@@ -306,8 +308,10 @@ export function parseInitializeInstruction<TProgram extends string, TAccountMeta
         InstructionWithData<ReadonlyUint8Array>,
 ): ParsedInitializeInstruction<TProgram, TAccountMetas> {
     if (instruction.accounts.length < 6) {
-        // TODO: Coded error.
-        throw new Error('Not enough accounts');
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 6,
+        });
     }
     let accountIndex = 0;
     const getNextAccount = () => {

test/e2e/anchor/src/generated/instructions/updateGuard.ts

@@ -20,6 +20,8 @@ import {
     getProgramDerivedAddress,
     getStructDecoder,
     getStructEncoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+    SolanaError,
     transformEncoder,
     type AccountMeta,
     type AccountSignerMeta,
@@ -377,8 +379,10 @@ export function parseUpdateGuardInstruction<TProgram extends string, TAccountMet
         InstructionWithData<ReadonlyUint8Array>,
 ): ParsedUpdateGuardInstruction<TProgram, TAccountMetas> {
     if (instruction.accounts.length < 6) {
-        // TODO: Coded error.
-        throw new Error('Not enough accounts');
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 6,
+        });
     }
     let accountIndex = 0;
     const getNextAccount = () => {

test/e2e/anchor/src/generated/programs/wenTransferGuard.ts

@@ -11,6 +11,9 @@ import {
     containsBytes,
     fixEncoderSize,
     getBytesEncoder,
+    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+    SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+    SolanaError,
     type Address,
     type Instruction,
     type InstructionWithData,
@@ -97,7 +100,10 @@ export function identifyWenTransferGuardInstruction(
     ) {
         return WenTransferGuardInstruction.UpdateGuard;
     }
-    throw new Error('The provided instruction could not be identified as a wenTransferGuard instruction.');
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, {
+        instructionData: data,
+        programName: 'wenTransferGuard',
+    });
 }
 
 export type ParsedWenTransferGuardInstruction<TProgram extends string = 'LockdqYQ9X2kwtWB99ioSbxubAmEi8o9jqYwbXgrrRw'> =
@@ -137,6 +143,9 @@ export function parseWenTransferGuardInstruction<TProgram extends string>(
             };
         }
         default:
-            throw new Error(`Unrecognized instruction type: ${instructionType as string}`);
+            throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, {
+                instructionType: instructionType as string,
+                programName: 'wenTransferGuard',
+            });
     }
 }

test/e2e/dummy/src/generated/instructions/instruction6.ts

@@ -7,6 +7,8 @@
  */
 
 import {
+    SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+    SolanaError,
     type AccountMeta,
     type Address,
     type Instruction,
@@ -67,8 +69,10 @@ export function parseInstruction6Instruction<TProgram extends string, TAccountMe
     instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas>,
 ): ParsedInstruction6Instruction<TProgram, TAccountMetas> {
     if (instruction.accounts.length < 1) {
-        // TODO: Coded error.
-        throw new Error('Not enough accounts');
+        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+            actualAccountMetas: instruction.accounts.length,
+            expectedAccountMetas: 1,
+        });
     }
     let accountIndex = 0;
     const getNextAccount = () => {