@sentio/sdk 1.16.4 → 1.17.1

package/src/meter.ts

@@ -1,5 +1,5 @@
 import { MetricDescriptor, RecordMetaData } from './gen/processor/protos/processor'
-import { BaseContext, Context, SolanaContext, SuiContext } from './context'
+import { AptosContext, BaseContext, Context, SolanaContext, SuiContext } from './context'
 import { toMetricValue, Numberish } from './numberish'
 import Long from 'long'
 
@@ -42,6 +42,7 @@ function GetRecordMetaData(ctx: BaseContext, metric: Metric, labels: Labels): Re
         contractAddress: ctx.contract.rawContract.address,
         blockNumber: Long.fromNumber(ctx.log.blockNumber, true), // TODO need number type to be long
         transactionIndex: ctx.log.transactionIndex,
+        transactionHash: ctx.transactionHash || '',
         logIndex: ctx.log.logIndex,
         chainId: ctx.chainId.toString(),
         descriptor: descriptor,
@@ -53,6 +54,7 @@ function GetRecordMetaData(ctx: BaseContext, metric: Metric, labels: Labels): Re
         contractAddress: ctx.contract.rawContract.address,
         blockNumber: Long.fromNumber(ctx.block.number, true),
         transactionIndex: -1,
+        transactionHash: '',
         logIndex: -1,
         chainId: ctx.chainId.toString(),
         descriptor: descriptor,
@@ -63,7 +65,8 @@ function GetRecordMetaData(ctx: BaseContext, metric: Metric, labels: Labels): Re
       return {
         contractAddress: ctx.contract.rawContract.address,
         blockNumber: Long.fromNumber(ctx.trace.blockNumber, true),
-        transactionIndex: ctx.trace.transactionPosition, // TODO make sure if this is the right value to set
+        transactionIndex: ctx.trace.transactionPosition,
+        transactionHash: ctx.transactionHash || '',
         logIndex: -1,
         chainId: ctx.chainId.toString(),
         descriptor: descriptor,
@@ -75,6 +78,7 @@ function GetRecordMetaData(ctx: BaseContext, metric: Metric, labels: Labels): Re
       contractAddress: ctx.address,
       blockNumber: Long.ZERO, // TODO need number type to be long
       transactionIndex: 0,
+      transactionHash: '', // TODO add
       logIndex: 0,
       chainId: 'SOL_mainnet', // TODO set in context
       descriptor: descriptor,
@@ -85,11 +89,23 @@ function GetRecordMetaData(ctx: BaseContext, metric: Metric, labels: Labels): Re
       contractAddress: ctx.address,
       blockNumber: Long.ZERO, // TODO need number type to be long
       transactionIndex: 0,
+      transactionHash: '', // TODO
       logIndex: 0,
       chainId: 'SUI_devnet', // TODO set in context
       descriptor: descriptor,
       labels: normalizeLabels(labels),
     }
+  } else if (ctx instanceof AptosContext) {
+    return {
+      contractAddress: ctx.address,
+      blockNumber: Long.ZERO, // TODO need number type to be long
+      transactionIndex: 0,
+      transactionHash: '', // TODO
+      logIndex: 0,
+      chainId: 'aptos_devnet', // TODO set in context
+      descriptor: descriptor,
+      labels: normalizeLabels(labels),
+    }
   }
   throw new Error("This can't happen")
 }

package/src/processor-state.ts

@@ -6,6 +6,7 @@ import { TemplateInstance } from './gen/processor/protos/processor'
 import { Provider } from '@ethersproject/providers'
 import { SolanaBaseProcessor } from './solana-processor'
 import { SuiBaseProcessor } from './sui-processor'
+import { AptosBaseProcessor } from './aptos-processor'
 
 export class ProcessorState {
   // from abiName_address_chainId => contract wrapper
@@ -24,4 +25,6 @@ export class ProcessorState {
   solanaProcessors: SolanaBaseProcessor[] = []
 
   suiProcessors: SuiBaseProcessor[] = []
+
+  aptosProcessors: AptosBaseProcessor[] = []
 }

package/src/service.ts

@@ -195,6 +195,26 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       }
       this.contractConfigs.push(contractConfig)
     }
