@sentio/sdk 1.30.2 → 1.31.0

package/src/core/account-processor.ts

@@ -0,0 +1,217 @@
+import { ListStateStorage } from '../state/state-storage'
+import { ERC20__factory, ERC721__factory } from '../builtin/internal'
+import { AddressType, DummyProvider, ProcessResult } from '@sentio/sdk'
+import { AccountBindOptions } from './bind-options'
+import { getNetwork } from '@ethersproject/providers'
+import { TransferEvent as ERC20TransferEvent } from '../builtin/internal/ERC20'
+import { TransferEvent as ERC721TransferEvent } from '../builtin/internal/ERC721'
+import { AccountContext } from './context'
+import { PromiseOrVoid } from '../promise-or-void'
+import { Event, EventFilter } from '@ethersproject/contracts'
+import { BytesLike } from '@ethersproject/bytes'
+import { AddressOrTypeEventFilter, EventsHandler } from './base-processor'
+
+export class AccountProcessorState extends ListStateStorage<AccountProcessor> {
+  static INSTANCE = new AccountProcessorState()
+}
+
+const ERC20_CONTRACT = ERC20__factory.connect('', DummyProvider)
+const ERC721_CONTRACT = ERC721__factory.connect('', DummyProvider)
+
+export class AccountProcessor {
+  config: AccountBindOptions
+  eventHandlers: EventsHandler[] = []
+
+  static bind(config: AccountBindOptions): AccountProcessor {
+    const processor = new AccountProcessor(config)
+    AccountProcessorState.INSTANCE.addValue(processor)
+    return processor
+  }
+
+  protected constructor(config: AccountBindOptions) {
+    this.config = config
+  }
+
+  public getChainId(): number {
+    return getNetwork(this.config.network || 1).chainId
+  }
+
+  /**
+   * Register custom handler function to process erc20 transfer event to this account
+   * @param handler custom handler function
+   * @param tokensAddresses all the erc20 token address to watch
+   */
+  onERC20TransferIn(
+    handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    tokensAddresses: string[] = []
+  ) {
+    return this.onERC20(handler, tokensAddresses, (address: string) =>
+      ERC20_CONTRACT.filters.Transfer(null, this.config.address)
+    )
+  }
+
+  /**
+   * Register custom handler function to process erc20 transfer event from this account
+   * @param handler custom handler function
+   * @param tokensAddresses all the erc20 token address to watch
+   */
+  onERC20TransferOut(
+    handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    tokensAddresses: string[] = []
+  ) {
+    return this.onERC20(handler, tokensAddresses, (address: string) =>
+      ERC20_CONTRACT.filters.Transfer(this.config.address)
+    )
+  }
+
+  /**
+   * Register custom handler function to process erc20 mint for this account
+   * @param handler custom handler function
+   * @param tokensAddresses all the erc20 token address to watch
+   */
+  onERC20Minted(
+    handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    tokensAddresses: string[] = []
+  ) {
+    return this.onERC20(handler, tokensAddresses, (address: string) =>
+      ERC20_CONTRACT.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address)
+    )
+  }
+
+  private onERC20(
+    handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    tokensAddresses: string[] = [],
+    defaultFilter: (address: string) => AddressOrTypeEventFilter
+  ) {
+    return this.onERC(handler, tokensAddresses, defaultFilter, AddressType.ERC20)
+  }
+
+  /**
+   * Register custom handler function to process ERC721 transfer event to this account
+   * @param handler custom handler function
+   * @param collections all the ERC721 token address to watch, if not provided then watch all ERC721
+   */
+  onERC721TransferIn(
+    handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    collections: string[]
+  ) {
+    return this.onERC721(handler, collections, (address: string) =>
+      ERC721_CONTRACT.filters.Transfer(null, this.config.address)
+    )
+  }
+
+  /**
+   * Register custom handler function to process ERC721 transfer event from this account
+   * @param handler custom handler function
+   * @param collections all the ERC721 token address to watch, if not provided then watch all ERC721
+   */
+  onERC721TransferOut(
+    handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    collections: string[]
+  ) {
+    return this.onERC721(handler, collections, (address: string) =>
+      ERC721_CONTRACT.filters.Transfer(this.config.address)
+    )
+  }
+
+  /**
+   * Register custom handler function to process ERC721 mint for this account
+   * @param handler custom handler function
+   * @param collections all the ERC721 token address to watch, if not provided then watch all ERC721
+   */
+  onERC721Minted(
+    handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    collections: string[] = []
+  ) {
+    return this.onERC721(handler, collections, (address: string) =>
+      ERC721_CONTRACT.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address)
+    )
+  }
+
+  private onERC721(
+    handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    collections: string[],
+    defaultFilter: (address: string) => AddressOrTypeEventFilter
+  ) {
+    return this.onERC(handler, collections, defaultFilter, AddressType.ERC721)
+  }
+
+  private onERC(
+    handler: (event: any, ctx: AccountContext) => PromiseOrVoid,
+    contractAddresses: string[],
+    defaultFilter: (address: string) => AddressOrTypeEventFilter,
+    addressType: AddressType
+  ) {
+    const filters = []
+    for (const token of contractAddresses) {
+      const filter = defaultFilter(this.config.address)
+      filter.address = token
+      filters.push(filter)
+    }
+    if (!filters.length) {
+      const filter = defaultFilter(this.config.address)
+      filter.address = undefined
+      filter.addressType = addressType
+      filters.push(filter)
+    }
+    return this.onEvent(handler, filters)
+  }
+
+  protected onEvent(
+    handler: (event: Event, ctx: AccountContext) => PromiseOrVoid,
+    filter: AddressOrTypeEventFilter | AddressOrTypeEventFilter[]
+  ) {
+    const chainId = this.getChainId()
+
+    let _filters: AddressOrTypeEventFilter[] = []
+
+    if (Array.isArray(filter)) {
+      _filters = filter
+    } else {
+      _filters.push(filter)
+    }
+
+    let hasVaildConfig = false
+    for (const filter of _filters) {
+      if (filter.address) {
+        hasVaildConfig = true
+        break
+      }
+      if (filter.topics && filter.topics.length) {
+        hasVaildConfig = true
+        break
+      }
+    }
+
+    if (!hasVaildConfig) {
+      throw Error('no valid config has been found for this account')
+    }
+
+    const config = this.config
+
+    this.eventHandlers.push({
+      filters: _filters,
+      handler: async function (log) {
+        const ctx = new AccountContext(chainId, config.address, undefined, log)
+        // let event: Event = <Event>deepCopy(log);
+        const event: Event = <Event>log
+        const parsed = ERC20_CONTRACT.interface.parseLog(log)
+        if (parsed) {
+          event.args = parsed.args
+          event.decode = (data: BytesLike, topics?: Array<any>) => {
+            return ERC20_CONTRACT.interface.decodeEventLog(parsed.eventFragment, data, topics)
+          }
+          event.event = parsed.name
+          event.eventSignature = parsed.signature
+
+          // TODO fix this bug
+          await handler(event, ctx)
+          return ctx.getProcessResult()
+        }
+        return ProcessResult.fromPartial({})
+      },
+    })
+
+    return this
+  }
+}

