@sentio/sdk 1.27.10 → 1.29.0

package/src/gen/service/price/protos/price.ts

@@ -0,0 +1,394 @@
+/* eslint-disable */
+import { CallContext, CallOptions } from "nice-grpc-common";
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+
+export interface CoinID {
+  symbol: string | undefined;
+  address: CoinID_AddressIdentifier | undefined;
+}
+
+export interface CoinID_AddressIdentifier {
+  address: string;
+  chain: string;
+}
+
+export interface GetPriceRequest {
+  timestamp: Date | undefined;
+  coinId: CoinID | undefined;
+}
+
+export interface GetPriceResponse {
+  price: number;
+  timestamp: Date | undefined;
+}
+
+function createBaseCoinID(): CoinID {
+  return { symbol: undefined, address: undefined };
+}
+
+export const CoinID = {
+  encode(
+    message: CoinID,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.symbol !== undefined) {
+      writer.uint32(18).string(message.symbol);
+    }
+    if (message.address !== undefined) {
+      CoinID_AddressIdentifier.encode(
+        message.address,
+        writer.uint32(26).fork()
+      ).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CoinID {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCoinID();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 2:
+          message.symbol = reader.string();
+          break;
+        case 3:
+          message.address = CoinID_AddressIdentifier.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CoinID {
+    return {
+      symbol: isSet(object.symbol) ? String(object.symbol) : undefined,
+      address: isSet(object.address)
+        ? CoinID_AddressIdentifier.fromJSON(object.address)
+        : undefined,
+    };
+  },
+
+  toJSON(message: CoinID): unknown {
+    const obj: any = {};
+    message.symbol !== undefined && (obj.symbol = message.symbol);
+    message.address !== undefined &&
+      (obj.address = message.address
+        ? CoinID_AddressIdentifier.toJSON(message.address)
+        : undefined);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<CoinID>): CoinID {
+    const message = createBaseCoinID();
+    message.symbol = object.symbol ?? undefined;
+    message.address =
+      object.address !== undefined && object.address !== null
+        ? CoinID_AddressIdentifier.fromPartial(object.address)
+        : undefined;
+    return message;
+  },
+};
+
+function createBaseCoinID_AddressIdentifier(): CoinID_AddressIdentifier {
+  return { address: "", chain: "" };
+}
+
+export const CoinID_AddressIdentifier = {
+  encode(
+    message: CoinID_AddressIdentifier,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    if (message.chain !== "") {
+      writer.uint32(18).string(message.chain);
+    }
+    return writer;
+  },
+
+  decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number
+  ): CoinID_AddressIdentifier {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCoinID_AddressIdentifier();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        case 2:
+          message.chain = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CoinID_AddressIdentifier {
+    return {
+      address: isSet(object.address) ? String(object.address) : "",
+      chain: isSet(object.chain) ? String(object.chain) : "",
+    };
+  },
+
+  toJSON(message: CoinID_AddressIdentifier): unknown {
+    const obj: any = {};
+    message.address !== undefined && (obj.address = message.address);
+    message.chain !== undefined && (obj.chain = message.chain);
+    return obj;
+  },
+
+  fromPartial(
+    object: DeepPartial<CoinID_AddressIdentifier>
+  ): CoinID_AddressIdentifier {
+    const message = createBaseCoinID_AddressIdentifier();
+    message.address = object.address ?? "";
+    message.chain = object.chain ?? "";
+    return message;
+  },
+};
+
+function createBaseGetPriceRequest(): GetPriceRequest {
+  return { timestamp: undefined, coinId: undefined };
+}
+
+export const GetPriceRequest = {
+  encode(
+    message: GetPriceRequest,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.timestamp !== undefined) {
+      Timestamp.encode(
+        toTimestamp(message.timestamp),
+        writer.uint32(10).fork()
+      ).ldelim();
+    }
+    if (message.coinId !== undefined) {
+      CoinID.encode(message.coinId, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GetPriceRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetPriceRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.timestamp = fromTimestamp(
+            Timestamp.decode(reader, reader.uint32())
+          );
+          break;
+        case 2:
+          message.coinId = CoinID.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetPriceRequest {
+    return {
+      timestamp: isSet(object.timestamp)
+        ? fromJsonTimestamp(object.timestamp)
+        : undefined,
+      coinId: isSet(object.coinId) ? CoinID.fromJSON(object.coinId) : undefined,
+    };
+  },
+
+  toJSON(message: GetPriceRequest): unknown {
+    const obj: any = {};
+    message.timestamp !== undefined &&
+      (obj.timestamp = message.timestamp.toISOString());
+    message.coinId !== undefined &&
+      (obj.coinId = message.coinId ? CoinID.toJSON(message.coinId) : undefined);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<GetPriceRequest>): GetPriceRequest {
+    const message = createBaseGetPriceRequest();
+    message.timestamp = object.timestamp ?? undefined;
+    message.coinId =
+      object.coinId !== undefined && object.coinId !== null
+        ? CoinID.fromPartial(object.coinId)
+        : undefined;
+    return message;
+  },
+};
+
+function createBaseGetPriceResponse(): GetPriceResponse {
+  return { price: 0, timestamp: undefined };
+}
+
+export const GetPriceResponse = {
+  encode(
+    message: GetPriceResponse,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.price !== 0) {
+      writer.uint32(9).double(message.price);
+    }
+    if (message.timestamp !== undefined) {
+      Timestamp.encode(
+        toTimestamp(message.timestamp),
+        writer.uint32(18).fork()
+      ).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GetPriceResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetPriceResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.price = reader.double();
+          break;
+        case 2:
+          message.timestamp = fromTimestamp(
+            Timestamp.decode(reader, reader.uint32())
+          );
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetPriceResponse {
+    return {
+      price: isSet(object.price) ? Number(object.price) : 0,
+      timestamp: isSet(object.timestamp)
+        ? fromJsonTimestamp(object.timestamp)
+        : undefined,
+    };
+  },
+
+  toJSON(message: GetPriceResponse): unknown {
+    const obj: any = {};
+    message.price !== undefined && (obj.price = message.price);
+    message.timestamp !== undefined &&
+      (obj.timestamp = message.timestamp.toISOString());
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<GetPriceResponse>): GetPriceResponse {
+    const message = createBaseGetPriceResponse();
+    message.price = object.price ?? 0;
+    message.timestamp = object.timestamp ?? undefined;
+    return message;
+  },
+};
+
+export type PriceServiceDefinition = typeof PriceServiceDefinition;
+export const PriceServiceDefinition = {
+  name: "PriceService",
+  fullName: "price_service.PriceService",
+  methods: {
+    getPrice: {
+      name: "GetPrice",
+      requestType: GetPriceRequest,
+      requestStream: false,
+      responseType: GetPriceResponse,
+      responseStream: false,
+      options: {},
+    },
+  },
+} as const;
+
+export interface PriceServiceServiceImplementation<CallContextExt = {}> {
+  getPrice(
+    request: GetPriceRequest,
+    context: CallContext & CallContextExt
+  ): Promise<DeepPartial<GetPriceResponse>>;
+}
+
+export interface PriceServiceClient<CallOptionsExt = {}> {
+  getPrice(
+    request: DeepPartial<GetPriceRequest>,
+    options?: CallOptions & CallOptionsExt
+  ): Promise<GetPriceResponse>;
+}
+
+type Builtin =
+  | Date
+  | Function
+  | Uint8Array
+  | string
+  | number
+  | boolean
+  | undefined;
+
+type DeepPartial<T> = T extends Builtin
+  ? T
+  : T extends Long
+  ? string | number | Long
+  : T extends Array<infer U>
+  ? Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U>
+  ? ReadonlyArray<DeepPartial<U>>
+  : T extends {}
+  ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+function toTimestamp(date: Date): Timestamp {
+  const seconds = numberToLong(date.getTime() / 1_000);
+  const nanos = (date.getTime() % 1_000) * 1_000_000;
+  return { seconds, nanos };
+}
+
+function fromTimestamp(t: Timestamp): Date {
+  let millis = t.seconds.toNumber() * 1_000;
+  millis += t.nanos / 1_000_000;
+  return new Date(millis);
+}
+
+function fromJsonTimestamp(o: any): Date {
+  if (o instanceof Date) {
+    return o;
+  } else if (typeof o === "string") {
+    return new Date(o);
+  } else {
+    return fromTimestamp(Timestamp.fromJSON(o));
+  }
+}
+
+function numberToLong(number: number) {
+  return Long.fromNumber(number);
+}
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/src/processor-runner.ts

@@ -11,8 +11,10 @@ import fs from 'fs-extra'
 import { ProcessorState } from './processor-state'
 import { load } from './loader'
 import { CompressionAlgorithms } from '@grpc/grpc-js/build/src/compression-algorithms'
+import { Endpoints } from './endpoints'
 
 global.PROCESSOR_STATE = new ProcessorState()
+global.ENDPOINTS = new Endpoints()
 
 const optionDefinitions = [
   { name: 'target', type: String, defaultOption: true },
@@ -25,6 +27,8 @@ const optionDefinitions = [
     type: String,
     defaultValue: 'chains-config.json',
   },
+  { name: 'chainquery-server', type: String, defaultValue: '' },
+  { name: 'pricefeed-server', type: String, defaultValue: '' },
 ]
 
 const options = commandLineArgs(optionDefinitions, { partial: true })
@@ -35,6 +39,8 @@ const fullPath = path.resolve(options['chains-config'])
 const chainsConfig = fs.readJsonSync(fullPath)
 
 setProvider(chainsConfig, options.concurrency, options['use-chainserver'])
+globalThis.ENDPOINTS.chainQueryAPI = options['chainquery-server']
+globalThis.ENDPOINTS.priceFeedAPI = options['pricefeed-server']
 
 console.log('Start Server', options)
 

package/src/processor-state.ts

@@ -5,17 +5,14 @@ import {
   BaseProcessorTemplate,
   SolanaBaseProcessor,
   SuiBaseProcessor,
+  EventTracker,
 } from './core'
 
-import { AptosBaseProcessor } from './aptos'
-
 import { BaseContract } from 'ethers'
 import { TemplateInstance } from './gen'
-import { Provider } from '@ethersproject/providers'
-import { EventTracker } from './core'
 import { Metric } from './core/meter'
-import { AptosAccountProcessor } from './aptos/aptos-processor'
 import { Exporter } from './core/exporter'
+import { AptosBaseProcessor, AptosAccountProcessor } from './aptos/aptos-processor'
 
 export class ProcessorState {
   // from abiName_address_chainId => contract wrapper
@@ -24,8 +21,6 @@ export class ProcessorState {
   processors: BaseProcessor<BaseContract, BoundContractView<BaseContract, any>>[] = []
   // from abiName_options to contracts
   processorMap = new Map<string, BaseProcessor<any, any>>()
-  // evm providers
-  providers = new Map<number, Provider>()
   // evm processor templates
   templates: BaseProcessorTemplate<BaseContract, BoundContractView<BaseContract, any>>[] = []
   // evm processor template instances spec

package/src/provider.ts

@@ -12,23 +12,23 @@ export function getProvider(networkish?: Networkish): Provider {
   }
   const network = getNetwork(networkish)
 
-  if (!global.PROCESSOR_STATE.providers) {
+  if (!global.ENDPOINTS.providers) {
     throw Error('Provider not set')
   }
-  const value = global.PROCESSOR_STATE.providers.get(network.chainId)
+  const value = global.ENDPOINTS.providers.get(network.chainId)
   if (value === undefined) {
     throw Error(
       'Provider not found for chain ' +
         network.chainId +
         ', configured chains: ' +
-        [...global.PROCESSOR_STATE.providers.keys()].join(' ')
+        [...global.ENDPOINTS.providers.keys()].join(' ')
     )
   }
   return value
 }
 
 export function setProvider(config: Record<string, ChainConfig>, concurrency = 4, useChainServer = false) {
-  global.PROCESSOR_STATE.providers = new Map<number, Provider>()
+  globalThis.ENDPOINTS.providers = new Map<number, Provider>()
 
   for (const chainIdStr in config) {
     if (isNaN(Number.parseInt(chainIdStr))) {
@@ -56,7 +56,7 @@ export function setProvider(config: Record<string, ChainConfig>, concurrency = 4
     }
 
     const provider = new QueuedStaticJsonRpcProvider(rpcAddress, chainId, concurrency)
-    global.PROCESSOR_STATE.providers.set(chainId, provider)
+    global.ENDPOINTS.providers.set(chainId, provider)
   }
 }
 

package/src/testing/test-processor-server.ts

@@ -9,14 +9,10 @@ import {
   ProcessConfigRequest,
   ProcessConfigResponse,
   ProcessInstructionsRequest,
-  ProcessorServiceImpl,
   ProcessorServiceImplementation,
-  ProcessorState,
   ProcessTransactionsRequest,
-  setProvider,
   StartRequest,
-  Trace,
-} from '@sentio/sdk'
+} from '../gen'
 import { CallContext } from 'nice-grpc-common'
 import { Empty } from '../gen/google/protobuf/empty'
 import { ChainConfig } from '../chain-config'
@@ -24,11 +20,19 @@ import { CHAIN_MAP } from '../utils/chain'
 import { Block, Log } from '@ethersproject/abstract-provider'
 import Long from 'long'
 import { getNetwork, Networkish } from '@ethersproject/providers'
+import { Endpoints } from '../endpoints'
+import { ProcessorState } from '../processor-state'
+import { ProcessorServiceImpl } from '../service'
+import { Trace } from '../core/trace'
+import { setProvider } from '../provider'
 
 export const TEST_CONTEXT: CallContext = <CallContext>{}
 
-function cleanTest() {
+export function cleanTest() {
   global.PROCESSOR_STATE = new ProcessorState()
+  if (!global.ENDPOINTS) {
+    global.ENDPOINTS = new Endpoints()
+  }
 }
 
 export class TestProcessorServer implements ProcessorServiceImplementation {

package/src/utils/conversion.ts

@@ -1,6 +1,7 @@
 import { BigNumber } from 'ethers'
-import { BigDecimal, MetricValue } from '@sentio/sdk'
+import { BigDecimal } from '../core/big-decimal'
 import { Numberish } from '../core'
+import { MetricValue } from '../gen'
 
 export function toBigDecimal(n: BigNumber | bigint) {
   return new BigDecimal(n.toString())

package/src/utils/price.ts

@@ -0,0 +1,58 @@
+import { PriceServiceClient, PriceServiceDefinition } from '../gen/service/price/protos/price'
+import { createChannel, createClient } from 'nice-grpc'
+
+export function getPriceClient(address?: string): PriceServiceClient {
+  if (!address) {
+    address = global.ENDPOINTS.priceFeedAPI
+  }
+  const channel = createChannel(address)
+
+  return createClient(PriceServiceDefinition, channel)
+}
+
+const priceMap = new Map<string, number>()
+let priceClient: PriceServiceClient
+
+/**
+ *
+ * @param chainId chain id refers to CHAIN_MAP
+ * @param coinType
+ * @param date
+ */
+export async function getPriceByType(chainId: string, coinType: string, date: Date): Promise<number> {
+  if (!priceClient) {
+    priceClient = getPriceClient()
+  }
+
+  const dateStr = [date.getUTCDate(), date.getUTCMonth() + 1, date.getUTCFullYear()].join('-')
+  const key = `${coinType}-${dateStr}`
+  const price = priceMap.get(key)
+  if (price) {
+    return price
+  }
+
+  /*eslint no-constant-condition: ["error", { "checkLoops": false }]*/
+  while (true) {
+    try {
+      const response = await priceClient.getPrice({
+        timestamp: date,
+        coinId: {
+          address: {
+            chain: chainId,
+            address: coinType,
+          },
+        },
+      })
+      const price = response.price
+      priceMap.set(key, price)
+      return price
+    } catch (e) {
+      console.log('error getting price', e, dateStr, coinType)
+      await delay(1000)
+    }
+  }
+}
+
+export function delay(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}

package/src/utils/token.ts

@@ -3,7 +3,7 @@ import { BigNumber } from '@ethersproject/bignumber'
 import { transformEtherError } from '../error'
 import { getERC20Contract } from '../builtin/erc20'
 import { getERC20BytesContract } from '../builtin/internal/erc20bytes_processor'
-import { BigDecimal } from '@sentio/sdk'
+import { BigDecimal } from '../core/big-decimal'
 import { toBigDecimal } from './conversion'
 import { utils } from 'ethers'