@sentio/sdk 3.8.0-rc.3 → 3.9.0-rc.11

package/src/solana/codegen/codegen.ts

@@ -1,23 +1,23 @@
 import path from 'path'
 import fs from 'fs'
 import chalk from 'chalk'
-import { Idl } from '@coral-xyz/anchor'
 import {
+  Idl,
+  IdlDefinedFields,
   IdlField,
   IdlInstruction,
-  IdlType,
   IdlInstructionAccountItem,
-  IdlDefinedFields,
+  IdlType,
   IdlTypeDef
-} from '@coral-xyz/anchor/dist/esm/idl.js'
+} from '@anchor-lang/core'
 import { recursiveCodegen } from '../../core/codegen.js'
 
-export function codegen(abisDir: string, targetPath = path.join('src', 'types', 'solana'), genExample = false) {
+export async function codegen(abisDir: string, targetPath = path.join('src', 'types', 'solana'), genExample = false) {
   if (!fs.existsSync(abisDir)) {
     return
   }
 
-  const numFiles = recursiveCodegen(abisDir, targetPath, codegenInternal)
+  const numFiles = await recursiveCodegen(abisDir, targetPath, codegenInternal)
 
   console.log(chalk.green(`Generated ${numFiles} for Solana`))
 }
@@ -49,7 +49,7 @@ function codeGenSolanaIdlProcessor(idlObj: Idl): string {
   return `import { BorshInstructionCoder, Instruction, Idl } from '@sentio/sdk/solana'
 import { SolanaBaseProcessor, SolanaContext, SolanaBindOptions } from "@sentio/sdk/solana"
 import { ${idlName}_idl } from "./${idlName}.js"
-import { PublicKey } from '@solana/web3.js'
+import type { Address } from '@solana/kit'
 
 ${idlObj.types?.map((def) => codeGenType(def)).join('')}
 
@@ -180,7 +180,7 @@ function mapType(tpe: IdlType): string {
   }
   switch (tpe) {
     case 'pubkey':
-      return 'PublicKey'
+      return 'Address'
     case 'bool':
       return 'boolean'
     case 'string':

package/src/solana/index.ts

@@ -3,4 +3,4 @@ export * from './solana-context.js'
 export * from './solana-processor.js'
 export * from './solana-options.js'
 
-export { BorshInstructionCoder, type Instruction, type Idl } from '@coral-xyz/anchor'
+export { BorshInstructionCoder, type Instruction, type Idl } from '@anchor-lang/core'

package/src/solana/solana-context.ts

@@ -1,6 +1,6 @@
 import { normalizeLabels, Labels, BaseContext, RecordMetaData } from '../index.js'
 import { SolanaChainId } from '@sentio/chain'
-import { TransactionResponse } from '@solana/web3.js'
+import type { TransactionResponse } from './solana-rpc-types.js'
 
 export class SolanaContext extends BaseContext {
   network: SolanaChainId

package/src/solana/solana-plugin.ts

@@ -12,7 +12,7 @@ import {
 import { ServerError, Status } from 'nice-grpc'
 
 import { SolanaProcessorState } from './solana-processor.js'
-import { Instruction as SolInstruction } from '@coral-xyz/anchor'
+import { Instruction as SolInstruction } from '@anchor-lang/core'
 
 export class SolanaPlugin extends Plugin {
   name: string = 'SolanaPlugin'

package/src/solana/solana-processor.ts

@@ -1,13 +1,13 @@
 import { Data_SolBlock, Data_SolInstruction, HandleInterval, ProcessResult } from '@sentio/protos'
 import { SolanaContext } from './solana-context.js'
-import { Instruction } from '@coral-xyz/anchor'
+import { Instruction } from '@anchor-lang/core'
 import { SolanaBindOptions, SolanaFetchConfig } from './solana-options.js'
 import { ListStateStorage } from '@sentio/runtime'
 import { ALL_ADDRESS, Labels, PromiseOrVoid } from '../core/index.js'
 import { SolanaChainId } from '@sentio/chain'
 import { HandlerOptions } from '../core/handler-options.js'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
-import { TransactionResponse, BlockResponse } from '@solana/web3.js'
+import type { TransactionResponse, BlockResponse } from './solana-rpc-types.js'
 
 type IndexConfigure = {
   startSlot: bigint
@@ -18,7 +18,11 @@ export interface InstructionCoder {
   decode(ix: Buffer | string, encoding?: 'hex' | 'base58'): Instruction | null
 }
 
-export type SolanaInstructionHandler = (instruction: Instruction, ctx: SolanaContext, accounts?: string[]) => void
+export type SolanaInstructionHandler<T extends Instruction = Instruction> = (
+  instruction: T,
+  ctx: SolanaContext,
+  accounts: string[]
+) => void
 
 export interface InstructionHandlerEntry {
   handler: SolanaInstructionHandler
@@ -79,12 +83,12 @@ export class SolanaBaseProcessor {
     SolanaProcessorState.INSTANCE.addValue(this)
   }
 
-  public onInstruction(
+  public onInstruction<T extends Instruction = Instruction>(
     instructionName: string,
-    handler: SolanaInstructionHandler,
-    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+    handler: SolanaInstructionHandler<T>,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, T>
   ) {
-    this.instructionHandlerMap.set(instructionName, { handler, handlerOptions })
+    this.instructionHandlerMap.set(instructionName, { handler, handlerOptions } as InstructionHandlerEntry)
     return this
   }
 

package/src/solana/solana-rpc-types.ts

@@ -0,0 +1,73 @@
+import type { Address, Signature, Blockhash } from '@solana/kit'
+
+export type TransactionVersion = 'legacy' | number
+
+export interface TransactionMessageHeader {
+  numRequiredSignatures: number
+  numReadonlySignedAccounts: number
+  numReadonlyUnsignedAccounts: number
+}
+
+export interface CompiledInstruction {
+  programIdIndex: number
+  accounts: number[]
+  data: string
+}
+
+export interface TransactionMessage {
+  accountKeys: Address[]
+  header: TransactionMessageHeader
+  instructions: CompiledInstruction[]
+  recentBlockhash: Blockhash
+}
+
+export interface TokenBalance {
+  accountIndex: number
+  mint: string
+  owner?: string
+  programId?: string
+  uiTokenAmount: {
+    amount: string
+    decimals: number
+    uiAmount: number | null
+    uiAmountString: string
+  }
+}
+
+export interface ConfirmedTransactionMeta {
+  err: unknown
+  fee: number
+  innerInstructions?: Array<{ index: number; instructions: CompiledInstruction[] }> | null
+  logMessages?: string[] | null
+  preBalances: number[]
+  postBalances: number[]
+  preTokenBalances?: TokenBalance[] | null
+  postTokenBalances?: TokenBalance[] | null
+  rewards?: unknown[] | null
+  loadedAddresses?: { writable: Address[]; readonly: Address[] }
+}
+
+export interface TransactionResponse {
+  slot: number
+  blockTime?: number | null
+  transaction: {
+    message: TransactionMessage
+    signatures: Signature[]
+  }
+  meta: ConfirmedTransactionMeta | null
+  version?: TransactionVersion
+}
+
+export interface BlockResponse {
+  blockhash: Blockhash
+  previousBlockhash: Blockhash
+  parentSlot: number
+  blockHeight?: number | null
+  blockTime?: number | null
+  transactions: Array<{
+    transaction: { message: TransactionMessage; signatures: Signature[] }
+    meta: ConfirmedTransactionMeta | null
+    version?: TransactionVersion
+  }>
+  rewards?: unknown[]
+}

package/src/store/codegen.ts

@@ -210,7 +210,7 @@ async function codegenInternal(schema: GraphQLSchema, source: string, target: st
               })
               fields.push({
                 name: f.name + 'ID' + (isMany ? 's' : ''),
-                type: isMany ? `Array<ID | undefined>` : `ID`,
+                type: isMany ? `Array<ID>` : `ID`,
                 annotations: []
               })
               if (isMany) {
@@ -317,7 +317,7 @@ export class ${c.name} ${c.parent ? `extends ${c.parent}` : ''} ${c.interfaces.l
 ${c.fields
   .map((f) => `${f.annotations.map((a) => `\n\t${a}`).join('')}\n\t${f.name}${f.optional ? '?' : ''}: ${f.type}`)
   .join('\n')}
-  ${isEntity ? `constructor(data: ${c.name}ConstructorInput) {super()}` : ''}
+  ${isEntity ? `constructor(data: Partial<${c.name}ConstructorInput>) {super()}` : ''}
   ${(c.methods ?? []).map(genMethod).join('\n')}
   
   ${

package/src/store/decorators.ts

@@ -25,7 +25,9 @@ function handleError(entity: string, key: string, fn: () => any) {
   try {
     return fn()
   } catch (e) {
-    throw new Error(`Get property "${key}" from Entity "${entity}" failed: ${e.message}`)
+    throw new Error(
+      `Get property "${key}" from Entity "${entity}" failed: ${e instanceof Error ? e.message : String(e)}`
+    )
   }
 }
 

package/src/store/store.ts

@@ -96,7 +96,7 @@ export class Store {
       entity: [] as string[],
       id: [] as string[]
     }
-    const entityName = getEntityName(entity)
+    const entityName = getEntityName(entity as EntityClass<T> | T)
     if (id) {
       if (Array.isArray(id)) {
         for (const i of id) {