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

package/src/aptos/types.ts

@@ -0,0 +1,149 @@
+import { SPLITTER, VECTOR_STR } from './utils.js'
+
+export class TypeDescriptor {
+  // type: string
+
+  // qualified name without type parameters
+  qname: string
+  // account?: string
+  // module?: string
+
+  typeArgs: TypeDescriptor[]
+
+  constructor(symbol: string, typeParams?: TypeDescriptor[]) {
+    this.qname = symbol
+    this.typeArgs = typeParams || []
+  }
+
+  getSignature(): string {
+    if (this.typeArgs.length > 0) {
+      return this.qname + '<' + this.typeArgs.map((t) => t.getSignature()).join(', ') + '>'
+    }
+    return this.qname
+  }
+
+  // Replace T0, T1 with more concrete type
+  applyTypeArgs(ctx: Map<string, TypeDescriptor>): TypeDescriptor {
+    const replace = ctx.get(this.qname)
+    if (replace) {
+      return replace
+    }
+    if (ctx.size === 0 || this.typeArgs.length === 0) {
+      return this
+    }
+
+    const typeArgs: TypeDescriptor[] = []
+    for (const arg of this.typeArgs) {
+      const replace = ctx.get(arg.qname)
+      if (replace) {
+        typeArgs.push(replace)
+      } else {
+        typeArgs.push(arg.applyTypeArgs(ctx))
+      }
+    }
+    return new TypeDescriptor(this.qname, typeArgs)
+  }
+
+  // all depended types including itself, not include system type
+  dependedTypes(): string[] {
+    if (this.qname.startsWith('&')) {
+      return []
+    }
+    switch (this.qname) {
+      case 'signer':
+      case 'address':
+      case '0x1::string::String':
+      case 'bool':
+      case 'u8':
+      case 'u16':
+      case 'u32':
+      case 'u64':
+      case 'u128':
+        return []
+    }
+
+    // Type parameters are not depended
+    if (this.qname.indexOf(SPLITTER) == -1) {
+      if (this.qname.startsWith('T')) {
+        return []
+      }
+    }
+
+    const types = new Set<string>()
+    for (const param of this.typeArgs) {
+      param.dependedTypes().forEach((t) => types.add(t))
+    }
+
+    if (this.qname !== VECTOR_STR) {
+      types.add(this.qname)
+    }
+
+    return Array.from(types)
+  }
+}
+
+export function parseMoveType(type: string): TypeDescriptor {
+  // type = type.replace('&', '')
+
+  type = type.replaceAll('&mut ', '&')
+  type = type.replaceAll('mut ', '')
+
+  // TODO replace ' ' is not exactly safe, need to double check this
+  type = type.replaceAll(' ', '')
+
+  const stack: TypeDescriptor[] = [new TypeDescriptor('')]
+  let buffer = []
+
+  // xxx:asdf<g1<a,<c,d>>, b, g2<a,b>, e>
+  for (let i = 0; i < type.length; i++) {
+    const ch = type[i]
+    if (ch === '<') {
+      // const symbol = type.slice(symbolStart, i)
+      // symbolStart =
+      const symbol = buffer.join('')
+      buffer = []
+      stack[stack.length - 1].qname = symbol
+      stack.push(new TypeDescriptor(''))
+      continue
+    }
+    if (ch === '>') {
+      const typeParam = stack.pop()
+      if (!typeParam) {
+        throw Error('Uxpectecd stack size')
+      }
+      if (buffer.length > 0) {
+        typeParam.qname = buffer.join('')
+        buffer = []
+      }
+      stack[stack.length - 1].typeArgs.push(typeParam)
+      continue
+    }
+    if (ch === ',') {
+      const typeParam = stack.pop()
+      if (!typeParam) {
+        throw Error('Uxpectecd stack size')
+      }
+      if (buffer.length > 0) {
+        typeParam.qname = buffer.join('')
+        buffer = []
+      }
+
+      stack[stack.length - 1].typeArgs.push(typeParam)
+      // continue parse next param
+      stack.push(new TypeDescriptor(''))
+      continue
+    }
+
+    buffer.push(ch)
+  }
+
+  if (buffer.length > 0) {
+    stack[stack.length - 1].qname = buffer.join('')
+  }
+
+  const res = stack.pop()
+  if (!res || stack.length > 0) {
+    throw Error('Uxpectecd stack size')
+  }
+  return res
+}

package/src/aptos/utils.ts

