@subql/common-solana 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@subql/common-solana",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "",
   "scripts": {
     "build": "rm -rf dist && tsc -b",
@@ -16,8 +16,8 @@
   "dependencies": {
     "@codama/nodes-from-anchor": "^1.1.11",
     "@codama/renderers-js": "^1.2.10",
-    "@subql/common": "5.4.1-1",
-    "@subql/types-solana": "1.0.0",
+    "@subql/common": "^5.7.0",
+    "@subql/types-solana": "1.0.1",
     "codama": "^1.2.11",
     "js-yaml": "^4.1.0",
     "pino": "^6.13.3",
@@ -35,5 +35,18 @@
     "@types/rimraf": "3.0.2",
     "ejs": "3.1.10",
     "lodash": "4.17.21"
-  }
+  },
+  "files": [
+    "/dist",
+    "!/dist/**/*.spec.js",
+    "!/dist/**/*.spec.d.ts",
+    "!/dist/**/*.spec.js.map",
+    "!/dist/**/*.test.js",
+    "!/dist/**/*.test.d.ts",
+    "!/dist/**/*.test.js.map",
+    "package.json",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ]
 }

package/src/codegen/codegen.spec.ts

@@ -1,145 +0,0 @@
-// Copyright 2020-2025 SubQuery Pte Ltd authors & contributors
-// SPDX-License-Identifier: GPL-3.0
-
-import path from 'node:path';
-import {SolanaDatasourceKind, SolanaHandlerKind, SubqlRuntimeDatasource} from '@subql/types-solana';
-import rimraf from 'rimraf';
-import {generateIDLInterfaces, validateDiscriminators} from './codegen';
-
-const outDir = path.join(__dirname, 'test-output');
-
-describe('IDL Codegen', () => {
-  afterEach(() => {
-    rimraf.sync(outDir);
-  });
-
-  it('can generate an interface from an IDL', async () => {
-    const ds: SubqlRuntimeDatasource = {
-      kind: SolanaDatasourceKind.Runtime,
-      startBlock: 0,
-      assets: new Map([
-        ['jupiter', {file: '../../../../node/test/JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4.idl.json'}],
-      ]),
-      mapping: {
-        file: '',
-        handlers: [],
-      },
-    };
-
-    const renderTemplate = jest.fn().mockImplementation((templatePath, outputPath, templateData) => {
-      /* DO nothing*/
-    });
-
-    await expect(generateIDLInterfaces([ds], outDir, renderTemplate)).resolves.not.toThrow();
-
-    expect(renderTemplate).toHaveBeenCalledWith(
-      path.resolve(__dirname, '../../templates/idl.ts.ejs'),
-      path.join(outDir, '/src/types/handler-inputs/jupiter.ts'),
-      {
-        props: {
-          name: 'jupiter',
-          instructions: [
-            'Claim',
-            'ClaimToken',
-            'CloseToken',
-            'CreateOpenOrders',
-            'CreateProgramOpenOrders',
-            'CreateTokenLedger',
-            'CreateTokenAccount',
-            'ExactOutRoute',
-            'Route',
-            'RouteWithTokenLedger',
-            'SetTokenLedger',
-            'SharedAccountsExactOutRoute',
-            'SharedAccountsRoute',
-            'SharedAccountsRouteWithTokenLedger',
-          ],
-        },
-      }
-    );
-  });
-
-  describe('validating discriminators agains IDLs', () => {
-    it('can validate that a discriminator is part of an IDL', async () => {
-      const ds: SubqlRuntimeDatasource = {
-        kind: SolanaDatasourceKind.Runtime,
-        startBlock: 0,
-        assets: new Map([
-          [
-            'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4',
-            {file: '../../../../node/test/JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4.idl.json'},
-          ],
-        ]),
-        mapping: {
-          file: '',
-          handlers: [
-            {
-              handler: 'handleClaimToken',
-              kind: SolanaHandlerKind.Instruction,
-              filter: {
-                programId: 'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4',
-                discriminator: 'ClaimToken',
-              },
-            },
-          ],
-        },
-      };
-
-      await expect(validateDiscriminators([ds], outDir)).resolves.not.toThrow();
-    });
-
-    it('throws when an idl does not include the discriminator', async () => {
-      const ds: SubqlRuntimeDatasource = {
-        kind: SolanaDatasourceKind.Runtime,
-        startBlock: 0,
-        assets: new Map([
-          [
-            'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4',
-            {file: '../../../../node/test/JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4.idl.json'},
-          ],
-        ]),
-        mapping: {
-          file: '',
-          handlers: [
-            {
-              handler: 'handleClaimToken',
-              kind: SolanaHandlerKind.Instruction,
-              filter: {
-                programId: 'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4',
-                discriminator: 'InvalidDiscriminator',
-              },
-            },
-          ],
-        },
-      };
-
-      await expect(validateDiscriminators([ds], outDir)).rejects.toThrow(
-        'Datasource has a handler with a discriminator InvalidDiscriminator but no matching instruction found in IDL'
-      );
-    });
-
-    it('throws when there is no IDL', async () => {
-      const ds: SubqlRuntimeDatasource = {
-        kind: SolanaDatasourceKind.Runtime,
-        startBlock: 0,
-        mapping: {
-          file: '',
-          handlers: [
-            {
-              handler: 'handleClaimToken',
-              kind: SolanaHandlerKind.Instruction,
-              filter: {
-                programId: 'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4',
-                discriminator: 'ClaimToken',
-              },
-            },
-          ],
-        },
-      };
-
-      await expect(validateDiscriminators([ds], outDir)).rejects.toThrow(
-        'Datasource has a handler with a discriminator but no IDL file reference'
-      );
-    });
-  });
-});

