@sentio/sdk 1.37.0-rc.2 → 1.37.0-rc.3

package/src/builtin/solana/wormhole-processor.ts

@@ -1,269 +0,0 @@
-import { SolanaBaseProcessor, SolanaContext, SolanaBindOptions } from '@sentio/sdk'
-import { Instruction } from '@project-serum/anchor'
-import bs58 from 'bs58'
-
-import {
-  deserialize,
-  field,
-  vec, fixedArray, option,
-} from "@dao-xyz/borsh";
-
-// https://github.com/certusone/wormhole/blob/8818d4b8f0471095dd48fa6f5da9c315cbfc9b52/solana/modules/token_bridge/program/src/lib.rs#L100
-enum TokenBridgeInstruction {
-  Initialize = 0,
-  AttestToken,
-  CompleteNative, // no args
-  CompleteWrapped, // no args
-  TransferWrapped,
-  TransferNative,
-  RegisterChain, // no args
-  CreateWrapped, // no args
-  UpgradeContract, // no args
-  CompleteNativeWithPayload, // no args
-  CompleteWrappedWithPayload, // no args
-  TransferWrappedWithPayload,
-  TransferNativeWithPayload,
-}
-
-class TransferDataValues {
-  @field({ type: 'u32' })
-  nonce: number
-
-  @field({type: 'u64'})
-  amount: bigint
-
-  @field({type: 'u64'})
-  fee: bigint
-
-  @field({ type: fixedArray('u8', 32) })
-  target_address: number[];
-
-  @field({ type: 'u16' })
-  target_chain: number
-
-  constructor(data?: TransferDataValues)  {
-    if(data){
-      Object.assign(this,data)
-    }
-  }
-}
-
-class TransferNativeWithPayloadData {
-  @field({ type: 'u32' })
-  nonce: number
-
-  @field({type: 'u64'})
-  amount: bigint
-
-  @field({type: 'u64'})
-  fee: bigint
-
-  @field({ type: fixedArray('u8', 32) })
-  target_address: number[];
-
-  @field({ type: 'u16' })
-  target_chain: number
-
-  @field({ type: vec('u8') })
-  payload: number[];
-
-  @field({type: option(fixedArray('u8', 32) )})
-  cpi_program_id?: number[]
-
-  constructor(data?: TransferNativeWithPayloadData)  {
-    if(data){
-      Object.assign(this,data)
-    }
-  }
-}
-
-class AttestTokenValues {
-  @field({ type: 'u32' })
-  nonce: number
-
-  constructor(data?: AttestTokenValues)  {
-    if(data){
-      Object.assign(this,data)
-    }
-  }
-}
-
-class InitializeDataValues {
-  @field({type: fixedArray('u8', 32) })
-  bridge: number[]
-
-  constructor(data?: InitializeDataValues)  {
-    if(data){
-      Object.assign(this,data)
-    }
-  }
-}
-
-export class TokenBridgeProcessor extends SolanaBaseProcessor {
-
-  // private readonly transferDataValues = [
-  //   borsh.u32('nonce'),
-  //   borsh.u64('amount'),
-  //   borsh.u64('fee'),
-  //   borsh.array(borsh.u8(undefined), 32, 'target_address'),
-  //   borsh.u16('target_chain')
-  // ]
-  // https://github.com/certusone/wormhole/blob/8818d4b8f0471095dd48fa6f5da9c315cbfc9b52/solana/modules/token_bridge/program/src/api/transfer_payload.rs#L170
-  // private readonly transferDataWithPayloadValues = [
-  //   borsh.u32('nonce'),
-  //   borsh.u64('amount'),
-  //   borsh.array(borsh.u8(undefined), 32, 'target_address'),
-  //   borsh.u16('target_chain'),
-  //   borsh.vecU8('payload'),
-  //   borsh.option(borsh.publicKey(undefined), 'cpi_program_id')
-  // ]
-  // private readonly attestTokenValues = [
-  //   borsh.u32('nonce')
-  // ]
-  // private readonly initializeDataValues = [
-  //   borsh.publicKey('bridge')
-  // ]
-
-  static bind(options: SolanaBindOptions): TokenBridgeProcessor {
-    if (options && !options.name) {
-      options.name = 'WormholeTokenBridge'
-    }
-    return new TokenBridgeProcessor(options)
-  }
-
-  decodeInstruction: (rawInstruction: string) => Instruction | null = (ins) => {
-    const u8Arr = bs58.decode(ins)
-    if (u8Arr.length === 0) {
-      return null
-    }
-
-    let data: any
-    // wormhole pass intruction's enum value as its first instrcution data
-    switch (u8Arr[0]) {
-      case TokenBridgeInstruction.Initialize:
-        return {
-          data: '',
-          name: TokenBridgeInstruction[TokenBridgeInstruction.Initialize]
-        }
-      case TokenBridgeInstruction.TransferNative:
-        data = deserialize(Buffer.from(u8Arr.slice(1)), TransferDataValues)
-
-        // struct is defined at: https://github.com/certusone/wormhole/blob/8818d4b8f0471095dd48fa6f5da9c315cbfc9b52/solana/modules/token_bridge/program/src/api/transfer.rs#L295
-        // data = borsh.struct(this.transferDataValues, 'TransferNativeData').decode(Buffer.from(u8Arr.slice(1)))
-        return {
-          data,
-          name: TokenBridgeInstruction[TokenBridgeInstruction.TransferNative]
-        }
-      case TokenBridgeInstruction.TransferWrapped:
-        data = deserialize(Buffer.from(u8Arr.slice(1)), TransferDataValues)
-
-        // stuct is defined at: https://github.com/certusone/wormhole/blob/8818d4b8f0471095dd48fa6f5da9c315cbfc9b52/solana/modules/token_bridge/program/src/api/transfer.rs#L295
-        // data = borsh.struct(this.transferDataValues, 'TransferWrappedData').decode(Buffer.from(u8Arr.slice(1)))
-        return {
-          data,
-          name: TokenBridgeInstruction[TokenBridgeInstruction.TransferWrapped]
-        }
-      case TokenBridgeInstruction.TransferNativeWithPayload:
-        data = deserialize(Buffer.from(u8Arr.slice(1)), TransferNativeWithPayloadData)
-
-        // data = borsh.struct(this.transferDataWithPayloadValues, 'TransferNativeWithPayloadData').decode(Buffer.from(u8Arr.slice(1)))
-        return {
-          data,
-          name: TokenBridgeInstruction[TokenBridgeInstruction.TransferNativeWithPayload]
-        }
-      case TokenBridgeInstruction.TransferWrappedWithPayload:
-        data = deserialize(Buffer.from(u8Arr.slice(1)), TransferNativeWithPayloadData)
-
-        // data = borsh.struct(this.transferDataWithPayloadValues, 'TransferWrappedWithPayloadData').decode(Buffer.from(u8Arr.slice(1)))
-        return {
-          data,
-          name: TokenBridgeInstruction[TokenBridgeInstruction.TransferWrappedWithPayload]
-        }
-      case TokenBridgeInstruction.Initialize:
-        data = deserialize(Buffer.from(u8Arr.slice(1)), InitializeDataValues)
-
-        // data = borsh.struct(this.initializeDataValues, 'InitializeData').decode(Buffer.from(u8Arr.slice(1)))
-        return {
-          data,
-          name: TokenBridgeInstruction[TokenBridgeInstruction.Initialize]
-        }
-      case TokenBridgeInstruction.AttestToken:
-        data = deserialize(Buffer.from(u8Arr.slice(1)), AttestTokenValues)
-
-        // data = borsh.struct(this.attestTokenValues, 'AttestTokenData').decode(Buffer.from(u8Arr.slice(1)))
-        return {
-          data,
-          name: TokenBridgeInstruction[TokenBridgeInstruction.AttestToken]
-        }
-      case TokenBridgeInstruction.CompleteNative:
-      case TokenBridgeInstruction.CompleteNativeWithPayload:
-      case TokenBridgeInstruction.CompleteWrapped:
-      case TokenBridgeInstruction.CompleteWrappedWithPayload:
-      case TokenBridgeInstruction.CreateWrapped:
-      case TokenBridgeInstruction.UpgradeContract:
-      case TokenBridgeInstruction.RegisterChain:
-        return {
-          data: '',
-          name: TokenBridgeInstruction[u8Arr[0]]
-        }
-
-      default:
-        return null
-    }
-  }
-
-  onInitialize(handler: (args: any, accounts: string[], ctx: SolanaContext) => void): TokenBridgeProcessor {
-    this.onInstruction('Initialize', (ins: Instruction, ctx, accounts: string[]) => {
-      if (ins) {
-        handler(ins.data, accounts, ctx)
-      }
-    })
-    return this
-  }
-
-  onAttestToken(handler: (args: any, accounts: string[], ctx: SolanaContext) => void): TokenBridgeProcessor {
-    this.onInstruction('AttestToken', (ins: Instruction, ctx, accounts: string[]) => {
-      if (ins) {
-        handler(ins.data, accounts, ctx)
-      }
-    })
-    return this
-  }
-
-
-  onTransferWrapped(handler: (args: any, accounts: string[], ctx: SolanaContext) => void): TokenBridgeProcessor {
-    this.onInstruction('TransferWrapped', (ins: Instruction, ctx, accounts: string[]) => {
-      if (ins) {
-        handler(ins.data, accounts, ctx)
-      }
-    })
-    return this
-  }
-
-  onTransferNativeWithPayload(handler: (args: any, accounts: string[], ctx: SolanaContext) => void): TokenBridgeProcessor {
-    this.onInstruction('TransferNativeWithPayload', (ins: Instruction, ctx, accounts: string[]) => {
-      if (ins) {
-        handler(ins.data,  accounts, ctx)
-      }
-    })
-    return this
-  }
-
-  onTransferWrappedWithPaylod(handler: (args: any, accounts: string[], ctx: SolanaContext) => void): TokenBridgeProcessor {
-    this.onInstruction('TransferWrappedWithPaylod', (ins: Instruction, ctx, accounts: string[]) => {
-      if (ins) {
-        handler(ins.data, accounts, ctx)
-      }
-    })
-    return this
-  }
-
-  onTransferNative(handler: (args: any, accounts: string[], ctx: SolanaContext) => void): TokenBridgeProcessor {
-    this.onInstruction('TransferNative', (ins: Instruction, ctx, accounts: string[]) => {
-      if (ins) {
-        handler(ins.data, accounts, ctx)
-      }
-    })
-    return this
-  }
-}