+
+    // Part 3, prepare aptos constractors
+    for (const aptosProcessor of global.PROCESSOR_STATE.aptosProcessors) {
+      const contractConfig: ContractConfig = {
+        processorType: 'user_processor',
+        contract: {
+          name: 'aptos processor',
+          chainId: 'aptos_testnet',
+          address: aptosProcessor.address,
+          abi: '',
+        },
+        blockConfigs: [],
+        logConfigs: [],
+        traceConfigs: [],
+        startBlock: aptosProcessor.config.startSeqNumber,
+        endBlock: DEFAULT_MAX_BLOCK,
+        instructionConfig: undefined,
+      }
+      this.contractConfigs.push(contractConfig)
+    }
   }
 
   async start(request: StartRequest, context: CallContext): Promise<Empty> {
@@ -339,6 +359,37 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       await Promise.all(processorPromises)
     }
 
+    if (request.chainId.toLowerCase().startsWith('apt') && global.PROCESSOR_STATE.aptosProcessors) {
+      const processorPromises: Promise<void>[] = []
+      for (const txn of request.transactions) {
+        processorPromises.push(
+          new Promise((resolve, _) => {
+            for (const processor of global.PROCESSOR_STATE.aptosProcessors) {
+              if (processor.address === txn.programAccountId!) {
+                const res = processor.handleTransaction(JSON.parse(new TextDecoder().decode(txn.raw)))
+                if (res) {
+                  res.gauges.forEach((g) => {
+                    if (g.metadata && txn.slot) {
+                      g.metadata.blockNumber = txn.slot
+                    }
+                    result.gauges.push(g)
+                  })
+                  res.counters.forEach((c) => {
+                    if (c.metadata && txn.slot) {
+                      c.metadata.blockNumber = txn.slot
+                    }
+                    result.counters.push(c)
+                  })
+                }
+              }
+            }
+            resolve()
+          })
+        )
+      }
+      await Promise.all(processorPromises)
+    }
+
     recordRuntimeInfo(result, HandlerType.TRANSACTION)
     return {
       result,

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

@@ -1,7 +1,7 @@
 import { SolanaBaseProcessor } from '../../solana-processor'
 import { SolanaContext } from '../../context'
 import { Instruction } from '@project-serum/anchor'
-import { Approve, Burn, CloseAccount, FreezeAccount, InitializeAccount, InitializeAccount2, InitializeAccount3, InitializeMint, InitializeMultisig, MintTo, Revoke, ThawAccount, Transfer } from './types';
+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';
 import { SolanaBindOptions } from '../../bind-options';
 
 export class SPLTokenProcessor extends SolanaBaseProcessor {
@@ -160,5 +160,141 @@ export class SPLTokenProcessor extends SolanaBaseProcessor {
     })
     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
 }

package/src/solana/builtin/types.ts

@@ -205,34 +205,41 @@ const BurnChecked = type({
   tokenAmount: TokenAmountUi,
 });
 
+export type SyncNative = Infer<typeof BurnChecked>;
 const SyncNative = type({
   account: PublicKeyFromString,
 });
 
+export type GetAccountDataSize = Infer<typeof GetAccountDataSize>;
 const GetAccountDataSize = type({
   mint: PublicKeyFromString,
   extensionTypes: optional(array(string())),
 });
 
+export type InitializeImmutableOwner = Infer<typeof InitializeImmutableOwner>;
 const InitializeImmutableOwner = type({
   account: PublicKeyFromString,
 });
 
+export type AmountToUiAmount = Infer<typeof AmountToUiAmount>;
 const AmountToUiAmount = type({
   mint: PublicKeyFromString,
   amount: union([string(), number()]),
 });
 
+export type UiAmountToAmount = Infer<typeof UiAmountToAmount>;
 const UiAmountToAmount = type({
   mint: PublicKeyFromString,
   uiAmount: string(),
 });
 
+export type InitializeMintCloseAuthority = Infer<typeof InitializeMintCloseAuthority>;
 const InitializeMintCloseAuthority = type({
   mint: PublicKeyFromString,
   newAuthority: PublicKeyFromString,
 });
 
