@sentio/sdk 1.7.12 → 1.7.15

package/src/test/codegen.test.ts

@@ -0,0 +1,26 @@
+import { codeGenEthersProcessor } from '../cli/build'
+import path from 'path'
+import * as fs from 'fs'
+import os from 'os'
+
+describe('Test EVM codegen', () => {
+  const codeGenFolder = fs.mkdtempSync(path.join(os.tmpdir(), 'codegen_test'))
+
+  jest.setTimeout(20000)
+
+  test('code gen for anyswapRouter', async () => {
+    await codeGenEthersProcessor(
+      path.join(__dirname, 'abis/evm'),
+      'lib/target-ethers-sentio',
+      `${codeGenFolder}/internal`
+    )
+    expect(fs.existsSync(codeGenFolder)).toEqual(true)
+    expect(fs.readdirSync(codeGenFolder).length).toEqual(2)
+  })
+
+  afterAll(() => {
+    if (fs.existsSync(codeGenFolder)) {
+      fs.rmSync(codeGenFolder, { recursive: true, force: true })
+    }
+  })
+})

package/src/test/erc20-template.test.ts

@@ -0,0 +1,39 @@
+// TODO move out of this package
+
+import { expect } from 'chai'
+
+import { StartRequest } from '..'
+import Long from 'long'
+import { TestProcessorServer } from './test-processor-server'
+
+describe('Test Template', () => {
+  const service = new TestProcessorServer()
+
+  beforeAll(async () => {
+    service.setup()
+    require('./erc20-template')
+    const request: StartRequest = {
+      templateInstances: [
+        {
+          contract: {
+            address: 'dynamic2',
+            name: 'dynamic2',
+            chainId: '1',
+            abi: '',
+          },
+          startBlock: Long.ZERO,
+          endBlock: Long.ZERO,
+          templateId: 0,
+        },
+      ],
+    }
+    await service.start(request)
+  })
+
+  test('Check template instantiate', async () => {
+    const config = await service.getConfig({})
+    expect(config.contractConfigs).length(2)
+    expect(config.contractConfigs?.[1].contract?.name).equals('dynamic2')
+    expect(config.templateInstances).length(1)
+  })
+})

package/src/test/erc20-template.ts

@@ -0,0 +1,25 @@
+import { Erc20Processor, Erc20ProcessorTemplate } from '../builtin/erc20'
+
+export const filter = Erc20Processor.filters.Transfer(
+  '0x0000000000000000000000000000000000000000',
+  '0xb329e39ebefd16f40d38f07643652ce17ca5bac1'
+)
+
+const processorTemplate = new Erc20ProcessorTemplate().onTransfer(async function (event, ctx) {
+  console.log('')
+})
+
+Erc20Processor.bind({
+  address: '0x1e4ede388cbc9f4b5c79681b7f94d36a11abebc9',
+  network: 1,
+  name: 'x2y2',
+  startBlock: 14201940,
+}).onTransfer(async function (event, ctx) {
+  processorTemplate.bind({
+    address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    network: 3,
+    name: 'dynamic',
+  })
+  // template.bind('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 3, 'dynamic')
+  ctx.meter.Counter('c1').add(1)
+}, filter)

package/src/test/erc20.test.ts