package/src/core/base-processor.ts

@@ -4,13 +4,17 @@ import { BaseContract, Event, EventFilter } from '@ethersproject/contracts'
 import Long from 'long'
 
 import { BoundContractView, ContractContext, ContractView } from './context'
-import { ProcessResult } from '../gen'
+import { AddressType, ProcessResult } from '../gen'
 import { BindInternalOptions, BindOptions } from './bind-options'
 import { PromiseOrVoid } from '../promise-or-void'
 import { Trace } from './trace'
 
+export interface AddressOrTypeEventFilter extends EventFilter {
+  addressType?: AddressType
+}
+
 export class EventsHandler {
-  filters: EventFilter[]
+  filters: AddressOrTypeEventFilter[]
   handler: (event: Log) => Promise<ProcessResult>
 }
 

package/src/core/bind-options.ts

@@ -42,3 +42,9 @@ export class SolanaBindOptions extends BindOptions {
   declare network?: string
   processInnerInstruction?: boolean
 }
+
+export class AccountBindOptions {
+  address: string
+  network?: Networkish
+  startBlock?: Long | number
+}

package/src/core/context.ts

@@ -34,34 +34,14 @@ export abstract class EthContext extends BaseContext {
       this.transactionHash = trace.transactionHash
     }
   }
-}
 
