Swap out anchor for codama and support decoding SPL programs

Author: stwiname

packages/node/package.json

@@ -19,7 +19,8 @@
     "subql-node-solana": "./bin/run"
   },
   "dependencies": {
-    "@coral-xyz/anchor": "^0.31.0",
+    "@codama/dynamic-codecs": "^1.1.12",
+    "@codama/nodes-from-anchor": "^1.1.11",
     "@nestjs/common": "^11.0.8",
     "@nestjs/core": "^11.0.8",
     "@nestjs/event-emitter": "^2.0.0",
@@ -32,6 +33,7 @@
     "@subql/testing": "^2.2.1",
     "@subql/types-solana": "workspace:*",
     "cacheable-lookup": "6",
+    "codama": "^1.2.11",
     "ethers": "^5.7.0",
     "eventemitter2": "^6.4.5",
     "json5": "^2.2.3",

packages/node/src/solana/api.solana.spec.ts

@@ -1,9 +1,7 @@
 // Copyright 2020-2025 SubQuery Pte Ltd authors & contributors
 // SPDX-License-Identifier: GPL-3.0
 
-import { translateAddress } from '@coral-xyz/anchor';
 import { EventEmitter2 } from '@nestjs/event-emitter';
-import { Connection } from '@solana/web3.js';
 import { TransactionFilter } from '@subql/common-solana';
 import {
   SolanaBlock,
@@ -259,16 +257,4 @@ describe('Api.solana', () => {
       throw new Error('Test not implemented');
     });
   });
-
-  it('has the same behaviour for getAccountInfo as legacy @solana/web3.js', async () => {
-    const connection2 = new Connection(HTTP_ENDPOINT);
-
-    const res1 = await solanaApi.getAccountInfo(
-      'SAGE2HAwep459SNq61LHvjxPk4pLPEJLoMETef7f7EE',
-    );
-    const res2 = await connection2.getAccountInfo(
-      translateAddress('SAGE2HAwep459SNq61LHvjxPk4pLPEJLoMETef7f7EE'),
-    );
-    expect(res1?.data).toEqual(res2?.data);
-  });
 });

packages/node/src/solana/api.solana.ts