@@ -0,0 +1,92 @@
+// TODO move out of this package
+
+import { expect } from 'chai'
+
+import { HandlerType } from '..'
+
+import { TestProcessorServer } from './test-processor-server'
+import { firstCounterValue, firstGaugeValue } from './metric-utils'
+import { BigNumber } from 'ethers'
+import { mockTransferLog } from '../builtin/erc20/test-utils'
+
+describe('Test Basic Examples', () => {
+  const service = new TestProcessorServer()
+
+  beforeAll(async () => {
+    service.setup()
+    require('./erc20')
+    await service.start()
+  })
+
+  test('check configuration', async () => {
+    const config = await service.getConfig({})
+    expect(config.contractConfigs).length(5)
+
+    // check auto rename
+    expect(config.contractConfigs?.[2].contract?.name).equals('Erc20')
+    expect(config.contractConfigs?.[3].contract?.name).equals('Erc20_1')
+    // same as above because only differ in parameters
+    expect(config.contractConfigs?.[4].contract?.name).equals('Erc20_1')
+  })
+
+  test('Check block dispatch', async () => {
+    const res = await service.testBlock(blockData)
+    const o11yRes = res.result
+    expect(o11yRes?.counters).length(0)
+    expect(o11yRes?.gauges).length(1)
+    expect(firstGaugeValue(o11yRes, 'g1')).equals(10n)
+
+    const gauge = o11yRes?.gauges?.[0]
+    expect(gauge?.metadata?.blockNumber?.toString()).equals('14373295')
+    expect(gauge?.runtimeInfo?.from).equals(HandlerType.BLOCK)
+
+    const res2 = await service.testBlock(blockData, 56)
+    const o11yRes2 = res2.result
+    expect(o11yRes2?.counters).length(0)
+    expect(o11yRes2?.gauges).length(1)
+    expect(firstGaugeValue(o11yRes2, 'g2')).equals(20n)
+  })
+
+  test('Check log dispatch', async () => {
+    const logData = mockTransferLog('0x1E4EDE388cbc9F4b5c79681B7f94d36a11ABEBC9', {
+      from: '0x0000000000000000000000000000000000000000',
+      to: '0xB329e39Ebefd16f40d38f07643652cE17Ca5Bac1',
+      value: BigNumber.from('0x9a71db64810aaa0000'),
+    })
+
+    let res = await service.testLog(logData)
+
+    const counters = res.result?.counters
+    expect(counters).length(1)
+    expect(firstCounterValue(res.result, 'c1')).equals(1n)
+
+    expect(counters?.[0].metadata?.chainId).equals('1')
+    expect(counters?.[0].runtimeInfo?.from).equals(HandlerType.LOG)
+    expect(res.configUpdated).equals(true)
+
+    const logData2 = Object.assign({}, logData)
+    logData2.address = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
+    res = await service.testLog(logData2, 56)
+
+    expect(firstCounterValue(res.result, 'c2')).equals(2n)
+    expect(res.result?.counters[0].metadata?.chainId).equals('56')
+
+    expect(res.result?.gauges).length(0)
+
+    const config = await service.getConfig({})
+    expect(config.contractConfigs).length(6) //config increased
+    expect(config.contractConfigs?.[5].contract?.name).equals('dynamic')
+
+    // repeat trigger won't bind again
+    await service.testLogs([logData])
+    const config2 = await service.getConfig({})
+    expect(config).deep.equals(config2)
+  })
+
+  const blockData = {
+    hash: '0x2b9b7cce1f17f3b7e1f3c2472cc806a07bee3f0baca07d021350950d81d73a42',
+    number: 14373295,
+    timestamp: 1647106437,
+    extraData: '0xe4b883e5bda9e7a59ee4bb99e9b1bc493421',
+  }
+})

package/src/test/erc20.ts