-export class ContractContext<
-  TContract extends BaseContract,
-  TContractBoundView extends BoundContractView<TContract, ContractView<TContract>>
-> extends EthContext {
-  contract: TContractBoundView
-  contractName: string
-
-  constructor(
-    contractName: string,
-    view: TContractBoundView,
-    chainId: number,
-    block?: Block,
-    log?: Log,
-    trace?: Trace
-  ) {
-    super(chainId, view.rawContract.address, block, log, trace)
-    view.context = this
-    this.contractName = contractName
-    this.contract = view
-  }
+  protected abstract getContractName(): string
 
   getMetaData(name: string, labels: Labels): RecordMetaData {
     if (this.log) {
       return {
-        address: this.contract.rawContract.address,
-        contractName: this.contractName,
+        address: this.address,
+        contractName: this.getContractName(),
         blockNumber: this.blockNumber,
         transactionIndex: this.log.transactionIndex,
         transactionHash: this.transactionHash || '',
@@ -74,8 +54,8 @@ export class ContractContext<
     }
     if (this.block) {
       return {
-        address: this.contract.rawContract.address,
-        contractName: this.contractName,
+        address: this.address,
+        contractName: this.getContractName(),
         blockNumber: this.blockNumber,
         transactionIndex: -1,
         transactionHash: '',
@@ -88,8 +68,8 @@ export class ContractContext<
     }
     if (this.trace) {
       return {
-        address: this.contract.rawContract.address,
-        contractName: this.contractName,
+        address: this.address,
+        contractName: this.getContractName(),
         blockNumber: this.blockNumber,
         transactionIndex: this.trace.transactionPosition,
         transactionHash: this.transactionHash || '',
@@ -104,6 +84,41 @@ export class ContractContext<
   }
 }
 
+export class AccountContext extends EthContext {
+  constructor(chainId: number, address: string, block?: Block, log?: Log, trace?: Trace) {
+    super(chainId, address, block, log, trace)
+  }
+  protected getContractName(): string {
+    return 'account'
+  }
+}
+
+export class ContractContext<
+  TContract extends BaseContract,
+  TContractBoundView extends BoundContractView<TContract, ContractView<TContract>>
+> extends EthContext {
+  contract: TContractBoundView
+  contractName: string
+
+  constructor(
+    contractName: string,
+    view: TContractBoundView,
+    chainId: number,
+    block?: Block,
+    log?: Log,
+    trace?: Trace
+  ) {
+    super(chainId, view.rawContract.address, block, log, trace)
+    view.context = this
+    this.contractName = contractName
+    this.contract = view
+  }
+
+  protected getContractName(): string {
+    return this.contractName
+  }
+}
+
 export class ContractView<TContract extends BaseContract> {
   filters: { [name: string]: (...args: Array<any>) => EventFilter }
   protected contract: TContract

package/src/core/event-tracker.ts

@@ -1,6 +1,7 @@
 import { BaseContext } from './base-context'
-import { DataDescriptor, EventTrackingResult } from '../gen'
+import { EventTrackingResult } from '../gen'
 import { NamedResultDescriptor } from './metadata'
+import { MapStateStorage } from '../state/state-storage'
 
 export interface Event {
   // The unique identifier of main identity associate with an event
@@ -16,6 +17,10 @@ export interface TrackerOptions {
   distinctByDays?: number[]
 }
 
+export class EventTrackerState extends MapStateStorage<EventTracker> {
+  static INSTANCE = new EventTrackerState()
+}
+
 // Track Event with an identity associate with it
 export class EventTracker extends NamedResultDescriptor {
   static DEFAULT_OPTIONS: TrackerOptions = {
@@ -25,8 +30,7 @@ export class EventTracker extends NamedResultDescriptor {
 
   static register(eventName: string, options?: TrackerOptions) {
     const tracker = new EventTracker(eventName, { ...EventTracker.DEFAULT_OPTIONS, ...options })
-    global.PROCESSOR_STATE.eventTrackers.push(tracker)
-    return tracker
+    return EventTrackerState.INSTANCE.getOrSetValue(eventName, tracker)
   }
 
   options: TrackerOptions
@@ -60,7 +64,6 @@ export class AccountEventTracker extends EventTracker {
       eventName = 'user'
     }
     const tracker = new AccountEventTracker(eventName, { ...AccountEventTracker.DEFAULT_OPTIONS, ...options })
-    global.PROCESSOR_STATE.eventTrackers.push(tracker)
-    return tracker
+    return EventTrackerState.INSTANCE.getOrSetValue(eventName, tracker)
   }
 }

package/src/core/meter.ts

@@ -1,8 +1,8 @@
 import { BaseContext } from './base-context'
-import { toMetricValue, Numberish } from './numberish'
+import { Numberish, toMetricValue } from './numberish'
 import { Labels, NamedResultDescriptor } from './metadata'
-import { AggregationConfig, MetricConfig } from '../gen'
-import { MapStateStorage, StateStorage } from '../state/state-storage'
+import { AggregationConfig, AggregationType, MetricConfig } from '../gen'
+import { MapStateStorage } from '../state/state-storage'
 
 export function normalizeName(name: string): string {
   const regex = new RegExp('![_.a-zA-Z0-9]')
@@ -53,6 +53,12 @@ export class Metric extends NamedResultDescriptor {
     super(name)
     this.type = type
     this.descriptor = MetricConfig.fromPartial({ name: this.name, ...option })
+    const aggregationConfig = this.descriptor.aggregationConfig
+    if (aggregationConfig) {
+      if (aggregationConfig.intervalInMinutes > 0 && !aggregationConfig.types) {
+        aggregationConfig.types = [AggregationType.SUM, AggregationType.COUNT]
+      }
+    }
   }
 }
 

package/src/gen/chainquery/protos/chainquery.ts

@@ -16,6 +16,7 @@ export interface AptosGetTxnsByVersionRequest {
   network: string;
   fromVersion: Long;
   toVersion: Long;
+  headerOnly?: boolean | undefined;
 }
 
 export interface AptosGetTxnsByEventRequest {
@@ -175,7 +176,12 @@ export const AptosGetTxnsByFunctionRequest = {
 };
 
 function createBaseAptosGetTxnsByVersionRequest(): AptosGetTxnsByVersionRequest {
-  return { network: "", fromVersion: Long.UZERO, toVersion: Long.UZERO };
+  return {
+    network: "",
+    fromVersion: Long.UZERO,
+    toVersion: Long.UZERO,
+    headerOnly: undefined,
+  };
 }
 
 export const AptosGetTxnsByVersionRequest = {
@@ -192,6 +198,9 @@ export const AptosGetTxnsByVersionRequest = {
     if (!message.toVersion.isZero()) {
       writer.uint32(24).uint64(message.toVersion);
     }
+    if (message.headerOnly !== undefined) {
+      writer.uint32(32).bool(message.headerOnly);
+    }
     return writer;
   },
 
@@ -214,6 +223,9 @@ export const AptosGetTxnsByVersionRequest = {
         case 3:
           message.toVersion = reader.uint64() as Long;
           break;
+        case 4:
+          message.headerOnly = reader.bool();
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -231,6 +243,9 @@ export const AptosGetTxnsByVersionRequest = {
       toVersion: isSet(object.toVersion)
         ? Long.fromValue(object.toVersion)
         : Long.UZERO,
+      headerOnly: isSet(object.headerOnly)
+        ? Boolean(object.headerOnly)
+        : undefined,
     };
   },
 
@@ -241,6 +256,7 @@ export const AptosGetTxnsByVersionRequest = {
       (obj.fromVersion = (message.fromVersion || Long.UZERO).toString());
     message.toVersion !== undefined &&
       (obj.toVersion = (message.toVersion || Long.UZERO).toString());
+    message.headerOnly !== undefined && (obj.headerOnly = message.headerOnly);
     return obj;
   },
 
@@ -257,6 +273,7 @@ export const AptosGetTxnsByVersionRequest = {
       object.toVersion !== undefined && object.toVersion !== null
         ? Long.fromValue(object.toVersion)
         : Long.UZERO;
+    message.headerOnly = object.headerOnly ?? undefined;
     return message;
   },
 };

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

@@ -37,6 +37,45 @@ export function aggregationTypeToJSON(object: AggregationType): string {
   }
 }
 
+export enum AddressType {
+  ERC20 = 0,
+  ERC721 = 1,
+  ERC1155 = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function addressTypeFromJSON(object: any): AddressType {
+  switch (object) {
+    case 0:
+    case "ERC20":
+      return AddressType.ERC20;
+    case 1:
+    case "ERC721":
+      return AddressType.ERC721;
+    case 2:
+    case "ERC1155":
+      return AddressType.ERC1155;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return AddressType.UNRECOGNIZED;
+  }
+}
+
+export function addressTypeToJSON(object: AddressType): string {
+  switch (object) {
+    case AddressType.ERC20:
+      return "ERC20";
+    case AddressType.ERC721:
+      return "ERC721";
+    case AddressType.ERC1155:
+      return "ERC1155";
+    case AddressType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export enum HandlerType {
   UNKNOWN = 0,
   ETH_LOG = 1,
@@ -273,6 +312,7 @@ export interface AccountConfig {
   startBlock: Long;
   intervalConfigs: OnIntervalConfig[];
   aptosIntervalConfigs: AptosOnIntervalConfig[];
+  logConfigs: LogHandlerConfig[];
 }
 
 export interface OnIntervalConfig {
@@ -320,6 +360,8 @@ export interface LogHandlerConfig {
 
 export interface LogFilter {
   topics: Topic[];
+  address: string | undefined;
+  addressType: AddressType | undefined;
 }
 
 export interface InstructionHandlerConfig {
@@ -1607,6 +1649,7 @@ function createBaseAccountConfig(): AccountConfig {
     startBlock: Long.UZERO,
     intervalConfigs: [],
     aptosIntervalConfigs: [],
+    logConfigs: [],
   };
 }
 
@@ -1630,6 +1673,9 @@ export const AccountConfig = {
     for (const v of message.aptosIntervalConfigs) {
       AptosOnIntervalConfig.encode(v!, writer.uint32(42).fork()).ldelim();
     }
+    for (const v of message.logConfigs) {
+      LogHandlerConfig.encode(v!, writer.uint32(50).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -1659,6 +1705,11 @@ export const AccountConfig = {
             AptosOnIntervalConfig.decode(reader, reader.uint32())
           );
           break;
+        case 6:
+          message.logConfigs.push(
+            LogHandlerConfig.decode(reader, reader.uint32())
+          );
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1682,6 +1733,9 @@ export const AccountConfig = {
             AptosOnIntervalConfig.fromJSON(e)
           )
         : [],
+      logConfigs: Array.isArray(object?.logConfigs)
+        ? object.logConfigs.map((e: any) => LogHandlerConfig.fromJSON(e))
+        : [],
     };
   },
 
@@ -1705,6 +1759,13 @@ export const AccountConfig = {
     } else {
       obj.aptosIntervalConfigs = [];
     }
+    if (message.logConfigs) {
+      obj.logConfigs = message.logConfigs.map((e) =>
+        e ? LogHandlerConfig.toJSON(e) : undefined
+      );
+    } else {
+      obj.logConfigs = [];
+    }
     return obj;
   },
 
@@ -1722,6 +1783,8 @@ export const AccountConfig = {
       object.aptosIntervalConfigs?.map((e) =>
         AptosOnIntervalConfig.fromPartial(e)
       ) || [];
+    message.logConfigs =
+      object.logConfigs?.map((e) => LogHandlerConfig.fromPartial(e)) || [];
     return message;
   },
 };
@@ -2313,7 +2376,7 @@ export const LogHandlerConfig = {
 };
 
 function createBaseLogFilter(): LogFilter {
-  return { topics: [] };
+  return { topics: [], address: undefined, addressType: undefined };
 }
 
 export const LogFilter = {
@@ -2324,6 +2387,12 @@ export const LogFilter = {
     for (const v of message.topics) {
       Topic.encode(v!, writer.uint32(10).fork()).ldelim();
     }
+    if (message.address !== undefined) {
+      writer.uint32(18).string(message.address);
+    }
+    if (message.addressType !== undefined) {
+      writer.uint32(24).int32(message.addressType);
+    }
     return writer;
   },
 
@@ -2337,6 +2406,12 @@ export const LogFilter = {
         case 1:
           message.topics.push(Topic.decode(reader, reader.uint32()));
           break;
+        case 2:
+          message.address = reader.string();
+          break;
+        case 3:
+          message.addressType = reader.int32() as any;
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -2350,6 +2425,10 @@ export const LogFilter = {
       topics: Array.isArray(object?.topics)
         ? object.topics.map((e: any) => Topic.fromJSON(e))
         : [],
+      address: isSet(object.address) ? String(object.address) : undefined,
+      addressType: isSet(object.addressType)
+        ? addressTypeFromJSON(object.addressType)
+        : undefined,
     };
   },
 
@@ -2360,12 +2439,20 @@ export const LogFilter = {
     } else {
       obj.topics = [];
     }
+    message.address !== undefined && (obj.address = message.address);
+    message.addressType !== undefined &&
+      (obj.addressType =
+        message.addressType !== undefined
+          ? addressTypeToJSON(message.addressType)
+          : undefined);
     return obj;
   },
 
   fromPartial(object: DeepPartial<LogFilter>): LogFilter {
     const message = createBaseLogFilter();
     message.topics = object.topics?.map((e) => Topic.fromPartial(e)) || [];
+    message.address = object.address ?? undefined;
+    message.addressType = object.addressType ?? undefined;
     return message;
   },
 };

package/src/index.ts

@@ -1,4 +1,4 @@
-export { ProcessorServiceImpl } from './service'
+// export { ProcessorServiceImpl } from './service'
 export { getProvider, setProvider, DummyProvider } from './provider'
 export { transformEtherError } from './error'
 // export { ProcessorState } from './state/processor-state'