package/src/core/solana-context.ts

@@ -1,34 +0,0 @@
-import { BaseContext } from './base-context'
-import { Labels } from './metadata'
-import { RecordMetaData } from '@sentio/sdk'
-import { CHAIN_IDS } from '../utils/chain'
-import { normalizeLabels } from './meter'
-
-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/core/solana-options.ts

@@ -1,8 +0,0 @@
-export class SolanaBindOptions {
-  address: string
-  network?: string
-  name?: string
-  startBlock?: bigint | number
-  endBlock?: bigint | number
-  processInnerInstruction?: boolean
-}

package/src/core/solana-plugin.ts

@@ -1,97 +0,0 @@
-import { Plugin, PluginManager } from '@sentio/base'
-import {
-  ContractConfig,
-  Data_SolInstruction,
-  DataBinding,
-  HandlerType,
-  ProcessConfigResponse,
-  ProcessResult,
-} from '@sentio/protos'
-import { DEFAULT_MAX_BLOCK, mergeProcessResults, USER_PROCESSOR } from '../service'
-
-import { ServerError, Status } from 'nice-grpc'
-
-import { SolanaProcessorState } from './solana-processor'
-import { Instruction as SolInstruction } from '@project-serum/anchor/dist/cjs/coder/borsh/instruction'
-
-export class SolanaPlugin implements Plugin {
-  name: string = 'SolanaPlugin'
-
-  configure(config: ProcessConfigResponse): void {
-    // Part 2, prepare solana constractors
-    for (const solanaProcessor of SolanaProcessorState.INSTANCE.getValues()) {
-      const contractConfig: ContractConfig = {
-        processorType: USER_PROCESSOR,
-        contract: {
-          name: solanaProcessor.contractName,
-          chainId: solanaProcessor.network,
-          address: solanaProcessor.address,
-          abi: '',
-        },
-        logConfigs: [],
-        traceConfigs: [],
-        intervalConfigs: [],
-        startBlock: solanaProcessor.config.startSlot,
-        endBlock: DEFAULT_MAX_BLOCK,
-        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')
-    }
-
-    const instruction = request.data.solInstruction || Data_SolInstruction.decode(request.data.raw) // JSON.parse(jsonString)
-    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
-        if (instruction.parsed) {
-          parsedInstruction = processor.getParsedInstruction(instruction.parsed as { type: string; info: any })
-        } else if (instruction.instructionData) {
-          parsedInstruction = processor.getParsedInstruction(instruction.instructionData)
-        }
-        if (parsedInstruction == null) {
-          continue
-        }
-        const insHandler = processor.getInstructionHandler(parsedInstruction)
-        if (insHandler == null) {
-          continue
-        }
-        const res = await processor.handleInstruction(
-          parsedInstruction,
-          instruction.accounts,
-          insHandler,
-          instruction.slot
-        )
-
-        promises.push(Promise.resolve(res))
-      }
-    }
-    return mergeProcessResults(await Promise.all(promises))
-  }
-}
-
-PluginManager.INSTANCE.register(new SolanaPlugin())

