@sentio/sdk 2.0.0-rc.2 → 2.0.0-rc.20

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/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 { codegen } from './codegen/codegen.js'
+
+if (process.argv.length > 3) {
+  const abisDir = process.argv[2]
+  const targetDir = process.argv[3]
+  codegen(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"
+}