+export type TransferFeeExtension = Infer<typeof TransferFeeExtension>;
 const TransferFeeExtension = type({
   mint: PublicKeyFromString,
   transferFeeConfigAuthority: PublicKeyFromString,
@@ -241,12 +248,14 @@ const TransferFeeExtension = type({
   maximumFee: number(),
 });
 
+export type DefaultAccountStateExtension = Infer<typeof DefaultAccountStateExtension>;
 const DefaultAccountStateExtension = type({
   mint: PublicKeyFromString,
   accountState: string(),
   freezeAuthority: optional(PublicKeyFromString),
 });
 
+export type Reallocate = Infer<typeof Reallocate>;
 const Reallocate = type({
   account: PublicKeyFromString,
   payer: PublicKeyFromString,
@@ -254,6 +263,7 @@ const Reallocate = type({
   extensionTypes: array(string()),
 });
 
+export type MemoTransferExtension = Infer<typeof MemoTransferExtension>;
 const MemoTransferExtension = type({
   account: PublicKeyFromString,
   owner: optional(PublicKeyFromString),
@@ -261,6 +271,7 @@ const MemoTransferExtension = type({
   signers: optional(array(PublicKeyFromString)),
 });
 
+export type CreateNativeMint = Infer<typeof CreateNativeMint>;
 const CreateNativeMint = type({
   payer: PublicKeyFromString,
   nativeMint: PublicKeyFromString,

package/src/test/abis/solana/basic_1.json

@@ -0,0 +1,62 @@
+{
+  "version": "0.1.0",
+  "name": "basic_1",
+  "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"
+        }
+      ]
+    }
+  ],
+  "accounts": [
+    {
+      "name": "MyAccount",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "data",
+            "type": "u64"
+          }
+        ]
+      }
+    }
+  ]
+}

package/src/test/aptos.test.ts

@@ -0,0 +1,148 @@
+import { expect } from 'chai'
+import { TextEncoder } from 'util'
+import { ProcessTransactionsRequest } from '..'
+
+import { TestProcessorServer } from './test-processor-server'
+
+describe('Test Aptos Example', () => {
+  const service = new TestProcessorServer(() => {
+    require('./souffl3')
+  })
+
+  beforeAll(async () => {
+    await service.start({ templateInstances: [] })
+  })
+
+  test('check configuration ', async () => {
+    const config = await service.getConfig({})
+    expect(config.contractConfigs).length(1)
+  })
+
+  test('Check souffl3 transaction dispatch', async () => {
+    const request: ProcessTransactionsRequest = {
+      chainId: 'aptos_testnet',
+      transactions: [
+        {
+          raw: new TextEncoder().encode(JSON.stringify(testData)),
+          programAccountId: '4188c8694687e844677c2aa87171019e23d61cac60de5082a278a8aa47e9d807',
+        },
+      ],
+    }
+    const res = await service.processTransactions(request)
+    expect(res.result?.counters).length(1)
+    expect(res.result?.gauges).length(0)
+  })
+})
+
+const testData = {
+  version: '18483034',
+  hash: '0xbf4df6f390546a793ba9b7caff120002b3257986dbea9c697fd64acf7dfeb052',
+  state_change_hash: '0x6063039cca5a1eb33d3986d3665fc783238579961eaa4746c41e25fa4f72aac6',
+  event_root_hash: '0x425e39bcf994672108f83c34f637e84166af7ecedcbe26aed0dff0d62da8055d',
+  state_checkpoint_hash: null,
+  gas_used: '854',
+  success: true,
+  vm_status: 'Executed successfully',
+  accumulator_root_hash: '0x47aa479d9e15993ea2abe04043c89186fb5da0b5eb8b5c6d18bd55d5f0c2c877',
+  changes: [],
+  sender: '0x4188c8694687e844677c2aa87171019e23d61cac60de5082a278a8aa47e9d807',
+  sequence_number: '30',
+  max_gas_amount: '20000',
+  gas_unit_price: '1',
+  expiration_timestamp_secs: '1663144544',
+  payload: {
+    function: '0x4188c8694687e844677c2aa87171019e23d61cac60de5082a278a8aa47e9d807::SouffleChefCampaign::pull_token_v2',
+    type_arguments: ['0x1::aptos_coin::AptosCoin'],
+    arguments: [
+      '0x4188c8694687e844677c2aa87171019e23d61cac60de5082a278a8aa47e9d807',
+      '0x4188c8694687e844677c2aa87171019e23d61cac60de5082a278a8aa47e9d807',
+      'Souffl3 BlueBerry',
+      '1',
+    ],
+    type: 'entry_function_payload',
+  },
+  signature: {
+    public_key: '0x6c3f579afbf8a728827385039f7604ec1d06e5c802d8f9689ee8ec9d349fedc5',
+    signature:
+      '0xd2db95052e774f095d924030a50c29325a17e8d69d35c748f45bb0e22eb7d3b9e47545c98bd7130fd3ef46cbedc30c9aaeaf39c2d922ee8e7d578c0b1e76f30b',
+    type: 'ed25519_signature',
+  },
+  events: [
+    {
+      guid: {
+        creation_number: '3',
+        account_address: '0x4188c8694687e844677c2aa87171019e23d61cac60de5082a278a8aa47e9d807',
+      },
+      sequence_number: '10',
+      type: '0x1::coin::WithdrawEvent',
+      data: {
+        amount: '1',
+      },
+    },
+    {
+      guid: {
+        creation_number: '2',
+        account_address: '0x4188c8694687e844677c2aa87171019e23d61cac60de5082a278a8aa47e9d807',
+      },
+      sequence_number: '11',
+      type: '0x1::coin::DepositEvent',
+      data: {
+        amount: '1',
+      },
+    },
+    {
+      guid: {
+        creation_number: '9',
+        account_address: '0x21d5fe032affa1c8b10d343e9ad5a5618bc13baf5ed4a674fafaa12c54f416cc',
+      },
+      sequence_number: '9',
+      type: '0x3::token::CreateTokenDataEvent',
+      data: {
+        description:
+          'Souffl3 offers a one-stop marketplace for the launch, listing, and trading of NFT assets on APTOS.\nWebsite：https://souffl3.com/\nEveryone can win through our Bake Off campaign on the Aptos Testnet, rewards including Souffl3 Genesis NFT and whitelists of other collab projects, everyone is welcome to participate!',
+        id: {
+          collection: 'Souffl3 BlueBerry',
+          creator: '0x21d5fe032affa1c8b10d343e9ad5a5618bc13baf5ed4a674fafaa12c54f416cc',
+          name: 'Souffl3 BlueBerry #2',
+        },
+        maximum: '999999999999',
+        mutability_config: {
+          description: true,
+          maximum: true,
+          properties: true,
+          royalty: true,
+          uri: true,
+        },
+        name: 'Souffl3 BlueBerry #2',
+        property_keys: ['author', 'point'],
+        property_types: ['string', 'integer'],
+        property_values: ['0x33454e4a4f59204c616273', '0x30'],
+        royalty_payee_address: '0x4188c8694687e844677c2aa87171019e23d61cac60de5082a278a8aa47e9d807',
+        royalty_points_denominator: '100',
+        royalty_points_numerator: '20',
+        uri: 'https://y3x4txhvirx5zl57efzbl6dg7psaier5q35hhwuqwzjwuahrycya.arweave.net/xu_J3PVEb9yvvyFyFfhm--QEEj2G-nPakLZTagDxwLA',
+      },
+    },
+    {
+      guid: {
+        creation_number: '2',
+        account_address: '0x21d5fe032affa1c8b10d343e9ad5a5618bc13baf5ed4a674fafaa12c54f416cc',
+      },
+      sequence_number: '27',
+      type: '0x3::token::DepositEvent',
+      data: {
+        amount: '1',
+        id: {
+          property_version: '0',
+          token_data_id: {
+            collection: 'Souffl3 BlueBerry',
+            creator: '0x21d5fe032affa1c8b10d343e9ad5a5618bc13baf5ed4a674fafaa12c54f416cc',
+            name: 'Souffl3 BlueBerry #2',
+          },
+        },
+      },
+    },
+  ],
+  timestamp: '1663143945131218',
+  type: 'user_transaction',
+}

package/src/test/erc20.test.ts

@@ -7,7 +7,7 @@ import { HandlerType } from '..'
 import { TestProcessorServer } from './test-processor-server'
 import { firstCounterValue, firstGaugeValue } from './metric-utils'
 import { BigNumber } from 'ethers'
-import { mockApprovalLog, mockTransferLog } from '../builtin/erc20/test-utils'
+import { mockTransferLog } from '../builtin/erc20/test-utils'
 import { Trace } from '../trace'
 
 describe('Test Basic Examples', () => {

package/src/test/erc20.ts

@@ -1,5 +1,4 @@
 import { ERC20Processor, ERC20ProcessorTemplate } from '../builtin/erc20'
-import { BigNumber } from '@ethersproject/bignumber'
 
 export const filter = ERC20Processor.filters.Transfer(
   '0x0000000000000000000000000000000000000000',

package/src/test/solana.test.ts

@@ -11,7 +11,6 @@ import { firstCounterValue } from './metric-utils'
 
 describe('Test Solana Example', () => {
   const service = new TestProcessorServer(() => {
-    require('./mirrorworld')
     require('./wormhole-token-bridge')
   })
 
@@ -21,23 +20,7 @@ describe('Test Solana Example', () => {
 
   test('check configuration ', async () => {
     const config = await service.getConfig({})
-    expect(config.contractConfigs).length(3)
-  })
-
-  test('Check mirrorworld instruction dispatch', async () => {
-    const request: ProcessInstructionsRequest = {
-      instructions: [
-        {
-          instructionData: 'CACadoFwjNvan4GP8gh3Jtm1qdeoKX5j2SbSNEiB',
-          slot: Long.fromNumber(0),
-          programAccountId: 'F78NhTC9XmP1DKsCBRz5LGdQc4n4yFbj2dURiv7T9gGZ',
-        },
-      ],
-    }
-    const res = await service.processInstructions(request)
-    expect(res.result?.counters).length(3)
-    expect(res.result?.gauges).length(0)
-    expect(firstCounterValue(res.result, 'deposit_pool_total_value')).equal(5000000000n)
+    expect(config.contractConfigs).length(2)
   })
 
   test('Check wormhole token bridge instruction dispatch', async () => {

package/src/test/souffl3.ts

@@ -0,0 +1,24 @@
+import { AptosBindOptions } from '../bind-options'
+import { AptosBaseProcessor } from '../aptos-processor'
+
+class Souffl3 extends AptosBaseProcessor {
+  static bind(options: AptosBindOptions): Souffl3 {
+    if (options && !options.name) {
+      options.name = 'souffl3'
+    }
+    return new Souffl3(options)
+  }
+}
+
+Souffl3.bind({
+  startBlock: 6604913,
+  address: '4188c8694687e844677c2aa87171019e23d61cac60de5082a278a8aa47e9d807',
+}).onTransaction((txn, ctx) => {
+  if (txn.events) {
+    for (const event of txn.events) {
+      if (event && event.type === '0x3::token::DepositEvent') {
+        ctx.meter.Counter('deposit_token_count').add(Number(event.data.amount))
+      }
+    }
+  }
+})

package/src/test/test-provider.ts

@@ -1,18 +1,19 @@
 import { ChainConfig } from '../chain-config'
 import { setProvider } from '@sentio/sdk'
+import { CHAIN_MAP } from '../utils/chainmap'
 
-export function loadTestProvidersFromEnv(ids: string[] | string): boolean {
+export function loadTestProvidersFromEnv(requiredChainIds: string[] | string): boolean {
   const dummyConfig: Record<string, ChainConfig> = {}
 
-  if (!Array.isArray(ids)) {
-    ids = [ids]
+  if (!Array.isArray(requiredChainIds)) {
+    requiredChainIds = [requiredChainIds]
   }
 
-  for (const k of ids) {
+  for (const k of Object.keys(CHAIN_MAP)) {
     const envKey = 'TEST_ENDPOINT_' + k
     const http = process.env[envKey]
     if (!http) {
-      return false
+      continue
     }
     dummyConfig[k] = {
       ChainID: k,
@@ -21,5 +22,10 @@ export function loadTestProvidersFromEnv(ids: string[] | string): boolean {
   }
 
   setProvider(dummyConfig)
+  for (const id of requiredChainIds) {
+    if (!requiredChainIds.includes(id)) {
+      return false
+    }
+  }
   return true
 }