@sentio/sdk 1.25.2 → 1.26.0

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/target-ethers-sentio/codegen.ts

@@ -258,7 +258,9 @@ function generateOnEventFunction(event: EventDeclaration, contractName: string,
   ) {
     if (!filter) {
       // @ts-ignore
-      filter = ${contractName}Processor.filters['${filterName}'](${event.inputs.map(() => 'null').join(',')})
+      filter = ${contractName}Processor.filters[
+        // @ts-ignore
+        '${filterName}'](${event.inputs.map(() => 'null').join(',')})
     }
     return super.onEvent(handler, filter!)
   }

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 = {

package/src/tests/souffl3.ts

@@ -3,10 +3,11 @@ import { token } from '../builtin/aptos/0x3'
 import { voting } from '../builtin/aptos/0x1'
 import { TYPE_REGISTRY } from '../aptos/types'
 import { AccountEventTracker } from '@sentio/sdk'
+import { AptosAccountProcessor } from '../aptos/aptos-processor'
 
 const accountTracker = AccountEventTracker.register('pull')
 
-SouffleChefCampaign.bind({ startVersion: 3212312 })
+SouffleChefCampaign.bind({ startVersion: 3212312n })
   .onEntryPullTokenV2((call: SouffleChefCampaign.PullTokenV2Payload, ctx) => {
     ctx.meter.Counter('call_num').add(1)
     ctx.meter.Counter('pulled').add(call.arguments_typed[3])
@@ -45,3 +46,7 @@ voting.bind().onEventCreateProposalEvent((evt, ctx) => {
   evt.data_typed.expiration_secs + evt.data_typed.expiration_secs
   ctx.meter.Gauge('size').record(evt.data_typed.metadata.data.length)
 })
+
+AptosAccountProcessor.bind({ address: '0x1' }).onTimeInterval((resources, ctx) => {
+  ctx.meter.Counter('onTimer').add(1)
+}, 10000)