package/src/codegen/codegen.ts

@@ -1,96 +0,0 @@
-// Copyright 2020-2025 SubQuery Pte Ltd authors & contributors
-// SPDX-License-Identifier: GPL-3.0
-
-import assert from 'node:assert';
-import path from 'node:path';
-import {renderVisitor} from '@codama/renderers-js';
-import {SolanaDatasourceKind, SolanaHandlerKind, SubqlDatasource, SubqlRuntimeDatasource} from '@subql/types-solana';
-import {pascalCase} from 'codama';
-import {Data} from 'ejs';
-import {parseIdlFromFile, findInstructionDiscriminatorByName} from './idl';
-
-const INSTRUCTION_TEMPLATE_TS = path.resolve(__dirname, '../../templates/idl.ts.ejs');
-const CODAMA_PATH = '/src/types/program-interfaces';
-const IDL_PATH = '/src/types/handler-inputs';
-
-export async function validateDiscriminators(
-  dataSources: SubqlRuntimeDatasource[],
-  projectPath: string
-): Promise<void> {
-  const issues: string[] = [];
-
-  for (const ds of dataSources) {
-    for (const handler of ds.mapping.handlers) {
-      if (!handler.filter) {
-        break;
-      }
-      switch (handler.kind) {
-        case SolanaHandlerKind.Instruction: {
-          if (handler.filter.discriminator && handler.filter.programId) {
-            const fileRef = ds.assets?.get(handler.filter.programId);
-            if (!fileRef) {
-              issues.push(`Datasource has a handler with a discriminator but no IDL file reference`);
-              continue;
-            }
-
-            const idlPath = path.join(projectPath, fileRef.file);
-            const idl = await parseIdlFromFile(idlPath);
-
-            if (!findInstructionDiscriminatorByName(idl.getRoot(), handler.filter.discriminator)) {
-              issues.push(
-                `Datasource has a handler with a discriminator ${handler.filter.discriminator} but no matching instruction found in IDL`
-              );
-            }
-            // TODO check discriminator in IDL
-          }
-          break;
-        }
-        default:
-        /* Do nothing, there is nothing extra to validate*/
-      }
-    }
-  }
-
-  assert(issues.length === 0, issues.join('\n'));
-}
-
-export async function generateIDLInterfaces(
-  dataSources: SubqlDatasource[],
-  projectPath: string,
-  renderTemplate: (templatePath: string, outputPath: string, templateData: Data) => Promise<void>
-): Promise<void> {
-  // @subql/cli package calls this function with datasources as an array of objects
-  dataSources = dataSources.map((d) => ({
-    ...d,
-    assets: d?.assets ? (d.assets instanceof Map ? d.assets : new Map(Object.entries(d.assets))) : undefined,
-  })) as SubqlRuntimeDatasource[];
-
-  const allAssets = new Map(
-    dataSources.filter((ds) => ds.assets !== undefined).flatMap((ds) => Array.from(ds.assets!.entries()))
-  );
-
-  await validateDiscriminators(
-    dataSources.filter((ds) => ds.kind === SolanaDatasourceKind.Runtime) as SubqlRuntimeDatasource[],
-    projectPath
-  );
-
-  for (const [name, fileRef] of allAssets) {
-    const idlPath = path.join(projectPath, fileRef.file);
-    const idl = await parseIdlFromFile(idlPath);
-
-    const output = path.join(projectPath, CODAMA_PATH, name);
-
-    await idl.accept(renderVisitor(output, {}));
-
-    const instructionNames = idl.getRoot().program.instructions.map((inst) => pascalCase(inst.name));
-
-    await renderTemplate(INSTRUCTION_TEMPLATE_TS, path.join(projectPath, IDL_PATH, `${name}.ts`), {
-      props: {
-        name,
-        instructions: instructionNames,
-      },
-    });
-
-    console.log(`* IDL ${name} generated`);
-  }
-}

