@sentio/sdk 1.0.0-development → 1.0.0-rc.2

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

@@ -0,0 +1,329 @@
+/* eslint-disable */
+import Long from "long";
+import type { CallContext, CallOptions } from "nice-grpc-common";
+import _m0 from "protobufjs/minimal";
+import { Timestamp } from "../../../google/protobuf/timestamp";
+
+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 PriceServiceImplementation<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/index.ts

@@ -0,0 +1,13 @@
+// export { ProcessorServiceImpl } from './service'
+export { getProvider, setProvider, DummyProvider } from './provider'
+export { transformEtherError } from './error'
+// export { ProcessorState } from './state/processor-state'
+export { EthersError } from './error'
+
+export { getProcessor, addProcessor, getContractByABI, addContractByABI } from './binds'
+
+export * from './gen'
+
+export * from './core'
+
+export * as aptos from './aptos'

package/src/loader.ts

@@ -0,0 +1,24 @@
+export function load(name: string): { module: any; name: string; path: string } | undefined {
+  const req = eval('require')
+
+  try {
+    let path: string
+    try {
+      path = req.resolve(name, { paths: [process.cwd()] })
+    } catch {
+      path = req.resolve(name)
+    }
+
+    const module = { module: req(path), name, path }
+    console.log('Processor Load successfully')
+    return module
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith(`Cannot find module '${name}'`)) {
+      // this error is expected
+      console.log("Couldn't load (expected): ", name)
+      return undefined
+    } else {
+      throw err
+    }
+  }
+}

package/src/plugin.ts

@@ -0,0 +1,41 @@
+import { DataBinding, HandlerType, ProcessConfigResponse, ProcessResult } from './gen'
+
+export interface Plugin {
+  name: string
+  supportedHandlers: HandlerType[]
+
+  configure(config: ProcessConfigResponse): void
+  processBinding(request: DataBinding): Promise<ProcessResult>
+}
+
+export class PluginManager {
+  static INSTANCE = new PluginManager()
+
+  plugins: Plugin[] = []
+  typesToPlugin = new Map<HandlerType, Plugin>()
+
+  register(plugin: Plugin) {
+    this.plugins.push(plugin)
+    // for (const plugin of this.plugins) {
+    for (const handlerType of plugin.supportedHandlers) {
+      const exsited = this.typesToPlugin.get(handlerType)
+      if (exsited) {
+        throw new Error(`Duplicate plugin for ${handlerType}: ${exsited.name} and ${plugin.name}`)
+      }
+      this.typesToPlugin.set(handlerType, plugin)
+    }
+    // }
+  }
+
+  configure(config: ProcessConfigResponse) {
+    this.plugins.forEach((plugin) => plugin.configure(config))
+  }
+
+  processBinding(request: DataBinding): Promise<ProcessResult> {
+    const plugin = this.typesToPlugin.get(request.handlerType)
+    if (!plugin) {
+      throw new Error(`No plugin for ${request.handlerType}`)
+    }
+    return plugin.processBinding(request)
+  }
+}