package/src/core/solana-processor.ts

@@ -1,102 +0,0 @@
-import { ProcessResult } from '@sentio/protos'
-import { SolanaContext } from './solana-context'
-import { Instruction } from '@project-serum/anchor'
-import { SolanaBindOptions } from './solana-options'
-import { ListStateStorage } from '@sentio/base'
-import { CHAIN_IDS } from '../utils/chain'
-
-type IndexConfigure = {
-  startSlot: bigint
-  endSlot?: bigint
-}
-
-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 }
-  decodeInstruction: (rawInstruction: string) => Instruction | null
-  fromParsedInstruction: (instruction: { type: string; info: any }) => Instruction | null
-
-  constructor(options: SolanaBindOptions) {
-    if (options) {
-      this.bind(options)
-    }
-    SolanaProcessorState.INSTANCE.addValue(this)
-  }
-
-  bind(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.startBlock) {
-      this.startSlot(options.startBlock)
-    }
-    if (options.endBlock) {
-      this.endBlock(options.endBlock)
-    }
-    this.endpoint = options.network || 'https://api.mainnet-beta.solana.com'
-  }
-
-  public onInstruction(instructionName: string, handler: SolanaInstructionHandler) {
-    if (!this.isBind()) {
-      throw new Error("Processor doesn't bind to an address")
-    }
-
-    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)
-  }
-
-  // TODO this should be a async function
-  public handleInstruction(
-    parsedInstruction: Instruction,
-    accounts: string[],
-    handler: SolanaInstructionHandler,
-    slot: bigint
-  ): ProcessResult {
-    const ctx = new SolanaContext(this.contractName, this.network, this.address, slot)
-    handler(parsedInstruction, ctx, accounts)
-    return ctx.getProcessResult()
-  }
-
-  public isBind() {
-    return this.address !== null
-  }
-
-  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-codegen/codegen.ts

