@sentio/sdk 1.25.3 → 1.26.0

package/src/aptos/aptos-processor.ts

@@ -8,14 +8,15 @@ import {
   TypeRegistry,
 } from '.'
 
-import Long from 'long'
 import { EventInstance, TYPE_REGISTRY } from './types'
 import { getChainId } from './network'
+import { MoveResource } from 'aptos-sdk/src/generated'
+import { AptosResourceContext } from './context'
 
 type IndexConfigure = {
   address: string
   network: AptosNetwork
-  startVersion: Long
+  startVersion: bigint
   // endSeqNumber?: Long
 }
 
@@ -49,6 +50,18 @@ class CallHandler {
   handler: (call: Transaction_UserTransaction) => Promise<ProcessResult>
 }
 
+export class MoveResourcesWithVersionPayload {
+  resources: MoveResource[]
+  version: string
+}
+
+class ResourceHandlder {
+  type?: string
+  versionInterval?: number
+  timeIntervalInMinutes?: number
+  handler: (resource: MoveResourcesWithVersionPayload) => Promise<ProcessResult>
+}
+
 export class AptosBaseProcessor {
   readonly moduleName: string
   config: IndexConfigure
@@ -57,7 +70,7 @@ export class AptosBaseProcessor {
 
   constructor(moduleName: string, options: AptosBindOptions) {
     this.moduleName = moduleName
-    this.configure(options)
+    this.config = configure(options)
     global.PROCESSOR_STATE.aptosProcessors.push(this)
     this.loadTypes(TYPE_REGISTRY)
   }
@@ -79,7 +92,7 @@ export class AptosBaseProcessor {
           processor.moduleName,
           processor.config.network,
           processor.config.address,
-          Long.fromString(tx.version),
+          BigInt(tx.version),
           tx
         )
         if (tx) {
@@ -116,7 +129,7 @@ export class AptosBaseProcessor {
           processor.moduleName,
           processor.config.network,
           processor.config.address,
-          Long.fromString(txn.version),
+          BigInt(txn.version),
           txn
         )
         if (txn && txn.events) {
@@ -158,7 +171,7 @@ export class AptosBaseProcessor {
           processor.moduleName,
           processor.config.network,
           processor.config.address,
-          Long.fromString(tx.version),
+          BigInt(tx.version),
           tx
         )
         if (tx) {
@@ -173,19 +186,6 @@ export class AptosBaseProcessor {
     return this
   }
 
-  private configure(options: AptosBindOptions) {
-    let startVersion = Long.ZERO
-    if (options.startVersion) {
-      startVersion = Long.fromValue(options.startVersion)
-    }
-
-    this.config = {
-      startVersion: startVersion,
-      address: options.address,
-      network: options.network || AptosNetwork.MAIN_NET,
-    }
-  }
-
   getChainId(): string {
     return getChainId(this.config.network)
   }
@@ -202,3 +202,76 @@ export class AptosBaseProcessor {
     console.log('')
   }
 }
+
+export class AptosAccountProcessor {
+  config: IndexConfigure
+
+  resourcesHandlers: ResourceHandlder[] = []
+
+  static bind(options: AptosBindOptions): AptosAccountProcessor {
+    return new AptosAccountProcessor(options)
+  }
+
+  protected constructor(options: AptosBindOptions) {
+    this.config = configure(options)
+    global.PROCESSOR_STATE.aptosAccountProcessors.push(this)
+  }
+
+  getChainId(): string {
+    return getChainId(this.config.network)
+  }
+
+  private onInterval(
+    handler: (resources: MoveResource[], ctx: AptosResourceContext) => void,
+    timeInterval: number | undefined,
+    versionInterval: number | undefined,
+    type: string | undefined
+  ) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const processor = this
+    this.resourcesHandlers.push({
+      handler: async function (arg) {
+        const ctx = new AptosResourceContext(processor.config.network, processor.config.address, BigInt(arg.version))
+        await handler(arg.resources, ctx)
+        return ctx.getProcessResult()
+      },
+      timeIntervalInMinutes: timeInterval,
+      versionInterval: versionInterval,
+      type: type,
+    })
+    return this
+  }
+
+  public onTimeInterval(
+    handler: (resources: MoveResource[], ctx: AptosResourceContext) => void,
+    timeIntervalInMinutes = 60,
+    typpe?: string
+  ) {
+    return this.onInterval(handler, timeIntervalInMinutes, undefined, typpe)
+  }
+
+  public onVersionInterval(
+    handler: (resources: MoveResource[], ctx: AptosResourceContext) => void,
+    versionInterval = 100000,
+    typePrefix?: string
+  ) {
+    return this.onInterval(handler, undefined, versionInterval, typePrefix)
+  }
+}
+
+function configure(options: AptosBindOptions): IndexConfigure {
+  let startVersion = 0n
+  if (options.startVersion !== undefined) {
+    if (typeof options.startVersion === 'number') {
+      startVersion = BigInt(options.startVersion)
+    } else {
+      startVersion = options.startVersion
+    }
+  }
+
+  return {
+    startVersion: startVersion,
+    address: options.address,
+    network: options.network || AptosNetwork.MAIN_NET,
+  }
+}

package/src/aptos/context.ts

@@ -10,14 +10,14 @@ export class AptosContext extends BaseContext {
   address: string
   network: AptosNetwork
   moduleName: string
-  version: Long
+  version: bigint
   transaction: Transaction_UserTransaction
 
   constructor(
     moduleName: string,
     network: AptosNetwork,
     address: string,
-    version: Long,
+    version: bigint,
     transaction?: Transaction_UserTransaction
   ) {
     super()
@@ -34,7 +34,7 @@ export class AptosContext extends BaseContext {
     return {
       address: this.address,
       contractName: this.moduleName,
-      blockNumber: this.version,
+      blockNumber: Long.fromString(this.version.toString()),
       transactionIndex: 0,
       transactionHash: this.transaction?.hash || '', // TODO
       logIndex: 0,
@@ -45,3 +45,31 @@ export class AptosContext extends BaseContext {
     }
   }
 }
+
+export class AptosResourceContext extends BaseContext {
+  address: string
+  network: AptosNetwork
+  version: bigint
+
+  constructor(network: AptosNetwork, address: string, version: bigint) {
+    super()
+    this.address = address
+    this.network = network
+    this.version = version
+  }
+
+  getMetaData(descriptor: DataDescriptor, labels: Labels): RecordMetaData {
+    return {
+      address: this.address,
+      contractName: 'resources',
+      blockNumber: Long.fromString(this.version.toString()),
+      transactionIndex: 0,
+      transactionHash: '',
+      logIndex: 0,
+      chainId: getChainId(this.network),
+      dataDescriptor: descriptor,
+      name: descriptor.name,
+      labels: normalizeLabels(labels),
+    }
+  }
+}

package/src/aptos/network.ts

@@ -1,4 +1,3 @@
-import Long from 'long'
 import { APTOS_MAINNET_ID, APTOS_TESTNET_ID, CHAIN_MAP } from '../utils/chain'
 import { AptosClient } from 'aptos-sdk'
 
@@ -38,7 +37,6 @@ export function getRpcClient(network: AptosNetwork): AptosClient {
 
 export class AptosBindOptions {
   address: string
-  network?: AptosNetwork = AptosNetwork.TEST_NET
-  startVersion?: Long | number
-  // endBlock?: Long | number
+  network?: AptosNetwork = AptosNetwork.MAIN_NET
+  startVersion?: bigint | number
 }

package/src/gen/processor/protos/processor.ts

@@ -224,12 +224,19 @@ export interface AccountConfig {
   chainId: string;
   address: string;
   startBlock: Long;
-  aptosOnVersionConfigs: AptosOnVersionConfig[];
+  onIntervalConfigs: OnIntervalConfig[];
+  onAptosIntervalConfigs: AptosOnIntervalConfig[];
 }
 
-export interface AptosOnVersionConfig {
+export interface OnIntervalConfig {
   handlerId: number;
-  step: number;
+  minutes: number;
+  slot: number;
+}
+
+export interface AptosOnIntervalConfig {
+  intervalConfig: OnIntervalConfig | undefined;
+  type: string;
 }
 
 export interface ContractInfo {
@@ -1325,7 +1332,8 @@ function createBaseAccountConfig(): AccountConfig {
     chainId: "",
     address: "",
     startBlock: Long.UZERO,
-    aptosOnVersionConfigs: [],
+    onIntervalConfigs: [],
+    onAptosIntervalConfigs: [],
   };
 }
 
@@ -1343,8 +1351,11 @@ export const AccountConfig = {
     if (!message.startBlock.isZero()) {
       writer.uint32(24).uint64(message.startBlock);
     }
-    for (const v of message.aptosOnVersionConfigs) {
-      AptosOnVersionConfig.encode(v!, writer.uint32(34).fork()).ldelim();
+    for (const v of message.onIntervalConfigs) {
+      OnIntervalConfig.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+    for (const v of message.onAptosIntervalConfigs) {
+      AptosOnIntervalConfig.encode(v!, writer.uint32(42).fork()).ldelim();
     }
     return writer;
   },
@@ -1366,8 +1377,13 @@ export const AccountConfig = {
           message.startBlock = reader.uint64() as Long;
           break;
         case 4:
-          message.aptosOnVersionConfigs.push(
-            AptosOnVersionConfig.decode(reader, reader.uint32())
+          message.onIntervalConfigs.push(
+            OnIntervalConfig.decode(reader, reader.uint32())
+          );
+          break;
+        case 5:
+          message.onAptosIntervalConfigs.push(
+            AptosOnIntervalConfig.decode(reader, reader.uint32())
           );
           break;
         default:
@@ -1385,9 +1401,12 @@ export const AccountConfig = {
       startBlock: isSet(object.startBlock)
         ? Long.fromValue(object.startBlock)
         : Long.UZERO,
-      aptosOnVersionConfigs: Array.isArray(object?.aptosOnVersionConfigs)
-        ? object.aptosOnVersionConfigs.map((e: any) =>
-            AptosOnVersionConfig.fromJSON(e)
+      onIntervalConfigs: Array.isArray(object?.onIntervalConfigs)
+        ? object.onIntervalConfigs.map((e: any) => OnIntervalConfig.fromJSON(e))
+        : [],
+      onAptosIntervalConfigs: Array.isArray(object?.onAptosIntervalConfigs)
+        ? object.onAptosIntervalConfigs.map((e: any) =>
+            AptosOnIntervalConfig.fromJSON(e)
           )
         : [],
     };
@@ -1399,12 +1418,19 @@ export const AccountConfig = {
     message.address !== undefined && (obj.address = message.address);
     message.startBlock !== undefined &&
       (obj.startBlock = (message.startBlock || Long.UZERO).toString());
-    if (message.aptosOnVersionConfigs) {
-      obj.aptosOnVersionConfigs = message.aptosOnVersionConfigs.map((e) =>
-        e ? AptosOnVersionConfig.toJSON(e) : undefined
+    if (message.onIntervalConfigs) {
+      obj.onIntervalConfigs = message.onIntervalConfigs.map((e) =>
+        e ? OnIntervalConfig.toJSON(e) : undefined
       );
     } else {
-      obj.aptosOnVersionConfigs = [];
+      obj.onIntervalConfigs = [];
+    }
+    if (message.onAptosIntervalConfigs) {
+      obj.onAptosIntervalConfigs = message.onAptosIntervalConfigs.map((e) =>
+        e ? AptosOnIntervalConfig.toJSON(e) : undefined
+      );
+    } else {
+      obj.onAptosIntervalConfigs = [];
     }
     return obj;
   },
@@ -1417,39 +1443,42 @@ export const AccountConfig = {
       object.startBlock !== undefined && object.startBlock !== null
         ? Long.fromValue(object.startBlock)
         : Long.UZERO;
-    message.aptosOnVersionConfigs =
-      object.aptosOnVersionConfigs?.map((e) =>
-        AptosOnVersionConfig.fromPartial(e)
+    message.onIntervalConfigs =
+      object.onIntervalConfigs?.map((e) => OnIntervalConfig.fromPartial(e)) ||
+      [];
+    message.onAptosIntervalConfigs =
+      object.onAptosIntervalConfigs?.map((e) =>
+        AptosOnIntervalConfig.fromPartial(e)
       ) || [];
     return message;
   },
 };
 
-function createBaseAptosOnVersionConfig(): AptosOnVersionConfig {
-  return { handlerId: 0, step: 0 };
+function createBaseOnIntervalConfig(): OnIntervalConfig {
+  return { handlerId: 0, minutes: 0, slot: 0 };
 }
 
-export const AptosOnVersionConfig = {
+export const OnIntervalConfig = {
   encode(
-    message: AptosOnVersionConfig,
+    message: OnIntervalConfig,
     writer: _m0.Writer = _m0.Writer.create()
   ): _m0.Writer {
     if (message.handlerId !== 0) {
       writer.uint32(8).int32(message.handlerId);
     }
-    if (message.step !== 0) {
-      writer.uint32(16).int32(message.step);
+    if (message.minutes !== 0) {
+      writer.uint32(16).int32(message.minutes);
+    }
+    if (message.slot !== 0) {
+      writer.uint32(24).int32(message.slot);
     }
     return writer;
   },
 
-  decode(
-    input: _m0.Reader | Uint8Array,
-    length?: number
-  ): AptosOnVersionConfig {
+  decode(input: _m0.Reader | Uint8Array, length?: number): OnIntervalConfig {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseAptosOnVersionConfig();
+    const message = createBaseOnIntervalConfig();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1457,7 +1486,10 @@ export const AptosOnVersionConfig = {
           message.handlerId = reader.int32();
           break;
         case 2:
-          message.step = reader.int32();
+          message.minutes = reader.int32();
+          break;
+        case 3:
+          message.slot = reader.int32();
           break;
         default:
           reader.skipType(tag & 7);
@@ -1467,25 +1499,109 @@ export const AptosOnVersionConfig = {
     return message;
   },
 
-  fromJSON(object: any): AptosOnVersionConfig {
+  fromJSON(object: any): OnIntervalConfig {
     return {
       handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0,
-      step: isSet(object.step) ? Number(object.step) : 0,
+      minutes: isSet(object.minutes) ? Number(object.minutes) : 0,
+      slot: isSet(object.slot) ? Number(object.slot) : 0,
     };
   },
 
-  toJSON(message: AptosOnVersionConfig): unknown {
+  toJSON(message: OnIntervalConfig): unknown {
     const obj: any = {};
     message.handlerId !== undefined &&
       (obj.handlerId = Math.round(message.handlerId));
-    message.step !== undefined && (obj.step = Math.round(message.step));
+    message.minutes !== undefined &&
+      (obj.minutes = Math.round(message.minutes));
+    message.slot !== undefined && (obj.slot = Math.round(message.slot));
     return obj;
   },
 
-  fromPartial(object: DeepPartial<AptosOnVersionConfig>): AptosOnVersionConfig {
-    const message = createBaseAptosOnVersionConfig();
+  fromPartial(object: DeepPartial<OnIntervalConfig>): OnIntervalConfig {
+    const message = createBaseOnIntervalConfig();
     message.handlerId = object.handlerId ?? 0;
-    message.step = object.step ?? 0;
+    message.minutes = object.minutes ?? 0;
+    message.slot = object.slot ?? 0;
+    return message;
+  },
+};
+
+function createBaseAptosOnIntervalConfig(): AptosOnIntervalConfig {
+  return { intervalConfig: undefined, type: "" };
+}
+
+export const AptosOnIntervalConfig = {
+  encode(
+    message: AptosOnIntervalConfig,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.intervalConfig !== undefined) {
+      OnIntervalConfig.encode(
+        message.intervalConfig,
+        writer.uint32(10).fork()
+      ).ldelim();
+    }
+    if (message.type !== "") {
+      writer.uint32(18).string(message.type);
+    }
+    return writer;
+  },
+
+  decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number
+  ): AptosOnIntervalConfig {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAptosOnIntervalConfig();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.intervalConfig = OnIntervalConfig.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 2:
+          message.type = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AptosOnIntervalConfig {
+    return {
+      intervalConfig: isSet(object.intervalConfig)
+        ? OnIntervalConfig.fromJSON(object.intervalConfig)
+        : undefined,
+      type: isSet(object.type) ? String(object.type) : "",
+    };
+  },
+
+  toJSON(message: AptosOnIntervalConfig): unknown {
+    const obj: any = {};
+    message.intervalConfig !== undefined &&
+      (obj.intervalConfig = message.intervalConfig
+        ? OnIntervalConfig.toJSON(message.intervalConfig)
+        : undefined);
+    message.type !== undefined && (obj.type = message.type);
+    return obj;
+  },
+
+  fromPartial(
+    object: DeepPartial<AptosOnIntervalConfig>
+  ): AptosOnIntervalConfig {
+    const message = createBaseAptosOnIntervalConfig();
+    message.intervalConfig =
+      object.intervalConfig !== undefined && object.intervalConfig !== null
+        ? OnIntervalConfig.fromPartial(object.intervalConfig)
+        : undefined;
+    message.type = object.type ?? "";
     return message;
   },
 };

package/src/processor-state.ts

@@ -14,6 +14,7 @@ import { TemplateInstance } from './gen'
 import { Provider } from '@ethersproject/providers'
 import { EventTracker } from './core'
 import { Metric } from './core/meter'
+import { AptosAccountProcessor } from './aptos/aptos-processor'
 
 export class ProcessorState {
   // from abiName_address_chainId => contract wrapper
@@ -34,6 +35,7 @@ export class ProcessorState {
   suiProcessors: SuiBaseProcessor[] = []
 
   aptosProcessors: AptosBaseProcessor[] = []
+  aptosAccountProcessors: AptosAccountProcessor[] = []
 
   eventTrackers: EventTracker[] = []
 

package/src/service.ts

@@ -3,6 +3,7 @@ import { CallContext, ServerError, Status } from 'nice-grpc'
 import { SOL_MAINMET_ID, SUI_DEVNET_ID } from './utils/chain'
 
 import {
+  AccountConfig,
   AptosCallHandlerConfig,
   AptosEventHandlerConfig,
   BlockBinding,
@@ -31,6 +32,7 @@ import Long from 'long'
 import { TextDecoder } from 'util'
 import { Trace } from './core'
 import { Instruction } from '@project-serum/anchor'
+import { MoveResourcesWithVersionPayload } from './aptos/aptos-processor'
 
 const DEFAULT_MAX_BLOCK = Long.ZERO
 
@@ -42,6 +44,8 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
   private blockHandlers: ((block: Block) => Promise<ProcessResult>)[] = []
   private aptosEventHandlers: ((event: any) => Promise<ProcessResult>)[] = []
   private aptosCallHandlers: ((func: any) => Promise<ProcessResult>)[] = []
+  private aptosResourceHandlers: ((resourceWithVersion: MoveResourcesWithVersionPayload) => Promise<ProcessResult>)[] =
+    []
 
   // map from chain id to list of processors
   // private blockHandlers = new Map<string, ((block: Block) => Promise<ProcessResult>)[]>()
@@ -49,6 +53,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
 
   private started = false
   private contractConfigs: ContractConfig[]
+  private accountConfigs: AccountConfig[]
   private templateInstances: TemplateInstance[]
   private metricConfigs: MetricConfig[]
   private eventTrackingConfigs: EventTrackingConfig[]
@@ -72,7 +77,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       templateInstances: this.templateInstances,
       eventTrackingConfigs: this.eventTrackingConfigs,
       metricConfigs: this.metricConfigs,
-      accountConfigs: [],
+      accountConfigs: this.accountConfigs,
     }
   }
 
@@ -81,6 +86,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     this.templateInstances = []
     // this.processorsByChainId.clear()
     this.contractConfigs = []
+    this.accountConfigs = []
 
     this.templateInstances = [...global.PROCESSOR_STATE.templatesInstances]
     this.eventTrackingConfigs = []
@@ -247,7 +253,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         blockConfigs: [],
         logConfigs: [],
         traceConfigs: [],
-        startBlock: aptosProcessor.config.startVersion,
+        startBlock: Long.fromString(aptosProcessor.config.startVersion.toString()),
         endBlock: DEFAULT_MAX_BLOCK,
         instructionConfig: undefined,
         aptosEventConfigs: [],
@@ -286,6 +292,28 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       }
       this.contractConfigs.push(contractConfig)
     }
+
+    for (const aptosProcessor of global.PROCESSOR_STATE.aptosAccountProcessors) {
+      const accountConfig: AccountConfig = {
+        address: aptosProcessor.config.address,
+        chainId: aptosProcessor.getChainId(),
+        startBlock: Long.fromValue(aptosProcessor.config.startVersion.toString()),
+        onAptosIntervalConfigs: [],
+        onIntervalConfigs: [],
+      }
+      for (const handler of aptosProcessor.resourcesHandlers) {
+        const handlerId = this.aptosResourceHandlers.push(handler.handler) - 1
+        accountConfig.onAptosIntervalConfigs.push({
+          intervalConfig: {
+            handlerId: handlerId,
+            minutes: handler.timeIntervalInMinutes || 0,
+            slot: handler.versionInterval || 0,
+          },
+          type: handler.type || '',
+        })
+      }
+      this.accountConfigs.push(accountConfig)
+    }
   }
 
   async start(request: StartRequest, context: CallContext): Promise<Empty> {
@@ -361,6 +389,8 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         return this.processAptosFunctionCall(request)
       case HandlerType.APT_EVENT:
         return this.processAptosEvent(request)
+      case HandlerType.APT_RESOURCE:
+        return this.processAptosResource(request)
       default:
         throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
     }
@@ -613,6 +643,19 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     return result
   }
 
+  async processAptosResource(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
+    }
+    const jsonString = Utf8ArrayToStr(binding.data.raw)
+    const json = JSON.parse(jsonString) as MoveResourcesWithVersionPayload
+    const result = await this.aptosResourceHandlers[binding.handlerId](json).catch((e) => {
+      throw new ServerError(Status.INTERNAL, 'error processing event: ' + jsonString + '\n' + errorString(e))
+    })
+    recordRuntimeInfo(result, HandlerType.APT_RESOURCE)
+    return result
+  }
+
   async processAptosFunctionCall(binding: DataBinding): Promise<ProcessResult> {
     if (!binding.data) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")

package/src/tests/aptos.test.ts

@@ -115,6 +115,34 @@ describe('Test Aptos Example', () => {
     const res = await service.processBindings(request)
     expect(firstGaugeValue(res.result, 'size')).equal(2n)
   })
+
+  test('check on timer', async () => {
+    const request: ProcessBindingsRequest = {
+      bindings: [
+        {
+          data: {
+            raw: new TextEncoder().encode(
+              JSON.stringify({
+                version: '12345',
+                resources: [
+                  {
+                    type: '0x1::coin::SupplyConfig',
+                    data: {
+                      allow_upgrades: false,
+                    },
+                  },
+                ],
+              })
+            ),
+          },
+          handlerId: 0,
+          handlerType: HandlerType.APT_RESOURCE,
+        },
+      ],
+    }
+    const res = await service.processBindings(request)
+    expect(firstCounterValue(res.result, 'onTimer')).equal(1n)
+  })
 })
 
 const testData = {