@sentio/sdk 2.0.0-rc.14 → 2.0.0-rc.16

package/src/solana/builtin/types.ts

@@ -0,0 +1,279 @@
+/* eslint-disable @typescript-eslint/no-redeclare */
+// copy from https://github.com/solana-labs/solana/blob/master/explorer/src/components/instruction/token/types.ts
+
+import {
+  enums,
+  type,
+  Infer,
+  number,
+  string,
+  optional,
+  array,
+  nullable,
+  union,
+  coerce,
+  instance,
+} from "superstruct";
+
+// Replace with string
+export const PublicKeyFromString = coerce(
+  instance(String),
+  string(),
+  (value) => (value)
+);
+
+export type TokenAmountUi = Infer<typeof TokenAmountUi>;
+export type MintTo = Infer<typeof MintTo>;
+export type Burn = Infer<typeof Burn>;
+export type InitializeMint = Infer<typeof InitializeMint>;
+export type InitializeAccount = Infer<typeof InitializeAccount>;
+export type InitializeAccount2 = Infer<typeof InitializeAccount2>;
+export type InitializeAccount3 = Infer<typeof InitializeAccount3>;
+export type InitializeMultisig = Infer<typeof InitializeMultisig>;
+
+export const TokenAmountUi = type({
+  amount: string(),
+  decimals: number(),
+  uiAmountString: string(),
+});
+
+const InitializeMint = type({
+  mint: PublicKeyFromString,
+  decimals: number(),
+  mintAuthority: PublicKeyFromString,
+  rentSysvar: PublicKeyFromString,
+  freezeAuthority: optional(PublicKeyFromString),
+});
+
+const InitializeAccount = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  owner: PublicKeyFromString,
+  rentSysvar: PublicKeyFromString,
+});
+
+const InitializeAccount2 = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  rentSysvar: PublicKeyFromString,
+  owner: PublicKeyFromString,
+});
+
+const InitializeAccount3 = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  owner: PublicKeyFromString,
+});
+
+const InitializeMultisig = type({
+  multisig: PublicKeyFromString,
+  rentSysvar: PublicKeyFromString,
+  signers: array(PublicKeyFromString),
+  m: number(),
+});
+
+export type Transfer = Infer<typeof Transfer>;
+export const Transfer = type({
+  source: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  amount: union([string(), number()]),
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+export type Approve = Infer<typeof Approve>;
+const Approve = type({
+  source: PublicKeyFromString,
+  delegate: PublicKeyFromString,
+  amount: union([string(), number()]),
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+export type Revoke = Infer<typeof Revoke>;
+const Revoke = type({
+  source: PublicKeyFromString,
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const AuthorityType = enums([
+  "mintTokens",
+  "freezeAccount",
+  "accountOwner",
+  "closeAccount",
+]);
+
+export type SetAuthority = Infer<typeof SetAuthority>;
+const SetAuthority = type({
+  mint: optional(PublicKeyFromString),
+  account: optional(PublicKeyFromString),
+  authorityType: AuthorityType,
+  newAuthority: nullable(PublicKeyFromString),
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const MintTo = type({
+  mint: PublicKeyFromString,
+  account: PublicKeyFromString,
+  amount: union([string(), number()]),
+  mintAuthority: optional(PublicKeyFromString),
+  multisigMintAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const Burn = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  amount: union([string(), number()]),
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+const CloseAccount = type({
+  account: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+export type CloseAccount = Infer<typeof CloseAccount>;
+
+export type FreezeAccount = Infer<typeof FreezeAccount>;
+const FreezeAccount = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  freezeAuthority: optional(PublicKeyFromString),
+  multisigFreezeAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+export type ThawAccount = Infer<typeof ThawAccount>;
+const ThawAccount = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  freezeAuthority: optional(PublicKeyFromString),
+  multisigFreezeAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+export type TransferChecked = Infer<typeof TransferChecked>;
+export const TransferChecked = type({
+  source: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  destination: PublicKeyFromString,
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  tokenAmount: TokenAmountUi,
+});
+
+export type ApproveChecked = Infer<typeof ApproveChecked>;
+const ApproveChecked = type({
+  source: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  delegate: PublicKeyFromString,
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  tokenAmount: TokenAmountUi,
+});
+
+export type MintToChecked = Infer<typeof MintToChecked>;
+const MintToChecked = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  mintAuthority: optional(PublicKeyFromString),
+  multisigMintAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  tokenAmount: TokenAmountUi,
+});
+
+export type BurnChecked = Infer<typeof BurnChecked>;
+const BurnChecked = type({
+  account: PublicKeyFromString,
+  mint: PublicKeyFromString,
+  authority: optional(PublicKeyFromString),
+  multisigAuthority: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+  tokenAmount: TokenAmountUi,
+});
+
+export type SyncNative = Infer<typeof BurnChecked>;
+const SyncNative = type({
+  account: PublicKeyFromString,
+});
+
+export type GetAccountDataSize = Infer<typeof GetAccountDataSize>;
+const GetAccountDataSize = type({
+  mint: PublicKeyFromString,
+  extensionTypes: optional(array(string())),
+});
+
+export type InitializeImmutableOwner = Infer<typeof InitializeImmutableOwner>;
+const InitializeImmutableOwner = type({
+  account: PublicKeyFromString,
+});
+
+export type AmountToUiAmount = Infer<typeof AmountToUiAmount>;
+const AmountToUiAmount = type({
+  mint: PublicKeyFromString,
+  amount: union([string(), number()]),
+});
+
+export type UiAmountToAmount = Infer<typeof UiAmountToAmount>;
+const UiAmountToAmount = type({
+  mint: PublicKeyFromString,
+  uiAmount: string(),
+});
+
+export type InitializeMintCloseAuthority = Infer<typeof InitializeMintCloseAuthority>;
+const InitializeMintCloseAuthority = type({
+  mint: PublicKeyFromString,
+  newAuthority: PublicKeyFromString,
+});
+
+export type TransferFeeExtension = Infer<typeof TransferFeeExtension>;
+const TransferFeeExtension = type({
+  mint: PublicKeyFromString,
+  transferFeeConfigAuthority: PublicKeyFromString,
+  withdrawWitheldAuthority: PublicKeyFromString,
+  transferFeeBasisPoints: number(),
+  maximumFee: number(),
+});
+
+export type DefaultAccountStateExtension = Infer<typeof DefaultAccountStateExtension>;
+const DefaultAccountStateExtension = type({
+  mint: PublicKeyFromString,
+  accountState: string(),
+  freezeAuthority: optional(PublicKeyFromString),
+});
+
+export type Reallocate = Infer<typeof Reallocate>;
+const Reallocate = type({
+  account: PublicKeyFromString,
+  payer: PublicKeyFromString,
+  systemProgram: PublicKeyFromString,
+  extensionTypes: array(string()),
+});
+
+export type MemoTransferExtension = Infer<typeof MemoTransferExtension>;
+const MemoTransferExtension = type({
+  account: PublicKeyFromString,
+  owner: optional(PublicKeyFromString),
+  multisigOwner: optional(PublicKeyFromString),
+  signers: optional(array(PublicKeyFromString)),
+});
+
+export type CreateNativeMint = Infer<typeof CreateNativeMint>;
+const CreateNativeMint = type({
+  payer: PublicKeyFromString,
+  nativeMint: PublicKeyFromString,
+  systemProgram: PublicKeyFromString,
+});

package/src/solana/codegen/codegen.ts

@@ -0,0 +1,140 @@
+import path from 'path'
+import fs from 'fs'
+import chalk from 'chalk'
+import { Idl } from '@project-serum/anchor'
+import { IdlAccountItem, IdlField, IdlInstruction, IdlType } from '@project-serum/anchor/dist/cjs/idl.js'
+
+export function codeGenSolanaProcessor(abisDir: string, targetPath = path.join('src', 'types', 'solana')) {
+  if (!fs.existsSync(abisDir)) {
+    return
+  }
+
+  const abisFiles = fs.readdirSync(abisDir)
+
+  if (abisFiles.length > 0) {
+    console.log(chalk.green('Generated Types for Solana'))
+  }
+
+  for (const file of abisFiles) {
+    if (path.extname(file) === '.json') {
+      if (!fs.existsSync(targetPath)) {
+        fs.mkdirSync(targetPath, { recursive: true })
+      }
+      const idlContent = fs.readFileSync(path.join(abisDir, file), 'utf-8')
+      const idlObj = JSON.parse(idlContent)
+      const idlName = idlObj.name
+      const idlFile = path.join(targetPath, idlName + '.ts')
+      fs.writeFileSync(idlFile, `export const ${idlName}_idl = ${idlContent}`)
+      fs.writeFileSync(path.join(targetPath, `${idlName}_processor.ts`), codeGenSolanaIdlProcessor(idlObj))
+    }
+  }
+}
+
+function codeGenSolanaIdlProcessor(idlObj: Idl): string {
+  const idlName = idlObj.name
+  const idlNamePascalCase = toPascalCase(idlName)
+  const instructions: any[] = idlObj.instructions
+  return `import { BorshInstructionCoder, Instruction, Idl } from '@project-serum/anchor'
+import { SolanaBaseProcessor, SolanaContext, SolanaBindOptions } from "@sentio/sdk/solana"
+import { ${idlName}_idl } from "./${idlName}.js"
+import { PublicKey } from '@solana/web3.js'
+
+export class ${idlNamePascalCase}Processor extends SolanaBaseProcessor {
+  static DEFAULT_OPTIONS = {
+    name: '${idlNamePascalCase}',
+    instructionCoder: new BorshInstructionCoder(${idlName}_idl as Idl)
+  }
+
+  static bind(options: SolanaBindOptions): ${idlNamePascalCase}Processor {
+    return new ${idlNamePascalCase}Processor( { ...${idlNamePascalCase}Processor.DEFAULT_OPTIONS, ...options })
+  }
+
+  ${instructions.map((ins) => codeGenSolanaInstruction(idlNamePascalCase, ins)).join('')}
+}
+  `
+}
+
+function codeGenSolanaInstruction(idlName: string, ins: IdlInstruction): string {
+  const instructionName = ins.name
+
+  const argsType = codeGenInstructionArgsType(ins.args)
+  const accountType = codeGenAccountType(ins.accounts)
+
+  return `
+  on${
+    instructionName.charAt(0).toUpperCase() + instructionName.slice(1)
+  }(handler: (args: ${argsType}, accounts: ${accountType}, ctx: SolanaContext) => void): ${idlName}Processor {
+    this.onInstruction('${instructionName}', (ins: Instruction, ctx, accounts: string[]) => {
+      const origin = ins.data as any
+      if (origin) {
+        const data = ${codeGenInstructionArgs(ins.args)}
+        const accountData = ${codeGenAccountTypeArgs(ins.accounts)}
+        handler(data, accountData, ctx)
+      }
+    })
+    return this
+  }
+  `
+}
+
+function codeGenInstructionArgs(args: IdlField[]): string {
+  return `{ ${args.map((arg) => codeGenInstructionArg(arg.name, arg.type)).join(', ')} }`
+}
+
+function codeGenInstructionArg(name: string, type: IdlType): string {
+  const mType = mapType(type)
+  if (mType === 'bigint') {
+    return `${name}: BigInt(origin.${name}.toString())`
+  }
+  return `${name}: origin.${name} as ${mType}`
+}
+
+function codeGenInstructionArgsType(args: IdlField[]): string {
+  return `{ ${args.map((arg) => arg.name + ': ' + mapType(arg.type)).join(', ')} }`
+}
+
+function codeGenAccountType(args: IdlAccountItem[]): string {
+  return `{ ${args.map((arg) => arg.name + ': string').join(', ')} }`
+}
+
+function codeGenAccountTypeArgs(args: IdlAccountItem[]): string {
+  return `{ ${args.map((arg, idx) => `${arg.name}: accounts[${idx}]`).join(', ')} }`
+}
+
+// Reference: https://github.com/coral-xyz/anchor/blob/93332766f13e86efbe77c9986722731742317ede/ts/src/program/namespace/types.ts#L104
+function mapType(tpe: IdlType): string {
+  // TODO handle complex type
+  switch (tpe) {
+    case 'publicKey':
+      return 'PublicKey'
+    case 'bool':
+      return 'boolean'
+    case 'string':
+      return 'string'
+    case 'u8':
+    case 'i8':
+    case 'u16':
+    case 'i16':
+    case 'u32':
+    case 'i32':
+    case 'f32':
+    case 'f64':
+      return 'number'
+    case 'u64':
+    case 'i64':
+    case 'u128':
+    case 'i128':
+      return 'bigint'
+    default:
+      return 'any'
+  }
+}
+
+function toPascalCase(str: string) {
+  return `${str}`
+    .toLowerCase()
+    .replace(new RegExp(/[-_]+/, 'g'), ' ')
+    .replace(new RegExp(/[^\w\s]/, 'g'), '')
+    .replace(new RegExp(/\s+(.)(\w*)/, 'g'), ($1, $2, $3) => `${$2.toUpperCase() + $3}`)
+    .replace(new RegExp(/\w/), (s) => s.toUpperCase())
+}

package/src/solana/codegen/index.ts

@@ -0,0 +1 @@
+export * from './codegen.js'

package/src/solana/codegen/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "rootDir": "..",
+    "outDir": "../../../lib"
+  },
+  "extends": "@sentio/sdk-solana/tsconfig.json",
+  "include": ["./"]
+}

package/src/solana/index.ts

@@ -0,0 +1,4 @@
+export * from './solana-plugin.js'
+export * from './solana-context.js'
+export * from './solana-processor.js'
+export * from './solana-options.js'

package/src/solana/run-codegen.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+import path from 'path'
+import { codeGenSolanaProcessor } from './codegen/codegen.js'
+
+if (process.argv.length > 3) {
+  const abisDir = process.argv[2]
+  const targetDir = process.argv[3]
+  codeGenSolanaProcessor(abisDir, targetDir)
+} else {
+  console.error('Not enough argument')
+  process.exit(1)
+}

package/src/solana/solana-context.ts

@@ -0,0 +1,30 @@
+import { normalizeLabels, Labels, BaseContext, RecordMetaData, CHAIN_IDS } from '@sentio/sdk'
+
+export class SolanaContext extends BaseContext {
+  network: string
+  address: string
+  programName: string
+  blockNumber: bigint
+
+  constructor(programName: string, network: string, address: string, slot: bigint) {
+    super()
+    this.network = network || CHAIN_IDS.SOLANA_MAINNET
+    this.programName = programName
+    this.address = address
+    this.blockNumber = slot
+  }
+
+  getMetaData(name: string, labels: Labels): RecordMetaData {
+    return {
+      address: this.address,
+      contractName: this.programName,
+      blockNumber: this.blockNumber,
+      transactionIndex: 0,
+      transactionHash: '', // TODO add
+      logIndex: 0,
+      chainId: this.network,
+      name: name,
+      labels: normalizeLabels(labels),
+    }
+  }
+}

package/src/solana/solana-options.ts

@@ -0,0 +1,11 @@
+import { InstructionCoder } from './solana-processor.js'
+
+export class SolanaBindOptions {
+  address: string
+  network?: string
+  name?: string
+  startBlock?: bigint | number
+  endBlock?: bigint | number
+  processInnerInstruction?: boolean
+  instructionCoder?: InstructionCoder
+}

package/src/solana/solana-plugin.ts

@@ -0,0 +1,103 @@
+import { errorString, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
+import { ContractConfig, DataBinding, HandlerType, ProcessConfigResponse, ProcessResult } from '@sentio/protos'
+
+import { ServerError, Status } from 'nice-grpc'
+
+import { SolanaProcessorState } from './solana-processor.js'
+import { Instruction as SolInstruction } from '@project-serum/anchor'
+
+export class SolanaPlugin extends Plugin {
+  name: string = 'SolanaPlugin'
+
+  async configure(config: ProcessConfigResponse) {
+    // Part 2, prepare solana constractors
+    for (const solanaProcessor of SolanaProcessorState.INSTANCE.getValues()) {
+      const contractConfig: ContractConfig = {
+        transactionConfig: [],
+        processorType: USER_PROCESSOR,
+        contract: {
+          name: solanaProcessor.contractName,
+          chainId: solanaProcessor.network,
+          address: solanaProcessor.address,
+          abi: '',
+        },
+        logConfigs: [],
+        traceConfigs: [],
+        intervalConfigs: [],
+        startBlock: solanaProcessor.config.startSlot,
+        endBlock: 0n,
+        instructionConfig: {
+          innerInstruction: solanaProcessor.processInnerInstruction,
+          parsedInstruction: solanaProcessor.fromParsedInstruction !== null,
+          rawDataInstruction: solanaProcessor.decodeInstruction !== null,
+        },
+        aptosEventConfigs: [],
+        aptosCallConfigs: [],
+      }
+      config.contractConfigs.push(contractConfig)
+    }
+  }
+
+  supportedHandlers = [HandlerType.SOL_INSTRUCTION]
+
+  processBinding(request: DataBinding): Promise<ProcessResult> {
+    switch (request.handlerType) {
+      case HandlerType.SOL_INSTRUCTION:
+        return this.processSolInstruction(request)
+      default:
+        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    }
+  }
+
+  async processSolInstruction(request: DataBinding): Promise<ProcessResult> {
+    if (!request.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, 'instruction data cannot be empty')
+    }
+    if (!request.data.solInstruction) {
+      throw new ServerError(Status.INVALID_ARGUMENT, 'instruction data cannot be empty')
+    }
+
+    const instruction = request.data.solInstruction
+    const promises: Promise<ProcessResult>[] = []
+
+    // Only have instruction handlers for solana processors
+    for (const processor of SolanaProcessorState.INSTANCE.getValues()) {
+      if (processor.address === instruction.programAccountId) {
+        let parsedInstruction: SolInstruction | null = null
+
+        try {
+          if (instruction.parsed) {
+            parsedInstruction = processor.getParsedInstruction(instruction.parsed as { type: string; info: any })
+          } else if (instruction.instructionData) {
+            parsedInstruction = processor.getParsedInstruction(instruction.instructionData)
+          }
+        } catch (e) {
+          throw new ServerError(
+            Status.INTERNAL,
+            'Failed to decode instruction: ' + JSON.stringify(instruction) + errorString(e)
+          )
+        }
+        if (parsedInstruction == null) {
+          continue
+        }
+        const insHandler = processor.getInstructionHandler(parsedInstruction)
+        if (insHandler == null) {
+          continue
+        }
+        const res = processor
+          .handleInstruction(parsedInstruction, instruction.accounts, insHandler, instruction.slot)
+          .catch((e) => {
+            throw new ServerError(
+              Status.INTERNAL,
+              'Error processing instruction: ' + JSON.stringify(instruction) + '\n' + errorString(e)
+            )
+          })
+
+        promises.push(res)
+      }
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+}
+
+PluginManager.INSTANCE.register(new SolanaPlugin())

package/src/solana/solana-processor.ts

@@ -0,0 +1,102 @@
+import { ProcessResult } from '@sentio/protos'
+import { SolanaContext } from './solana-context.js'
+import { Instruction } from '@project-serum/anchor'
+import { SolanaBindOptions } from './solana-options.js'
+import { ListStateStorage } from '@sentio/runtime'
+import { CHAIN_IDS } from '@sentio/sdk'
+
+type IndexConfigure = {
+  startSlot: bigint
+  endSlot?: bigint
+}
+
+export interface InstructionCoder {
+  decode(ix: Buffer | string, encoding?: 'hex' | 'base58'): Instruction | null
+}
+
+export type SolanaInstructionHandler = (instruction: Instruction, ctx: SolanaContext, accounts?: string[]) => void
+
+export class SolanaProcessorState extends ListStateStorage<SolanaBaseProcessor> {
+  static INSTANCE: SolanaProcessorState = new SolanaProcessorState()
+}
+
+export class SolanaBaseProcessor {
+  public instructionHandlerMap: Map<string, SolanaInstructionHandler> = new Map()
+  address: string
+  endpoint: string
+  contractName: string
+  network: string
+  processInnerInstruction: boolean
+  config: IndexConfigure = { startSlot: 0n }
+  instructionCoder: InstructionCoder
+
+  decodeInstruction(rawInstruction: string): Instruction | null {
+    if (this.instructionCoder) {
+      return this.instructionCoder.decode(rawInstruction, 'base58')
+    }
+    return null
+  }
+
+  fromParsedInstruction: (instruction: { type: string; info: any }) => Instruction | null
+
+  constructor(options: SolanaBindOptions) {
+    this.address = options.address
+    this.contractName = options.name || ''
+    this.processInnerInstruction = options.processInnerInstruction || false
+    this.network = options.network || CHAIN_IDS.SOLANA_MAINNET
+    if (options.instructionCoder) {
+      this.instructionCoder = options.instructionCoder
+    }
+    if (options.startBlock) {
+      this.startSlot(options.startBlock)
+    }
+    if (options.endBlock) {
+      this.endBlock(options.endBlock)
+    }
+    this.endpoint = options.network || 'https://api.mainnet-beta.solana.com'
+
+    SolanaProcessorState.INSTANCE.addValue(this)
+  }
+
+  public onInstruction(instructionName: string, handler: SolanaInstructionHandler) {
+    this.instructionHandlerMap.set(instructionName, handler)
+    return this
+  }
+
+  public getParsedInstruction(ins: string | { type: string; info: any }): Instruction | null {
+    if (ins) {
+      if ((ins as { type: string; info: any }).info) {
+        return this.fromParsedInstruction ? this.fromParsedInstruction(ins as { type: string; info: any }) : null
+      }
+      if (this.decodeInstruction != null) {
+        return this.decodeInstruction(ins as string)
+      }
+    }
+    return null
+  }
+
+  public getInstructionHandler(parsedInstruction: Instruction): SolanaInstructionHandler | undefined {
+    return this.instructionHandlerMap.get(parsedInstruction.name)
+  }
+
+  public async handleInstruction(
+    parsedInstruction: Instruction,
+    accounts: string[],
+    handler: SolanaInstructionHandler,
+    slot: bigint
+  ): Promise<ProcessResult> {
+    const ctx = new SolanaContext(this.contractName, this.network, this.address, slot)
+    await handler(parsedInstruction, ctx, accounts)
+    return ctx.getProcessResult()
+  }
+
+  public startSlot(startSlot: bigint | number) {
+    this.config.startSlot = BigInt(startSlot)
+    return this
+  }
+
+  public endBlock(endBlock: bigint | number) {
+    this.config.endSlot = BigInt(endBlock)
+    return this
+  }
+}