@sentio/sdk 2.0.0-rc.13 → 2.0.0-rc.15

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
+  }
+}

package/src/solana/tests/abis/basic_1.json

@@ -0,0 +1,62 @@
+{
+  "accounts": [
+    {
+      "name": "MyAccount",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "data",
+            "type": "u64"
+          }
+        ]
+      }
+    }
+  ],
+  "instructions": [
+    {
+      "name": "initialize",
+      "accounts": [
+        {
+          "name": "myAccount",
+          "isMut": true,
+          "isSigner": true
+        },
+        {
+          "name": "user",
+          "isMut": true,
+          "isSigner": true
+        },
+        {
+          "name": "systemProgram",
+          "isMut": false,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "data",
+          "type": "u64"
+        }
+      ]
+    },
+    {
+      "name": "update",
+      "accounts": [
+        {
+          "name": "myAccount",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "data",
+          "type": "u64"
+        }
+      ]
+    }
+  ],
+  "name": "basic_1",
+  "version": "0.1.0"
+}