@@ -0,0 +1,26 @@
+import { MoveFunction, MoveModule } from './move-types.js'
+
+export const SPLITTER = '::'
+
+export const VECTOR_STR = 'vector'
+
+export function isFrameworkAccount(account: string) {
+  return account === '0x1' || account === '0x2' || account === '0x3'
+}
+
+export function moduleQname(module: MoveModule): string {
+  return module.address.toLowerCase() + SPLITTER + module.name
+}
+
+export function moduleQnameForType(type: string): [string, string] {
+  const parts = type.split(SPLITTER).slice(0, 2)
+  return [parts[0], parts[1]]
+}
+
+export function getMeaningfulFunctionParams(func: MoveFunction): string[] {
+  let params = func.params
+  if (func.params[0] === '&signer') {
+    params = params.slice(1)
+  }
+  return params
+}

package/src/core/context.ts

@@ -4,7 +4,7 @@ import { LogParams } from 'ethers/providers'
 import { RecordMetaData } from '@sentio/protos'
 import { Trace } from '../eth/trace.js'
 import { Labels, normalizeLabels } from './metadata.js'
-import { CHAIN_IDS } from '../utils/chain.js'
+import { CHAIN_IDS } from '../chain.js'
 import { BaseContext } from './base-context.js'
 
 export abstract class EthContext extends BaseContext {

package/src/core/sui-plugin.ts

@@ -3,7 +3,7 @@ import { ContractConfig, DataBinding, HandlerType, ProcessConfigResponse, Proces
 
 import { ServerError, Status } from 'nice-grpc'
 
-import { CHAIN_IDS } from '../utils/chain.js'
+import { CHAIN_IDS } from '../chain.js'
 import { SuiProcessorState } from './sui-processor.js'
 
 export class SuiPlugin extends Plugin {

package/src/index.ts

@@ -6,5 +6,5 @@ export * from '@sentio/protos'
 export * from './core/index.js'
 export * from './eth/index.js'
 
-export * from './utils/chain.js'
+export * from './chain.js'
 // export * from  './api'

package/src/solana/builtin/index.ts

@@ -0,0 +1 @@
+export * from './spl-token-processor.js'

package/src/solana/builtin/spl-token-processor.ts

@@ -0,0 +1,298 @@
+import { SolanaBaseProcessor, SolanaContext, SolanaBindOptions } from '@sentio/sdk/solana'
+import { Instruction } from '@project-serum/anchor'
+import { AmountToUiAmount, Approve, ApproveChecked, Burn, BurnChecked, CloseAccount, CreateNativeMint, DefaultAccountStateExtension, FreezeAccount, GetAccountDataSize, InitializeAccount, InitializeAccount2, InitializeAccount3, InitializeImmutableOwner, InitializeMint, InitializeMintCloseAuthority, InitializeMultisig, MemoTransferExtension, MintTo, MintToChecked, Reallocate, Revoke, SyncNative, ThawAccount, Transfer, TransferChecked, TransferFeeExtension, UiAmountToAmount } from './types.js';
+
+export class SPLTokenProcessor extends SolanaBaseProcessor {
+  static bind(options: SolanaBindOptions): SPLTokenProcessor {
+    if (options && !options.name) {
+      options.name = 'SPL Token Program'
+    }
+    return new SPLTokenProcessor(options)
+  }
+
+  fromParsedInstruction: (instruction: { type: string, info: any }) => Instruction | null = (instruction: { type: string, info: any }) => {
+    const instructionType = instruction.type
+    if (!instructionType) {
+      return null
+    }
+    return {
+      name: instruction.type,
+      data: {
+        ...instruction.info,
+      },
+    }
+  }
+
+  public onInitializeMint(
+    handler: (data: InitializeMint, ctx: SolanaContext) => void
+  ): SPLTokenProcessor {
+    this.onInstruction('initializeMint', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as InitializeMint, ctx)
+      }
+    })
+    return this
+  }
+
+  public onInitializeAccount(
+    hanlder: (data: InitializeAccount, ctx: SolanaContext) => void
+  ): SPLTokenProcessor {
+    this.onInstruction('initializeAccount', (ins: Instruction, ctx) => {
+      if (ins) {
+        hanlder(ins.data as InitializeAccount, ctx)
+      }
+    })
+    return this
+  }
+
+  public onInitializeAccount2(
+    hanlder: (data: InitializeAccount2, ctx: SolanaContext) => void
+  ): SPLTokenProcessor {
+    this.onInstruction('initializeAccount2', (ins: Instruction, ctx) => {
+      if (ins) {
+        hanlder(ins.data as InitializeAccount2, ctx)
+      }
+    })
+    return this
+  }
+
+  public onInitializeAccount3(
+    hanlder: (data: InitializeAccount3, ctx: SolanaContext) => void
+  ): SPLTokenProcessor {
+    this.onInstruction('initializeAccount3', (ins: Instruction, ctx) => {
+      if (ins) {
+        hanlder(ins.data as InitializeAccount3, ctx)
+      }
+    })
+    return this
+  }
+
+  public onInitializeMultisig(
+    handler: (data: InitializeMultisig, ctx: SolanaContext) => void
+  ): SPLTokenProcessor {
+    this.onInstruction('initializeMultisig', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as InitializeMultisig, ctx)
+      }
+    })
+    return this
+  }
+
+  public onTransfer(handler: (data: Transfer, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('transfer', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as Transfer, ctx)
+      }
+    })
+    return this
+  }
+
+  public onApprovend(handler: (data: Approve, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('approve', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as Approve, ctx)
+      }
+    })
+    return this
+  }
+
+  public onRevoke(handler: (data: Revoke, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('revoke', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as Revoke, ctx)
+      }
+    })
+    return this
+  }
+
+  public onSetAuthority(handler: (data: any, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('setAuthority', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as any, ctx)
+      }
+    })
+    return this
+  }
+
+  public onMintTo(handler: (data: MintTo, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('mintTo', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as MintTo, ctx)
+      }
+    })
+    return this
+  }
+
+  public onBurn(handler: (data: Burn, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('burn', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as Burn, ctx)
+      }
+    })
+    return this
+  }
+
+  public onCloseAccount(handler: (data: CloseAccount, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('closeAccount', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as CloseAccount, ctx)
+      }
+    })
+    return this
+  }
+
+  public onFreezeAccount(handler: (data: FreezeAccount, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('freezeAccount', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as FreezeAccount, ctx)
+      }
+    })
+    return this
+  }
+
+  public onThawAccount(handler: (data: ThawAccount, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('thawAccount', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as ThawAccount, ctx)
+      }
+    })
+    return this
+  }
+
+  public onTransferChecked(handler: (data: TransferChecked, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('transferChecked', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as TransferChecked, ctx)
+      }
+    })
+    return this
+  }
+
+  public onApproveChecked(handler: (data: ApproveChecked, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('approveChecked', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as ApproveChecked, ctx)
+      }
+    })
+    return this
+  }
+
+  public onMintToChecked(handler: (data: MintToChecked, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('mintToChecked', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as MintToChecked, ctx)
+      }
+    })
+    return this
+  }
+
+  public onBurnChecked(handler: (data: BurnChecked, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('burnChecked', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as BurnChecked, ctx)
+      }
+    })
+    return this
+  }
+
+  public onSyncNative(handler: (data: SyncNative, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('syncNative', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as SyncNative, ctx)
+      }
+    })
+    return this
+  }
+
+  public onGetAccountDataSize(handler: (data: GetAccountDataSize, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('getAccountDataSize', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as GetAccountDataSize, ctx)
+      }
+    })
+    return this
+  }
+
+  public onInitializeImmutableOwner(handler: (data: InitializeImmutableOwner, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('initializeImmutableOwner', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as InitializeImmutableOwner, ctx)
+      }
+    })
+    return this
+  }
+
+  public onAmountToUiAmount(handler: (data: AmountToUiAmount, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('amountToUiAmount', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as AmountToUiAmount, ctx)
+      }
+    })
+    return this
+  }
+
+  public onUiAmountToAmount(handler: (data: UiAmountToAmount, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('uiAmountToAmount', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as UiAmountToAmount, ctx)
+      }
+    })
+    return this
+  }
+
+  public onInitializeMintCloseAuthority(handler: (data: InitializeMintCloseAuthority, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('initializeMintCloseAuthority', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as InitializeMintCloseAuthority, ctx)
+      }
+    })
+    return this
+  }
+
+  public onTransferFeeExtension(handler: (data: TransferFeeExtension, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('transferFeeExtension', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as TransferFeeExtension, ctx)
+      }
+    })
+    return this
+  }
+
+  public onDefaultAccountStateExtension(handler: (data: DefaultAccountStateExtension, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('defaultAccountStateExtension', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as DefaultAccountStateExtension, ctx)
+      }
+    })
+    return this
+  }
+
+  public onReallocate(handler: (data: Reallocate, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('reallocate', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as Reallocate, ctx)
+      }
+    })
+    return this
+  }
+
+  public onMemoTransferExtension(handler: (data: MemoTransferExtension, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('memoTransferExtension', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as MemoTransferExtension, ctx)
+      }
+    })
+    return this
+  }
+
+  public onCreateNativeMint(handler: (data: CreateNativeMint, ctx: SolanaContext) => void): SPLTokenProcessor {
+    this.onInstruction('createNativeMint', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as CreateNativeMint, ctx)
+      }
+    })
+    return this
+  }
+
+  // Todo(pcxu): auto gen this file
+}