@@ -0,0 +1,48 @@
+import { Erc20Processor, Erc20ProcessorTemplate } from '../builtin/erc20'
+
+export const filter = Erc20Processor.filters.Transfer(
+  '0x0000000000000000000000000000000000000000',
+  '0xb329e39ebefd16f40d38f07643652ce17ca5bac1'
+)
+
+const processorTemplate = new Erc20ProcessorTemplate().onTransfer(async function (event, ctx) {
+  console.log('')
+})
+
+Erc20Processor.bind({
+  address: '0x1e4ede388cbc9f4b5c79681b7f94d36a11abebc9',
+  // network: 1,
+  name: 'x2y2',
+  startBlock: 14201940,
+})
+  .onTransfer(async function (event, ctx) {
+    processorTemplate.bind({ address: '0x1E4EDE388cbc9F4b5c79681B7f94d36a11ABEBC9', network: 3, name: 'dynamic' })
+    // template.bind('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 3, 'dynamic')
+    ctx.meter.Counter('c1').add(1)
+  }, filter)
+  .onBlock(async function (block, ctx) {
+    ctx.meter.Gauge('g1').record(10, { k: 'v' })
+  })
+
+Erc20Processor.bind({ address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', network: 56, name: 'usdc' })
+  .onTransfer(async function (event, ctx) {
+    ctx.meter.Counter('c2').add(2)
+  }, filter)
+  .onBlock(async function (block, ctx) {
+    ctx.meter.Gauge('g2').record(20, { k: 'v' })
+  })
+// .startBlock(14201940)
+
+Erc20Processor.bind({ address: 'xxxx', network: 56 })
+
+Erc20Processor.bind({ address: 'yyyy', network: 1 })
+Erc20Processor.bind({ address: 'yyyy', network: 1 })
+Erc20Processor.bind({ address: 'yyyy', network: 1, startBlock: 21 })
+
+// const template = Erc20Processor.template
+//   .onTransfer(async function (event, ctx) {
+//     ctx.meter.Counter('c2').add(2)
+//   }, filter)
+//   .onBlock(async function (block, ctx) {
+//     ctx.meter.Gauge('h1').record(20, { k: 'v' })
+//   })

package/src/test/generic-processor.test.ts

@@ -0,0 +1,72 @@
+// TODO move out of this package
+
+import { expect } from 'chai'
+
+import { HandlerType } from '..'
+
+import { GenericProcessor } from '../generic-processor'
+import { TestProcessorServer } from './test-processor-server'
+import { firstCounterValue } from './metric-utils'
+
+describe('Test Generic Processor', () => {
+  const service = new TestProcessorServer()
+
+  beforeAll(async () => {
+    service.setup()
+
+    GenericProcessor.bind(
+      [
+        'event Transfer(address indexed from, address indexed to, uint256 value)',
+        'event Approval(address indexed from, address indexed to, uint256 value)',
+      ],
+      { address: '0x1E4EDE388cbc9F4b5c79681B7f94d36a11ABEBC9' }
+    ).onAllEvents(function (log, ctx) {
+      ctx.meter.Counter('event_num').add(1)
+    })
+
+    GenericProcessor.bind('event WalletCreated(address wallet, address owner)', {
+      address: '0x57E037F4d2c8BEa011Ad8a9A5AF4AaEEd508650f',
+    }).onAllEvents(function (log, ctx) {
+      ctx.meter.Counter('wallet').add(1)
+    })
+
+    await service.start()
+  })
+
+  test('check configuration', async () => {
+    const config = await service.getConfig({})
+    expect(config.contractConfigs).length(2)
+    expect(config.contractConfigs?.[0].contract?.name).equals('Generic')
+  })
+
+  test('Check log dispatch', async () => {
+    const res = await service.testLogs([logData, logData])
+    const counters = res.result?.counters
+    expect(counters).length(2)
+    expect(firstCounterValue(res.result, 'event_num')).equals(1n)
+    expect(counters?.[0].runtimeInfo?.from).equals(HandlerType.LOG)
+  })
+
+  test('Check log dispatch no buffer over rune', async () => {
+    const logStr =
+      '{"address":"0x57e037f4d2c8bea011ad8a9a5af4aaeed508650f","topics":["0x5b03bfed1c14a02bdeceb5fa582eb1a5765fc0bc64ca0e6af4c20afc9487f081"],"data":"0x00000000000000000000000093269483a70c68d5c5bb63aac1e8f4ac59f498800000000000000000000000000c520e51c055cf63bab075715c1b860b2e9b8e24","blockNumber":"0xc9d6d7","transactionHash":"0x208af3250499672c2f07138b9aa236153c65c78ae4341b23c2763017afdd61a2","transactionIndex":"0xf3","blockHash":"0x6e3b100c34b510049e922fbe1c1dab1b0793be3d1229b632688e6a518cdd11b6","logIndex":"0x14b","removed":false}'
+    const res = await service.testLog(JSON.parse(logStr))
+    console.log(JSON.stringify(res))
+  })
+
+  const logData = {
+    blockNumber: 14213252,
+    blockHash: '0x83d646fac9350b281def8c4c37626f9d8efc95df801287b848c719edf35cdbaf',
+    transactionIndex: 347,
+    removed: false,
+    address: '0x1E4EDE388cbc9F4b5c79681B7f94d36a11ABEBC9',
+    data: '0x00000000000000000000000000000000000000000000009a71db64810aaa0000',
+    topics: [
+      '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x000000000000000000000000b329e39ebefd16f40d38f07643652ce17ca5bac1',
+    ],
+    transactionHash: '0x93355e0cb2c3490cb8a747029ff2dc8cdbde2407025b8391398436955afae303',
+    logIndex: 428,
+  }
+})

package/src/test/index.ts

@@ -0,0 +1 @@
+export { TestProcessorServer } from './test-processor-server'

package/src/test/metric-utils.ts

@@ -0,0 +1,49 @@
+import { DeepPartial } from '../gen/builtin'
+import { BigDecimal, MetricValue, O11yResult } from '@sentio/sdk'
+import { Numberish } from '../numberish'
+import { BigNumber } from 'ethers'
+
+export function MetricValueToNumber(v: DeepPartial<MetricValue> | undefined): Numberish | undefined {
+  if (v === undefined) {
+    return undefined
+  }
+
+  if (v.doubleValue !== undefined) {
+    return v.doubleValue
+  }
+  if (v.bigInteger !== undefined) {
+    let intValue = BigNumber.from(v.bigInteger.data).toBigInt()
+    if (v.bigInteger.negative) {
+      intValue = -intValue
+    }
+    return intValue
+  }
+  if (v.bigDecimal !== undefined) {
+    return new BigDecimal(v.bigDecimal)
+  }
+  return undefined
+}
+
+export function firstCounterValue(result: O11yResult | undefined, name: string): Numberish | undefined {
+  if (!result) {
+    return undefined
+  }
+  for (const counter of result.counters) {
+    if (counter.metadata?.name === name) {
+      return MetricValueToNumber(counter.metricValue)
+    }
+  }
+  return undefined
+}
+
+export function firstGaugeValue(result: O11yResult | undefined, name: string): Numberish | undefined {
+  if (!result) {
+    return undefined
+  }
+  for (const gauge of result.gauges) {
+    if (gauge.metadata?.name === name) {
+      return MetricValueToNumber(gauge.metricValue)
+    }
+  }
+  return undefined
+}

package/src/test/mirrorworld.ts

@@ -0,0 +1,40 @@
+import { GameWalletProcessor } from './types/game_wallet_processor'
+
+GameWalletProcessor.bind({ address: 'F78NhTC9XmP1DKsCBRz5LGdQc4n4yFbj2dURiv7T9gGZ' })
+  .onDistributeWithoutUser((payload, ctx) => {
+    const amount = payload.amount.toNumber()
+    ctx.meter.Counter('deposit_pool_total_value').add(amount)
+    ctx.meter.Counter('deposit_pool_current_value').add(amount)
+    ctx.meter.Counter('distribution_pool_total_value').sub(amount)
+  })
+  .onDeposit((payload, ctx) => {
+    const amount = payload.amount.toNumber()
+    ctx.meter.Counter('deposit_pool_total_value').add(amount)
+    ctx.meter.Counter('deposit_pool_current_value').add(amount)
+  })
+  .onWithdraw((payload, ctx) => {
+    const amount = payload.amount.toNumber()
+    ctx.meter.Counter('deposit_pool_total_value').add(amount)
+    ctx.meter.Counter('distribution_pool_total_value').sub(amount)
+  })
+  .onSpend((payload, ctx) => {
+    const amount = payload.amount.toNumber()
+    ctx.meter.Counter('deposit_pool_total_value').add(amount)
+    ctx.meter.Counter('distribution_pool_total_value').sub(amount)
+  })
+  .onDistribute((payload, ctx) => {
+    const amount = payload.amount.toNumber()
+    ctx.meter.Counter('deposit_pool_total_value').add(amount)
+    ctx.meter.Counter('deposit_pool_current_value').add(amount)
+    ctx.meter.Counter('distribution_pool_total_value').sub(amount)
+  })
+  .onSpendWithoutUser((payload, ctx) => {
+    const amount = payload.amount.toNumber()
+    ctx.meter.Counter('deposit_pool_total_value').add(amount)
+    ctx.meter.Counter('deposit_pool_current_value').sub(amount)
+  })
+  .onAddDistributeSupply((payload, ctx) => {
+    const amount = payload.amount.toNumber()
+    ctx.meter.Counter('distribution_pool_total_value').add(amount)
+  })
+  .startSlot(142700000)

package/src/test/sentio.yaml

@@ -0,0 +1,4 @@
+project: test
+# project: user_org_name/name
+host: test # local/test/staging/prod
+definition: src/

package/src/test/solana.test.ts

@@ -0,0 +1,93 @@
+// TODO move out of this package
+
+import { expect } from 'chai'
+
+import { HandlerType, ProcessInstructionsRequest } from '..'
+
+import Long from 'long'
+import { TextEncoder } from 'util'
+import { TestProcessorServer } from './test-processor-server'
+import { firstCounterValue } from './metric-utils'
+
+describe('Test Solana Example', () => {
+  const service = new TestProcessorServer()
+
+  beforeAll(async () => {
+    await service.setup()
+    require('./mirrorworld')
+    require('./wormhole-token-bridge')
+    await service.start({ templateInstances: [] })
+  })
+
+  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)
+  })
+
+  test('Check wormhole token bridge instruction dispatch', async () => {
+    const request: ProcessInstructionsRequest = {
+      instructions: [
+        {
+          instructionData: '33G5T8yXAQWdH8FX7fTy1mBJ6e4dUKfQWbViSrT7qJjpS8UAA3ftEQx9sNzrkaJm56xtENhDsWf',
+          slot: Long.fromNumber(0),
+          programAccountId: 'wormDTUJ6AWPNvk59vGQbDvGJmqbDTdgWgAqcLBCgUb',
+        },
+        {
+          instructionData: '33G5T8yXAQWdH8FX7fTy1mBJ6e4dUKfQWbViSrT7qJjpS8UAA3ftEQx9sNzrkaJm56xtENhDsWf',
+          slot: Long.fromNumber(1),
+          programAccountId: 'wormDTUJ6AWPNvk59vGQbDvGJmqbDTdgWgAqcLBCgUb',
+        },
+      ],
+    }
+    const res = await service.processInstructions(request)
+    expect(res.result?.counters).length(2)
+    expect(res.result?.gauges).length(0)
+    expect(res.result?.counters[0].metadata?.blockNumber.toInt()).equal(0)
+    expect(firstCounterValue(res.result, 'total_transfer_amount')).equal(1000000n)
+    expect(res.result?.counters[0].runtimeInfo?.from).equals(HandlerType.INSTRUCTION)
+  })
+
+  test('Check SPLToken parsed instruction dispatch', async () => {
+    const parsedIns = {
+      info: {
+        account: '2SDN4vEJdCdW3pGyhx2km9gB3LeHzMGLrG2j4uVNZfrx',
+        amount: '12000000000000',
+        mint: '7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs',
+        mintAuthority: 'BCD75RNBHrJJpW4dXVagL5mPjzRLnVZq4YirJdjEYMV7',
+      },
+      type: 'mintTo',
+    }
+    const request: ProcessInstructionsRequest = {
+      instructions: [
+        {
+          instructionData: '',
+          slot: Long.fromNumber(0),
+          programAccountId: 'wormDTUJ6AWPNvk59vGQbDvGJmqbDTdgWgAqcLBCgUb',
+          parsed: new TextEncoder().encode(JSON.stringify(parsedIns)),
+        },
+      ],
+    }
+    const res = await service.processInstructions(request)
+    expect(res.result?.counters).length(1)
+    expect(res.result?.gauges).length(0)
+    expect(res.result?.counters[0].metadata?.blockNumber.toInt()).equal(0)
+    expect(firstCounterValue(res.result, 'totalWeth_supply')).equal(12000000000000)
+    expect(res.result?.counters[0].runtimeInfo?.from).equals(HandlerType.INSTRUCTION)
+  })
+})