package/src/codegen/idl.ts

@@ -1,89 +0,0 @@
-// Copyright 2020-2025 SubQuery Pte Ltd authors & contributors
-// SPDX-License-Identifier: GPL-3.0
-
-import fs from 'node:fs';
-import {AnchorIdl, IdlV01, rootNodeFromAnchor} from '@codama/nodes-from-anchor';
-import {getBase16Encoder, getBase58Encoder, getBase64Encoder, getUtf8Encoder} from '@solana/codecs-strings';
-import {BytesValueNode, InstructionNode, RootNode, Codama, createFromRoot, camelCase} from 'codama';
-
-export type Idl = AnchorIdl | RootNode;
-
-export function isAnchorIdl(idl: Idl): idl is AnchorIdl {
-  return !isRootNode(idl);
-}
-
-export function isAnchorIdlV01(idl: Idl): idl is IdlV01 {
-  return isAnchorIdl(idl) && (idl.metadata as {spec?: string}).spec === '0.1.0';
-}
-
-export function isRootNode(idl: Idl): idl is RootNode {
-  return !!(idl as RootNode).program?.publicKey;
-}
-
-export function parseIdl(idl: Idl): Codama {
-  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);
-  }
-
-  return codama;
-}
-
-export async function parseIdlFromFile(path: string): Promise<Codama> {
-  const idlStr = await fs.promises.readFile(path, 'utf-8');
-  const idlJSON = JSON.parse(idlStr);
-
-  return parseIdl(idlJSON);
-}
-
-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;
-  }
-}
-
-export function getInstructionDiscriminatorBytes(node: InstructionNode): Buffer {
-  const discArg = node.arguments.find((arg) => arg.name === 'discriminator');
-  if (!discArg) {
-    throw new Error(`Instruction ${node.name} does not have a discriminator`);
-  }
-
-  // TODO what about other types of discriminators or ones that are larger than 1 byte?
-  switch (discArg.defaultValue?.kind) {
-    case 'numberValueNode':
-      return Buffer.from([discArg.defaultValue.number]);
-    case 'bytesValueNode':
-      return Buffer.from(getBytesFromBytesValueNode(discArg.defaultValue));
-    case undefined:
-      break;
-    default:
-      throw new Error(`Unable to handle unknown discriminator type ${discArg.defaultValue?.kind}`);
-  }
-
-  throw new Error(`Unable to find discriminator for instruction ${node.name}`);
-}
-
-export function findInstructionDiscriminatorByName(rootNode: RootNode, name: string): Buffer | undefined {
-  const inst = rootNode.program.instructions.find((inst) => inst.name === name || inst.name === camelCase(name));
-  if (!inst) {
-    return undefined;
-  }
-
-  try {
-    return getInstructionDiscriminatorBytes(inst);
-  } catch (e) {
-    // logger.debug(
-    //   `Failed to get discriminator for instruction ${inst.name}: ${e}`,
-    // );
-    return undefined;
-  }
-}

package/src/codegen/index.ts

