@sentio/sdk 1.30.3 → 1.31.1

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/meter.ts

@@ -1,7 +1,7 @@
 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 { AggregationConfig, AggregationType, MetricConfig } from '../gen'
 import { MapStateStorage } from '../state/state-storage'
 
 export function normalizeName(name: string): string {
@@ -53,6 +53,15 @@ 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 && aggregationConfig.intervalInMinutes && aggregationConfig.intervalInMinutes.length) {
+      if (aggregationConfig.intervalInMinutes.length > 1) {
+        console.error('current only support one intervalInMinutes, only first interval will be used for', name)
+      }
+      if (aggregationConfig.intervalInMinutes[0] > 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;
   },
 };