@@ -79,6 +79,7 @@ export class SolanaApi {
   ): Promise<SolanaApi> {
     try {
       // TODO keep alive, user agent and other headers
+      console.log('CREATING API', endpoint);
       const client = createSolanaRpc(endpoint);
       const genesisBlockHash = await client.getGenesisHash().send();
 
@@ -239,6 +240,7 @@ export class SolanaApi {
   handleError(e: Error): Error {
     if ((e as any)?.context?.statusCode === 429) {
       const { hostname } = new URL(this.endpoint);
+      console.log('ERROR', e);
       return new Error(`Rate Limited at endpoint: ${hostname}`);
     }
 

packages/node/src/solana/block.solana.ts

@@ -29,12 +29,12 @@ type RawSolanaBlock = Readonly<{
   /** The blockhash of this block's parent */
   previousBlockhash: Blockhash;
 
-  transactions: readonly TransactionForFullJson<void>[];
+  transactions: readonly TransactionForFullJson<0>[];
 }>;
 
 function wrapInstruction(
   instruction: Omit<SolanaInstruction, 'transaction' | 'decodedData'>,
-  transaction: TransactionForFullJson<void>,
+  transaction: TransactionForFullJson<0>,
   decoder: SolanaDecoder,
 ): SolanaInstruction {
   let pendingDecode: Promise<DecodedData | null>;

packages/node/src/solana/decoder.spec.ts

@@ -1,18 +1,20 @@
 // Copyright 2020-2025 SubQuery Pte Ltd authors & contributors
 // SPDX-License-Identifier: GPL-3.0
 
-const HTTP_ENDPOINT =
-  process.env.HTTP_ENDPOINT ?? 'https://solana.api.onfinality.io/public';
-
-import { Idl } from '@coral-xyz/anchor';
 import { EventEmitter2 } from '@nestjs/event-emitter';
 import { SolanaBlock } from '@subql/types-solana';
 import { BN } from 'bn.js';
 import { SolanaApi } from './api.solana';
-import { SolanaDecoder } from './decoder';
+import { Idl, SolanaDecoder } from './decoder';
+import { getProgramId } from './utils.solana';
+
+const HTTP_ENDPOINT =
+  process.env.HTTP_ENDPOINT ?? 'https://solana.api.onfinality.io/public';
 
+console.log('HTTPE HTTP_ENDPOINT', HTTP_ENDPOINT);
 const IDL_Jupiter: Idl = require('../../test/JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4.idl.json');
 const IDL_swap: Idl = require('../../test/swapFpHZwjELNnjvThjajtiVmkz3yPQEHjLtka2fwHW.idl.json');
+const IDL_token: Idl = require('../../test/TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA.idl.json');
 
 function stringify(value: any): string {
   return JSON.stringify(value, (_, v) => (BN.isBN(v) ? v.toString() : v));
@@ -60,31 +62,33 @@ describe('SolanaDecoder', () => {
 
   describe('decode instrutions', () => {
     beforeAll(async () => {
-      //https://solscan.io/block/330469167
+      // https://solscan.io/block/330469167
       const { block } = await solanaApi.fetchBlock(330_469_167);
       blockData = block;
 
       // eslint-disable-next-line @typescript-eslint/dot-notation
       decoder.idls['JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4'] = IDL_Jupiter;
       // eslint-disable-next-line @typescript-eslint/dot-notation
       decoder.idls['swapFpHZwjELNnjvThjajtiVmkz3yPQEHjLtka2fwHW'] = IDL_swap;
+      // eslint-disable-next-line @typescript-eslint/dot-notation
+      decoder.idls['TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'] = IDL_token;
     }, 30_000);
 
     const instructionData = stringify({
-      route_plan: [
+      routePlan: [
         {
           swap: {
-            MeteoraDlmm: {},
+            __kind: 'MeteoraDlmm',
           },
           percent: 100,
-          input_index: 0,
-          output_index: 1,
+          inputIndex: 0,
+          outputIndex: 1,
         },
       ],
-      in_amount: new BN(16000),
-      quoted_out_amount: new BN(126754),
-      slippage_bps: 200,
-      platform_fee_bps: 98,
+      inAmount: BigInt(16000),
+      quotedOutAmount: BigInt(126754),
+      slippageBps: 200,
+      platformFeeBps: 98,
     });
 
     it('can decode an instruction with an IDL file', async () => {
@@ -105,7 +109,8 @@ describe('SolanaDecoder', () => {
       expect(stringify(decoded!.data)).toEqual(instructionData);
     });
 
-    it('can decode an instruction with an IDL found on chain', async () => {
+    // Since removing anchor we don't have a way of fetching IDLS
+    it.skip('can decode an instruction with an IDL found on chain', async () => {
       // https://solscan.io/tx/3rf2sSMeJC1dd4t4TDvYPfvQjpL6DG6qdDcMnruDtATPbwjqt3xDnNvddtiTBESL8AWiFt2zENghqAh1h252bKQi
       const tx = blockData.transactions.find((tx) =>
         tx.transaction.signatures.find(
@@ -121,6 +126,34 @@ describe('SolanaDecoder', () => {
       expect(decoded!.name).toEqual('route');
       expect(stringify(decoded!.data)).toEqual(instructionData);
     });
+
+    it('can decode SPL token program instructions', async () => {
+      const tx = blockData.transactions.find((tx) =>
+        tx.transaction.signatures.find(
+          (s) =>
+            s ===
+            '61vjnjBfvU3e2BqmatPd3uYi37woXS44oqcQ3gD1XoS4demqXSmT32vGpdYdXTHW5niePACTKQaDxipn6jhbTWDL',
+        ),
+      );
+
+      // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
+      const instruction = tx!.meta?.innerInstructions.find(
+        (inner) => inner.index === 0,
+      )?.instructions[1]!;
+
+      const program = getProgramId(instruction);
+      expect(program).toBe('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+
+      const decoded = await decoder.decodeInstruction(instruction);
+
+      expect(decoded).toEqual({
+        name: 'transferChecked',
+        data: {
+          amount: BigInt('5904646875'),
+          decimals: 6,
+        },
+      });
+    });
   });
 
   describe('decode log', () => {

packages/node/src/solana/decoder.ts

@@ -2,28 +2,144 @@
 // SPDX-License-Identifier: GPL-3.0
 
 import fs from 'node:fs';
+import { getNodeCodec } from '@codama/dynamic-codecs';
+import { AnchorIdl, rootNodeFromAnchor } from '@codama/nodes-from-anchor';
 import {
-  Program,
-  BorshInstructionCoder,
-  BorshEventCoder,
-  Idl,
-} from '@coral-xyz/anchor';
+  getBase16Encoder,
+  getBase58Encoder,
+  getBase64Encoder,
+  getUtf8Encoder,
+} from '@solana/codecs-strings';
+import { Base58EncodedBytes } from '@solana/kit';
 import { getLogger } from '@subql/node-core';
 import {
   DecodedData,
   SolanaInstruction,
   SolanaLogMessage,
   SubqlRuntimeDatasource,
 } from '@subql/types-solana';
+import bs58 from 'bs58';
+import {
+  BytesValueNode,
+  createFromRoot,
+  InstructionNode,
+  RootNode,
+} from 'codama';
 import { SolanaApi } from './api.solana';
 import { getProgramId } from './utils.solana';
 
 const logger = getLogger('SolanaDecoder');
 
+export function getBytesFromBytesValueNode(node: BytesValueNode): Uint8Array {
+  switch (node.encoding) {
+    case 'utf8':
+      return getUtf8Encoder().encode(node.data) as Uint8Array;
+    case 'base16':
+      return getBase16Encoder().encode(node.data) as Uint8Array;
+    case 'base58':
+      return getBase58Encoder().encode(node.data) as Uint8Array;
+    case 'base64':
+    default:
+      return getBase64Encoder().encode(node.data) as Uint8Array;
+  }
+}
+
+// TODO fill with appropriate type, this could be a codama or anchor IDL
+export type Idl = AnchorIdl | RootNode;
+
+function findInstructionNode(
+  rootNode: RootNode,
+  data: Buffer,
+): InstructionNode | undefined {
+  return rootNode.program.instructions.find((inst) => {
+    const discArg = inst.arguments.find((arg) => arg.name === 'discriminator');
+    if (!discArg) return false;
+
+    // TODO what about other types of discriminators or ones that are larger than 1 byte?
+    switch (discArg.defaultValue?.kind) {
+      case 'numberValueNode':
+        return data[0] === discArg.defaultValue.number;
+      case 'bytesValueNode': {
+        const defaultBytes = getBytesFromBytesValueNode(discArg.defaultValue);
+        return data.indexOf(defaultBytes) === 0;
+      }
+      case undefined:
+        break;
+      default:
+        throw new Error(
+          `Unable to handle unknown discriminator type ${discArg.defaultValue?.kind}`,
+        );
+    }
+
+    return false;
+  });
+}
+
+function findEventNode(
+  rootNode: RootNode,
+  data: Buffer,
+): InstructionNode | undefined {
+  throw new Error('Not implemented');
+}
+
+function decodeData(
+  idl: Idl,
+  data: Base58EncodedBytes,
+  getEncodableNode: (
+    rootNode: RootNode,
+    data: Buffer,
+  ) => InstructionNode | undefined,
+): DecodedData | null {
+  let codama = createFromRoot(rootNodeFromAnchor(idl as AnchorIdl));
+  // Check if the idl was an anchor idl
+  if (codama.getRoot().program.publicKey === '') {
+    codama = createFromRoot(idl as RootNode);
+  }
+
+  const root = codama.getRoot();
+  const buffer = bs58.decode(data);
+
+  const node = getEncodableNode(root, buffer);
+  if (!node) {
+    logger.warn(
+      `Failed to find instruction with discriminator in ${root.program.name}`,
+    );
+    return null;
+  }
+
+  try {
+    // Path is required to find other defined structs
+    const codec = getNodeCodec([root, root.program, node]);
+
+    // Strip the discriminator
+    const { discriminator, ...data } = codec.decode(buffer) as any;
+
+    return {
+      data: data,
+      name: node.name,
+    };
+  } catch (e) {
+    logger.warn(`Failed to decode data name: ${node.name}, error: ${e}`);
+    return null;
+  }
+}
+
+export function decodeInstruction(
+  idl: Idl,
+  data: Base58EncodedBytes,
+): DecodedData | null {
+  return decodeData(idl, data, findInstructionNode);
+}
+
+export function decodeLog(idl: Idl, message: string): DecodedData | null {
+  const data = message.replace('Program data:', '') as Base58EncodedBytes;
+  return decodeData(idl, data, findEventNode);
+}
+
 export class SolanaDecoder {
   idls: Record<string, Idl | null> = {};
-  instructionDecoders: Record<string, BorshInstructionCoder> = {};
-  eventDecoders: Record<string, BorshEventCoder> = {};
+  // instructionDecoders: Record<string, BorshInstructionCoder> = {};
+  // eventDecoders: Record<string, BorshEventCoder> = {};
 
   constructor(public api: SolanaApi) {}
 
@@ -45,12 +161,14 @@ export class SolanaDecoder {
     }
   }
 
+  // eslint-disable-next-line @typescript-eslint/require-await
   async getIdlFromChain(programId: string): Promise<Idl | null> {
-    this.idls[programId] ??= await Program.fetchIdl(programId, {
-      connection: this.api as any,
-    });
+    throw new Error('Not implemented');
+    // this.idls[programId] ??= await Program.fetchIdl(programId, {
+    //   connection: this.api as any,
+    // });
 
-    return this.idls[programId];
+    // return this.idls[programId];
   }
 
   async decodeInstruction(
@@ -66,11 +184,7 @@ export class SolanaDecoder {
         return null;
       }
 
-      const coder =
-        this.instructionDecoders[programId] ?? new BorshInstructionCoder(idl);
-      const decoded = coder.decode(instruction.data, 'base58');
-
-      return decoded;
+      return decodeInstruction(idl, instruction.data);
     } catch (e) {
       logger.debug(`Failed to decode instruction: ${e}`);
     }
@@ -89,10 +203,7 @@ export class SolanaDecoder {
         return null;
       }
 
-      const coder = this.eventDecoders[programId] ?? new BorshEventCoder(idl);
-      const decoded = coder.decode(log.message.replace('Program data:', ''));
-
-      return decoded;
+      return decodeLog(idl, log.message);
     } catch (e) {
       logger.debug(`Failed to decode log: ${e}`);
     }

packages/node/src/solana/utils.solana.spec.ts

@@ -1,10 +1,10 @@
 // Copyright 2020-2025 SubQuery Pte Ltd authors & contributors
 // SPDX-License-Identifier: GPL-3.0
 
-import { Idl } from '@coral-xyz/anchor';
+import { IdlV01 } from '@codama/nodes-from-anchor';
 import { getAnchorDiscriminator } from './utils.solana';
 
-const IDL_Jupiter: Idl = require('../../test/JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4.idl.json');
+const IDL_Jupiter: IdlV01 = require('../../test/JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4.idl.json');
 
 describe('SolanaUtils', () => {
   describe('Calculating discriminators', () => {