@@ -1,5 +0,0 @@
-// Copyright 2020-2025 SubQuery Pte Ltd authors & contributors
-// SPDX-License-Identifier: GPL-3.0
-
-export * from './codegen';
-export * from './idl';

package/src/index.ts

@@ -1,16 +0,0 @@
-// Copyright 2020-2025 SubQuery Pte Ltd authors & contributors
-// SPDX-License-Identifier: GPL-3.0
-
-export * from './codegen';
-export * from './project';
-
-import {SolanaNetworkModule} from '@subql/types-solana';
-import * as c from './codegen';
-import * as p from './project';
-
-// This provides a compiled time check to ensure that the correct exports are provided
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const _ = {
-  ...p,
-  ...c,
-} satisfies SolanaNetworkModule;

package/src/project/index.ts

@@ -1,11 +0,0 @@
-// Copyright 2020-2025 SubQuery Pte Ltd authors & contributors
-// SPDX-License-Identifier: GPL-3.0
-
-export * from './load';
-export * from './models';
-export * from './types';
-export * from './utils';
-export * from './versioned';
-
-import { parseSolanaProjectManifest } from './load';
-export { parseSolanaProjectManifest as parseProjectManifest };

package/src/project/load.ts

@@ -1,10 +0,0 @@
-// Copyright 2020-2025 SubQuery Pte Ltd authors & contributors
-// SPDX-License-Identifier: GPL-3.0
-
-import { SolanaProjectManifestVersioned, VersionedProjectManifest } from './versioned';
-
-export function parseSolanaProjectManifest(raw: unknown): SolanaProjectManifestVersioned {
-  const projectManifest = new SolanaProjectManifestVersioned(raw as VersionedProjectManifest);
-  projectManifest.validate();
-  return projectManifest;
-}

package/src/project/models.ts

