@sentio/sdk 3.2.0 → 3.3.0-rc.2

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

@@ -1,6 +1,7 @@
-import { SolanaBaseProcessor, SolanaContext, SolanaBindOptions } from "../index.js"
+import { SolanaBaseProcessor, SolanaContext, SolanaBindOptions, SolanaFetchConfig } from "../index.js"
 import { Instruction } from '@coral-xyz/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';
+import { HandlerOptions } from '../../core/handler-options.js'
 
 export class SPLTokenProcessor extends SolanaBaseProcessor {
   static bind(options: SolanaBindOptions): SPLTokenProcessor {
@@ -24,273 +25,350 @@ export class SPLTokenProcessor extends SolanaBaseProcessor {
   }
 
   public onInitializeMint(
-    handler: (data: InitializeMint, ctx: SolanaContext) => void
+    handler: (data: InitializeMint, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
   ): SPLTokenProcessor {
     this.onInstruction('initializeMint', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as InitializeMint, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
   public onInitializeAccount(
-    hanlder: (data: InitializeAccount, ctx: SolanaContext) => void
+    handler: (data: InitializeAccount, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
   ): SPLTokenProcessor {
     this.onInstruction('initializeAccount', (ins: Instruction, ctx) => {
       if (ins) {
-        hanlder(ins.data as InitializeAccount, ctx)
+        handler(ins.data as InitializeAccount, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
   public onInitializeAccount2(
-    hanlder: (data: InitializeAccount2, ctx: SolanaContext) => void
+    handler: (data: InitializeAccount2, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
   ): SPLTokenProcessor {
     this.onInstruction('initializeAccount2', (ins: Instruction, ctx) => {
       if (ins) {
-        hanlder(ins.data as InitializeAccount2, ctx)
+        handler(ins.data as InitializeAccount2, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
   public onInitializeAccount3(
-    hanlder: (data: InitializeAccount3, ctx: SolanaContext) => void
+    handler: (data: InitializeAccount3, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
   ): SPLTokenProcessor {
     this.onInstruction('initializeAccount3', (ins: Instruction, ctx) => {
       if (ins) {
-        hanlder(ins.data as InitializeAccount3, ctx)
+        handler(ins.data as InitializeAccount3, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
   public onInitializeMultisig(
-    handler: (data: InitializeMultisig, ctx: SolanaContext) => void
+    handler: (data: InitializeMultisig, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
   ): SPLTokenProcessor {
     this.onInstruction('initializeMultisig', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as InitializeMultisig, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onTransfer(handler: (data: Transfer, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onTransfer(
+    handler: (data: Transfer, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('transfer', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as Transfer, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onApprovend(handler: (data: Approve, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onApprove(
+    handler: (data: Approve, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('approve', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as Approve, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onRevoke(handler: (data: Revoke, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onRevoke(
+    handler: (data: Revoke, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('revoke', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as Revoke, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onSetAuthority(handler: (data: any, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onSetAuthority(
+    handler: (data: any, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('setAuthority', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as any, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onMintTo(handler: (data: MintTo, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onMintTo(
+    handler: (data: MintTo, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('mintTo', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as MintTo, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onBurn(handler: (data: Burn, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onBurn(
+    handler: (data: Burn, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('burn', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as Burn, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onCloseAccount(handler: (data: CloseAccount, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onCloseAccount(
+    handler: (data: CloseAccount, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('closeAccount', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as CloseAccount, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onFreezeAccount(handler: (data: FreezeAccount, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onFreezeAccount(
+    handler: (data: FreezeAccount, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('freezeAccount', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as FreezeAccount, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onThawAccount(handler: (data: ThawAccount, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onThawAccount(
+    handler: (data: ThawAccount, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('thawAccount', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as ThawAccount, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onTransferChecked(handler: (data: TransferChecked, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onTransferChecked(
+    handler: (data: TransferChecked, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('transferChecked', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as TransferChecked, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onApproveChecked(handler: (data: ApproveChecked, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onApproveChecked(
+    handler: (data: ApproveChecked, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('approveChecked', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as ApproveChecked, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onMintToChecked(handler: (data: MintToChecked, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onMintToChecked(
+    handler: (data: MintToChecked, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('mintToChecked', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as MintToChecked, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onBurnChecked(handler: (data: BurnChecked, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onBurnChecked(
+    handler: (data: BurnChecked, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('burnChecked', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as BurnChecked, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onSyncNative(handler: (data: SyncNative, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onSyncNative(
+    handler: (data: SyncNative, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('syncNative', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as SyncNative, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onGetAccountDataSize(handler: (data: GetAccountDataSize, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onGetAccountDataSize(
+    handler: (data: GetAccountDataSize, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('getAccountDataSize', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as GetAccountDataSize, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onInitializeImmutableOwner(handler: (data: InitializeImmutableOwner, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onInitializeImmutableOwner(
+    handler: (data: InitializeImmutableOwner, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('initializeImmutableOwner', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as InitializeImmutableOwner, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onAmountToUiAmount(handler: (data: AmountToUiAmount, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onAmountToUiAmount(
+    handler: (data: AmountToUiAmount, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('amountToUiAmount', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as AmountToUiAmount, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onUiAmountToAmount(handler: (data: UiAmountToAmount, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onUiAmountToAmount(
+    handler: (data: UiAmountToAmount, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('uiAmountToAmount', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as UiAmountToAmount, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onInitializeMintCloseAuthority(handler: (data: InitializeMintCloseAuthority, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onInitializeMintCloseAuthority(
+    handler: (data: InitializeMintCloseAuthority, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('initializeMintCloseAuthority', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as InitializeMintCloseAuthority, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onTransferFeeExtension(handler: (data: TransferFeeExtension, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onTransferFeeExtension(
+    handler: (data: TransferFeeExtension, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('transferFeeExtension', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as TransferFeeExtension, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onDefaultAccountStateExtension(handler: (data: DefaultAccountStateExtension, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onDefaultAccountStateExtension(
+    handler: (data: DefaultAccountStateExtension, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('defaultAccountStateExtension', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as DefaultAccountStateExtension, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onReallocate(handler: (data: Reallocate, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onReallocate(
+    handler: (data: Reallocate, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('reallocate', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as Reallocate, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onMemoTransferExtension(handler: (data: MemoTransferExtension, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onMemoTransferExtension(
+    handler: (data: MemoTransferExtension, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('memoTransferExtension', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as MemoTransferExtension, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 
-  public onCreateNativeMint(handler: (data: CreateNativeMint, ctx: SolanaContext) => void): SPLTokenProcessor {
+  public onCreateNativeMint(
+    handler: (data: CreateNativeMint, ctx: SolanaContext) => void,
+    handlerOptions?: HandlerOptions<SolanaFetchConfig, Instruction>
+  ): SPLTokenProcessor {
     this.onInstruction('createNativeMint', (ins: Instruction, ctx) => {
       if (ins) {
         handler(ins.data as CreateNativeMint, ctx)
       }
-    })
+    }, handlerOptions)
     return this
   }
 

package/src/solana/solana-context.ts

@@ -1,24 +1,28 @@
 import { normalizeLabels, Labels, BaseContext, RecordMetaData } from '../index.js'
 import { SolanaChainId } from '@sentio/chain'
+import { TransactionResponse } from '@solana/web3.js'
 
 export class SolanaContext extends BaseContext {
   network: SolanaChainId
   address: string
   programName: string
   blockNumber: bigint
+  transaction?: TransactionResponse
 
   constructor(
     programName: string,
     network: SolanaChainId,
     address: string,
     slot: bigint,
-    baseLabels: Labels | undefined
+    baseLabels: Labels | undefined,
+    transaction?: TransactionResponse
   ) {
     super(baseLabels)
     this.network = network || SolanaChainId.SOLANA_MAINNET
     this.programName = programName
     this.address = address
     this.blockNumber = slot
+    this.transaction = transaction
   }
 
   getChainId() {
@@ -31,7 +35,7 @@ export class SolanaContext extends BaseContext {
       contractName: this.programName,
       blockNumber: this.blockNumber,
       transactionIndex: 0,
-      transactionHash: '', // TODO add
+      transactionHash: this.transaction?.transaction.signatures[0] || '',
       logIndex: 0,
       chainId: this.getChainId(),
       name: name,

package/src/solana/solana-options.ts

@@ -12,3 +12,7 @@ export class SolanaBindOptions {
   instructionCoder?: InstructionCoder
   baseLabels?: Labels
 }
+
+export class SolanaFetchConfig {
+  fetchTx?: boolean
+}

package/src/solana/solana-plugin.ts

@@ -4,6 +4,7 @@ import {
   DataBinding,
   HandlerType,
   InitResponse,
+  OnIntervalConfig,
   ProcessConfigResponse,
   ProcessResult
 } from '@sentio/protos'
@@ -30,6 +31,7 @@ export class SolanaPlugin extends Plugin {
       if (forChainId !== undefined && forChainId !== chainId.toString()) {
         continue
       }
+
       const contractConfig = ContractConfig.fromPartial({
         processorType: USER_PROCESSOR,
         contract: {
@@ -38,23 +40,47 @@ export class SolanaPlugin extends Plugin {
           address: solanaProcessor.address,
           abi: ''
         },
-        startBlock: solanaProcessor.config.startSlot,
-        instructionConfig: {
+        startBlock: solanaProcessor.config.startSlot
+      })
+      if (solanaProcessor.address && solanaProcessor.address != '*') {
+        let fetchTx = false
+        for (const fetchConfig of solanaProcessor.instructionHandlerMap.values()) {
+          if (fetchConfig.handlerOptions?.fetchTx) {
+            fetchTx = true
+            break
+          }
+        }
+        contractConfig.instructionConfig = {
           innerInstruction: solanaProcessor.processInnerInstruction,
           parsedInstruction: solanaProcessor.fromParsedInstruction !== null,
-          rawDataInstruction: solanaProcessor.decodeInstruction !== null
+          rawDataInstruction: solanaProcessor.decodeInstruction !== null,
+          fetchTx: fetchTx
         }
-      })
+      }
+
+      for (const [idx, handler] of solanaProcessor.blockHandlers.entries()) {
+        contractConfig.intervalConfigs.push(
+          OnIntervalConfig.fromPartial({
+            handlerId: idx,
+            minutesInterval: handler.timeIntervalInMinutes,
+            slotInterval: handler.slotInterval,
+            handlerName: handler.handlerName
+          })
+        )
+      }
+
       config.contractConfigs.push(contractConfig)
     }
   }
 
-  supportedHandlers = [HandlerType.SOL_INSTRUCTION]
+  supportedHandlers = [HandlerType.SOL_INSTRUCTION, HandlerType.SOL_BLOCK]
 
   processBinding(request: DataBinding): Promise<ProcessResult> {
     switch (request.handlerType) {
       case HandlerType.SOL_INSTRUCTION:
         return this.processSolInstruction(request)
+      case HandlerType.SOL_BLOCK:
+        return this.processSolBlock(request)
       default:
         throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
     }
@@ -73,7 +99,7 @@ export class SolanaPlugin extends Plugin {
 
     // Only have instruction handlers for solana processors
     for (const processor of SolanaProcessorState.INSTANCE.getValues()) {
-      if (processor.address === instruction.programAccountId) {
+      if (processor.address === instruction.programAccountId || processor.address === '*') {
         let parsedInstruction: SolInstruction | null = null
 
         try {
@@ -96,7 +122,7 @@ export class SolanaPlugin extends Plugin {
           continue
         }
         const res = processor
-          .handleInstruction(parsedInstruction, instruction.accounts, insHandler, instruction.slot)
+          .handleInstruction(parsedInstruction, instruction.accounts, insHandler, instruction)
           .catch((e) => {
             throw new ServerError(
               Status.INTERNAL,
@@ -109,6 +135,23 @@ export class SolanaPlugin extends Plugin {
     }
     return mergeProcessResults(await Promise.all(promises))
   }
+
+  async processSolBlock(request: DataBinding): Promise<ProcessResult> {
+    if (!request.data?.solBlock) {
+      throw new ServerError(Status.INVALID_ARGUMENT, 'block data cannot be empty')
+    }
+    const block = request.data.solBlock
+    const promises: Promise<ProcessResult>[] = []
+    for (const processor of SolanaProcessorState.INSTANCE.getValues()) {
+      for (const handlerId of request.handlerIds) {
+        const handler = processor.blockHandlers[handlerId]
+        if (handler) {
+          promises.push(processor.handleBlock(block, handler))
+        }
+      }
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
 }
 
 PluginManager.INSTANCE.register(new SolanaPlugin())