@@ -1,129 +0,0 @@
-import path from 'path'
-import fs from 'fs'
-import chalk from 'chalk'
-
-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: any): 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"
-import { ${idlName}_idl } from "./${idlName}"
-import bs58 from 'bs58'
-import { PublicKey } from '@solana/web3.js'
-
-export class ${idlNamePascalCase}Processor extends SolanaBaseProcessor {
-  static bind(options: SolanaBindOptions): ${idlNamePascalCase}Processor {
-    if (options && !options.name) {
-      options.name = '${idlNamePascalCase}'
-    }
-    return new ${idlNamePascalCase}Processor(options)
-  }
-
-  decodeInstruction: (rawInstruction: string) => Instruction | null = (rawInstruction) => {
-    const instructionCoder = new BorshInstructionCoder(${idlName}_idl as Idl)
-    const decodedIns = instructionCoder.decode(Buffer.from(bs58.decode(rawInstruction)))
-    return decodedIns
-  }
-
-  ${instructions.map((ins) => codeGenSolanaInstruction(idlNamePascalCase, ins)).join('')}
-}
-  `
-}
-
-function codeGenSolanaInstruction(idlName: string, ins: any): string {
-  const instructionName = ins.name
-  return `
-  on${instructionName.charAt(0).toUpperCase() + instructionName.slice(1)}(handler: (args: ${codeGenInstructionArgsType(
-    ins.args
-  )}, accounts: string[], ctx: SolanaContext) => void): ${idlName}Processor {
-    this.onInstruction('${instructionName}', (ins: Instruction, ctx, accounts: string[]) => {
-      const origin = ins.data as any
-      const data = ${codeGenInstructionArgs(ins.args)}
-      if (ins) {
-        handler(data, accounts, ctx)
-      }
-    })
-    return this
-  }
-  `
-}
-
-function codeGenInstructionArgs(args: { name: string; type: string }[]): string {
-  return `{ ${args.map((arg) => codeGenInstructionArg(arg.name, arg.type)).join(', ')} }`
-}
-
-function codeGenInstructionArg(name: string, type: string): string {
-  const mType = mapType(type)
-  if (mType === 'bigint') {
-    return `${name}: BigInt(origin.${name}.toString())`
-  }
-  return `${name}: origin.${name} as ${mType}`
-}
-
-function codeGenInstructionArgsType(args: { name: string; type: string }[]): string {
-  return `{ ${args.map((arg) => arg.name + ': ' + mapType(arg.type)).join(', ')} }`
-}
-
-// Reference: https://github.com/coral-xyz/anchor/blob/93332766f13e86efbe77c9986722731742317ede/ts/src/program/namespace/types.ts#L104
-function mapType(tpe: string): string {
-  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/test-abi-code-gen.ts

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