package/src/processor-runner.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+import path from 'path'
+import fs from 'fs-extra'
+import * as util from 'util'
+
+import commandLineArgs from 'command-line-args'
+import { createServer } from 'nice-grpc'
+import { createLogger, transports, format } from 'winston'
+import { CompressionAlgorithms } from '@grpc/grpc-js/build/src/compression-algorithms'
+
+import { ProcessorDefinition } from './gen'
+import { ProcessorServiceImpl } from './service'
+import { setProvider } from './provider'
+import { ProcessorState } from './state/processor-state'
+import { load } from './loader'
+import { Endpoints } from './endpoints'
+
+global.PROCESSOR_STATE = new ProcessorState()
+global.ENDPOINTS = new Endpoints()
+
+const optionDefinitions = [
+  { name: 'target', type: String, defaultOption: true },
+  { name: 'port', alias: 'p', type: String, defaultValue: '4000' },
+  { name: 'concurrency', type: Number, defaultValue: 4 },
+  { name: 'use-chainserver', type: Boolean, defaultValue: false },
+  {
+    name: 'chains-config',
+    alias: 'c',
+    type: String,
+    defaultValue: 'chains-config.json',
+  },
+  { name: 'chainquery-server', type: String, defaultValue: '' },
+  { name: 'pricefeed-server', type: String, defaultValue: '' },
+  { name: 'log-format', type: String, defaultValue: 'console' },
+  { name: 'debug', type: Boolean, defaultValue: false },
+]
+
+const options = commandLineArgs(optionDefinitions, { partial: true })
+
+if (options['log-format'] === 'json') {
+  const utilFormatter = {
+    transform: (info: any) => {
+      const args = info[Symbol.for('splat')]
+      if (args) {
+        info.message = util.format(info.message, ...args)
+      }
+      return info
+    },
+  }
+  const logger = createLogger({
+    format: format.combine(
+      format.timestamp({ format: 'YYYY-MM-DDTHH:mm:ssZ' }),
+      utilFormatter,
+      format.errors({ stack: true }),
+      format.json()
+    ),
+    transports: [new transports.Console()],
+  })
+
+  console.log = (...args) => logger.info.call(logger, ...args)
+  console.info = (...args) => logger.info.call(logger, ...args)
+  console.warn = (...args) => logger.warn.call(logger, ...args)
+  console.error = (...args) => logger.error.call(logger, ...args)
+  console.debug = (...args) => logger.debug.call(logger, ...args)
+}
+if (options.debug) {
+  console.log('Starting with', options.target)
+}
+
+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']
+
+if (options.debug) {
+  console.log('Starting Server', options)
+}
+
+const server = createServer({
+  'grpc.max_send_message_length': 128 * 1024 * 1024,
+  'grpc.max_receive_message_length': 128 * 1024 * 1024,
+  'grpc.default_compression_algorithm': CompressionAlgorithms.gzip,
+})
+
+const service = new ProcessorServiceImpl(() => load(options.target), server.shutdown)
+server.add(ProcessorDefinition, service)
+
+server.listen('0.0.0.0:' + options.port)
+
+console.log('Processor Server Started')

package/src/promise-or-void.ts

@@ -0,0 +1 @@
+export type PromiseOrVoid = void | Promise<any>

package/src/provider.ts

@@ -0,0 +1,74 @@
+import { getNetwork, Provider, StaticJsonRpcProvider } from '@ethersproject/providers'
+import { Networkish } from '@ethersproject/networks'
+import PQueue from 'p-queue'
+import { ConnectionInfo } from '@ethersproject/web'
+import { ChainConfig } from './chain-config'
+
+export const DummyProvider = new StaticJsonRpcProvider(undefined, 1)
+
+export function getProvider(networkish?: Networkish): Provider {
+  if (!networkish) {
+    networkish = 1
+  }
+  const network = getNetwork(networkish)
+
+  if (!global.ENDPOINTS.providers) {
+    throw Error('Provider not set')
+  }
+  const value = global.ENDPOINTS.providers.get(network.chainId)
+  if (value === undefined) {
+    throw Error(
+      'Provider not found for chain ' +
+        network.chainId +
+        ', configured chains: ' +
+        [...global.ENDPOINTS.providers.keys()].join(' ')
+    )
+  }
+  return value
+}
+
+export function setProvider(config: Record<string, ChainConfig>, concurrency = 4, useChainServer = false) {
+  globalThis.ENDPOINTS.providers = new Map<number, Provider>()
+
+  for (const chainIdStr in config) {
+    if (isNaN(Number.parseInt(chainIdStr))) {
+      continue
+    }
+
+    const chainConfig = config[chainIdStr]
+    const chainId = Number(chainIdStr)
+
+    // let providers: StaticJsonRpcProvider[] = []
+    // for (const http of chainConfig.Https) {
+    //   providers.push(new StaticJsonRpcProvider(http, chainId))
+    // }
+    // random shuffle
+    // providers = providers.sort(() => Math.random() - 0.5)
+
+    // const provider = new FallbackProvider(providers)
+
+    let rpcAddress = ''
+    if (useChainServer && chainConfig.ChainServer) {
+      rpcAddress = chainConfig.ChainServer
+    } else {
+      const idx = Math.floor(Math.random() * chainConfig.Https.length)
+      rpcAddress = chainConfig.Https[idx]
+    }
+
+    const provider = new QueuedStaticJsonRpcProvider(rpcAddress, chainId, concurrency)
+    global.ENDPOINTS.providers.set(chainId, provider)
+  }
+}
+
+class QueuedStaticJsonRpcProvider extends StaticJsonRpcProvider {
+  executor: PQueue
+
+  constructor(url: ConnectionInfo | string, network: Networkish, concurrency: number) {
+    super(url, network)
+    this.executor = new PQueue({ concurrency: concurrency })
+  }
+
+  send(method: string, params: Array<any>): Promise<any> {
+    return this.executor.add(() => super.send(method, params))
+  }
+}