@@ -1,213 +0,0 @@
-// Copyright 2020-2025 SubQuery Pte Ltd authors & contributors
-// SPDX-License-Identifier: GPL-3.0
-
-import {BaseDataSource, BlockFilterImpl, forbidNonWhitelisted} from '@subql/common';
-import {FileReference} from '@subql/types-core';
-import {
-  SolanaHandlerKind,
-  SolanaDatasourceKind,
-  SolanaLogFilter,
-  SubqlCustomHandler,
-  SubqlMapping,
-  SubqlHandler,
-  SubqlRuntimeHandler,
-  SubqlRuntimeDatasource,
-  SubqlCustomDatasource,
-  SubqlBlockHandler,
-  SubqlTransactionHandler,
-  SolanaTransactionFilter,
-  SolanaBlockFilter,
-  SolanaInstructionFilter,
-  SubqlInstructionHandler,
-  SubqlLogHandler,
-  InstructionAccountFilter,
-} from '@subql/types-solana';
-import {plainToClass, Transform, Type} from 'class-transformer';
-import {
-  IsArray,
-  IsEnum,
-  IsOptional,
-  IsString,
-  IsObject,
-  ValidateNested,
-  ValidateIf,
-  IsDefined,
-  IsBoolean,
-} from 'class-validator';
-
-export class BlockFilter extends BlockFilterImpl implements SolanaBlockFilter {}
-
-export class TransactionFilter implements SolanaTransactionFilter {
-  @IsOptional()
-  @IsString()
-  signerAccountKey?: string;
-}
-
-export class InstructionFilter implements SolanaInstructionFilter {
-  @ValidateIf((o) => o.discriminator !== undefined)
-  @IsDefined({message: 'programId is required if discriminator is set'})
-  @IsString()
-  programId?: string;
-
-  @IsOptional()
-  @IsString()
-  discriminator?: string;
-
-  @IsOptional()
-  @IsArray()
-  accounts?: [
-    InstructionAccountFilter,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?,
-    InstructionAccountFilter?
-  ];
-
-  @IsOptional()
-  @IsBoolean()
-  includeFalied?: boolean;
-}
-
-export class LogFilter implements SolanaLogFilter {
-  @IsOptional()
-  @IsString()
-  programId?: string;
-}
-
-export class BlockHandler implements SubqlBlockHandler {
-  @IsObject()
-  @IsOptional()
-  @Type(() => BlockFilter)
-  filter?: BlockFilter;
-  @IsEnum(SolanaHandlerKind, {groups: [SolanaHandlerKind.Block]})
-  kind!: SolanaHandlerKind.Block;
-  @IsString()
-  handler!: string;
-}
-
-export class TransactionHandler implements SubqlTransactionHandler {
-  @IsOptional()
-  @ValidateNested()
-  @Type(() => TransactionFilter)
-  filter?: SolanaTransactionFilter;
-  @IsEnum(SolanaHandlerKind, {groups: [SolanaHandlerKind.Transaction]})
-  kind!: SolanaHandlerKind.Transaction;
-  @IsString()
-  handler!: string;
-}
-
-export class InstructionHandler implements SubqlInstructionHandler {
-  @IsOptional()
-  @ValidateNested()
-  @Type(() => InstructionFilter)
-  filter?: SolanaInstructionFilter;
-  @IsEnum(SolanaHandlerKind, {groups: [SolanaHandlerKind.Instruction]})
-  kind!: SolanaHandlerKind.Instruction;
-  @IsString()
-  handler!: string;
-}
-
-export class LogHandler implements SubqlLogHandler {
-  @IsOptional()
-  @ValidateNested()
-  @Type(() => LogFilter)
-  filter?: SolanaLogFilter;
-  @IsEnum(SolanaHandlerKind, {groups: [SolanaHandlerKind.Log]})
-  kind!: SolanaHandlerKind.Log;
-  @IsString()
-  handler!: string;
-}
-
-export class CustomHandler implements SubqlCustomHandler {
-  @IsString()
-  kind!: string;
-  @IsString()
-  handler!: string;
-  @IsObject()
-  @IsOptional()
-  filter?: Record<string, unknown>;
-}
-
-export class SolanaMapping implements SubqlMapping {
-  @Transform((params) => {
-    const handlers: SubqlHandler[] = params.value;
-    return handlers.map((handler) => {
-      switch (handler.kind) {
-        case SolanaHandlerKind.Log:
-          return plainToClass(LogHandler, handler);
-        case SolanaHandlerKind.Instruction:
-          return plainToClass(InstructionHandler, handler);
-        case SolanaHandlerKind.Transaction:
-          return plainToClass(TransactionHandler, handler);
-        case SolanaHandlerKind.Block:
-          return plainToClass(BlockHandler, handler);
-        default:
-          throw new Error(`handler ${(handler as any).kind} not supported`);
-      }
-    });
-  })
-  @IsArray()
-  @ValidateNested()
-  handlers!: SubqlHandler[];
-  @IsString()
-  file!: string;
-}
-
-export class CustomMapping implements SubqlMapping<SubqlCustomHandler> {
-  @IsArray()
-  @Type(() => CustomHandler)
-  @ValidateNested()
-  handlers!: CustomHandler[];
-  @IsString()
-  file!: string;
-}
-
-export class RuntimeDataSourceBase<M extends SubqlMapping<SubqlRuntimeHandler>>
-  extends BaseDataSource
-  implements SubqlRuntimeDatasource<M>
-{
-  @IsEnum(SolanaDatasourceKind, {
-    groups: [SolanaDatasourceKind.Runtime],
-  })
-  kind!: SolanaDatasourceKind.Runtime;
-  @Type(() => SolanaMapping)
-  @ValidateNested()
-  mapping!: M;
-  @Type(() => FileReferenceImpl)
-  @ValidateNested({each: true})
-  @IsOptional()
-  assets?: Map<string, FileReference>;
-}
-
-export class FileReferenceImpl implements FileReference {
-  @IsString()
-  file!: string;
-}
-
-export class CustomDataSourceBase<K extends string, M extends SubqlMapping = SubqlMapping<SubqlCustomHandler>>
-  extends BaseDataSource
-  implements SubqlCustomDatasource<K, M>
-{
-  @IsString()
-  kind!: K;
-  @Type(() => CustomMapping)
-  @ValidateNested()
-  mapping!: M;
-  @Type(() => FileReferenceImpl)
-  @ValidateNested({each: true})
-  assets!: Map<string, FileReference>;
-  @Type(() => FileReferenceImpl)
-  @IsObject()
-  processor!: FileReference;
-}