@sentio/sdk 1.7.12 → 1.7.15

package/src/cli/cli.ts

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+import commandLineArgs from 'command-line-args'
+import commandLineUsage from 'command-line-usage'
+import fs from 'fs'
+import https from 'https'
+import http from 'http'
+import path from 'path'
+
+import yaml from 'js-yaml'
+import { EVM, FinalizeHost, FinalizeProjectName, SentioProjectConfig } from './config'
+import { WriteKey } from './key'
+import { uploadFile } from './upload'
+import chalk from 'chalk'
+import { buildProcessor } from './build'
+
+const mainDefinitions = [{ name: 'command', defaultOption: true }]
+const mainOptions = commandLineArgs(mainDefinitions, {
+  stopAtFirstUnknown: true,
+})
+const argv = mainOptions._unknown || []
+
+// Process configs
+let processorConfig: SentioProjectConfig = { host: '', project: '', source: '', build: true, targets: [] }
+// Fist step, read from project yaml file
+try {
+  console.log(chalk.blue('Loading Process config'))
+  // TODO correctly located sentio.yaml
+  const pwd = process.cwd()
+  const packageJson = path.join(pwd, 'package.json')
+  if (!fs.existsSync(packageJson)) {
+    console.error('package.json not found, please run this command in the root of your project')
+    process.exit(1)
+  }
+
+  const yamlPath = path.join(pwd, 'sentio.yaml')
+  if (!fs.existsSync(yamlPath)) {
+    console.error('sentio.yaml not found, please create one according to: TODO docs')
+    process.exit(1)
+  }
+
+  processorConfig = yaml.load(fs.readFileSync('sentio.yaml', 'utf8')) as SentioProjectConfig
+  if (!processorConfig.project === undefined) {
+    console.error('Config yaml must have contain a valid project identifier')
+    process.exit(1)
+  }
+  if (processorConfig.build === undefined) {
+    processorConfig.build = true
+  }
+  if (!processorConfig.host) {
+    processorConfig.host = 'prod'
+  }
+
+  if (!processorConfig.source) {
+    processorConfig.source = 'src/processor.ts'
+  }
+  if (!processorConfig.targets) {
+    console.warn('targets is not defined, use EVM as the default target')
+    processorConfig.targets = []
+  }
+  if (processorConfig.targets.length === 0) {
+    // By default evm
+    processorConfig.targets.push({ chain: EVM })
+  }
+} catch (e) {
+  console.error(e)
+  process.exit(1)
+}
+
+if (mainOptions.command === 'upload') {
+  const optionDefinitions = [
+    {
+      name: 'help',
+      alias: 'h',
+      type: Boolean,
+      description: 'Display this usage guide.',
+    },
+    {
+      name: 'api-key',
+      type: String,
+      description: '(Optional) Manually provide API key rather than use saved credential',
+    },
+    {
+      name: 'host',
+      description: '(Optional) Override Sentio Host name',
+      type: String,
+    },
+    {
+      name: 'owner',
+      description: '(Optional) Override Project owner',
+      type: String,
+    },
+    {
+      name: 'nobuild',
+      description: '(Optional) Skip build & pack file before uploading, default false',
+      type: Boolean,
+    },
+  ]
+  const options = commandLineArgs(optionDefinitions, { argv })
+  if (options.help) {
+    const usage = commandLineUsage([
+      {
+        header: 'Sentio upload',
+        content: 'Upload your project files to Sentio.',
+      },
+      {
+        header: 'Options',
+        optionList: optionDefinitions,
+      },
+    ])
+    console.log(usage)
+  } else {
+    if (options.host) {
+      processorConfig.host = options.host
+    }
+    if (options.nobuild) {
+      processorConfig.build = false
+    }
+    FinalizeHost(processorConfig)
+    FinalizeProjectName(processorConfig, options.owner)
+    console.log(processorConfig)
+
+    let apiOverride = undefined
+    if (options['api-key']) {
+      apiOverride = options['api-key']
+    }
+    uploadFile(processorConfig, apiOverride)
+  }
+} else if (mainOptions.command === 'login') {
+  const optionDefinitions = [
+    {
+      name: 'help',
+      alias: 'h',
+      type: Boolean,
+      description: 'Display this usage guide.',
+    },
+    {
+      name: 'api-key',
+      type: String,
+      description: '(Required) Your API key',
+    },
+    {
+      name: 'host',
+      description: '(Optional) Override Sentio Host name',
+      type: String,
+    },
+  ]
+  const options = commandLineArgs(optionDefinitions, { argv })
+
+  if (options.help || !options['api-key']) {
+    const usage = commandLineUsage([
+      {
+        header: 'Sentio login',
+        content: 'Try login to Sentio with your apikey.',
+      },
+      {
+        header: 'Options',
+        optionList: optionDefinitions,
+      },
+    ])
+    console.log(usage)
+  } else {
+    if (options.host) {
+      processorConfig.host = options.host
+    }
+    FinalizeHost(processorConfig)
+    console.log(processorConfig)
+
+    const url = new URL(processorConfig.host)
+    const reqOptions = {
+      hostname: url.hostname,
+      port: url.port,
+      path: '/api/v1/processors/check_key',
+      method: 'HEAD',
+      headers: {
+        'api-key': options['api-key'],
+      },
+    }
+    const h = url.protocol == 'https:' ? https : http
+    const req = h.request(reqOptions, (res) => {
+      if (res.statusCode == 200) {
+        WriteKey(processorConfig.host, options['api-key'])
+        console.log(chalk.green('login success'))
+      } else {
+        console.error(chalk.red('login failed, code:', res.statusCode, res.statusMessage))
+      }
+    })
+
+    req.on('error', (error) => {
+      console.error(error)
+    })
+
+    req.end()
+  }
+} else if (mainOptions.command === 'build') {
+  buildProcessor(false, processorConfig.targets)
+} else if (mainOptions.command === 'gen') {
+  buildProcessor(true, processorConfig.targets)
+} else {
+  const usage = commandLineUsage([
+    {
+      header: 'Sentio',
+      content: 'Login & Upload your project files to Sentio.',
+    },
+    {
+      header: 'Usage',
+      content: [
+        'sentio $command --help\t\tshow detail usage of specific command',
+        'sentio login --api-key=xx\t\tsave credential to local',
+        'sentio upload\t\t\t\tbuild and upload processor to sentio',
+        'sentio gen\t\t\t\tgenerate abi',
+        'sentio build\t\t\t\tgenerate abi and build',
+      ],
+    },
+  ])
+  console.log(usage)
+}

package/src/cli/config.ts

@@ -0,0 +1,43 @@
+export interface SentioProjectConfig {
+  project: string
+  host: string
+  source: string
+  build: boolean
+  targets: Target[]
+}
+
+export function FinalizeHost(config: SentioProjectConfig) {
+  switch (config.host) {
+    case '':
+    case 'prod':
+      config.host = 'https://app.sentio.xyz'
+      break
+    case 'test':
+      config.host = 'https://test.sentio.xyz'
+      break
+    case 'staging':
+      config.host = 'https://staging.sentio.xyz'
+      break
+    case 'local':
+      config.host = 'http://localhost:10000'
+  }
+}
+
+export function FinalizeProjectName(config: SentioProjectConfig, owner: string | undefined) {
+  if (owner) {
+    let name = config.project
+    if (name.includes('/')) {
+      name = config.project.split('/')[1]
+    }
+    config.project = [owner, name].join('/')
+  }
+}
+
+export interface Target {
+  chain: string
+  abisDir?: string
+}
+
+// Supported target chain, lower case
+export const EVM = 'evm'
+export const SOLANA = 'solana'

package/src/cli/key.ts

@@ -0,0 +1,43 @@
+import path from 'path'
+import fs from 'fs'
+import os from 'os'
+
+const homeDir = os.homedir()
+const sentioDir = path.join(homeDir, '.sentio')
+const configFile = path.join(sentioDir, 'config.json')
+
+interface SentioKeyConfig {
+  [key: string]: {
+    api_keys: string
+  }
+}
+
+export function WriteKey(host: string, api_key: string) {
+  const sentioDir = path.join(homeDir, '.sentio')
+  if (!fs.existsSync(sentioDir)) {
+    fs.mkdirSync(sentioDir, { recursive: true })
+  }
+  let config: SentioKeyConfig = {}
+  if (fs.existsSync(configFile)) {
+    const content = fs.readFileSync(configFile, 'utf8')
+    config = JSON.parse(content)
+  }
+  const hostConfig = config[host] || { api_keys: {} }
+  hostConfig.api_keys = api_key
+  config[host] = hostConfig
+  fs.writeFileSync(configFile, JSON.stringify(config, null, 2))
+}
+
+export function ReadKey(host: string): string | undefined {
+  if (!fs.existsSync(sentioDir)) {
+    return undefined
+  }
+  const configFile = path.join(sentioDir, 'config.json')
+  if (fs.existsSync(configFile)) {
+    const content = fs.readFileSync(configFile, 'utf8')
+    const config = JSON.parse(content)
+    return config[host]?.api_keys
+  } else {
+    return undefined
+  }
+}

package/src/cli/solana-code-gen.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+import { codeGenSolanaProcessor } from './build'
+
+const abisDir = 'abis/solana'
+if (process.argv.length > 2) {
+  const rootPath = process.argv[2]
+  if (process.argv.length > 3) {
+    const targetPath = process.argv[3]
+    codeGenSolanaProcessor(abisDir, rootPath, targetPath)
+  } else {
+    codeGenSolanaProcessor(abisDir, rootPath)
+  }
+} else {
+  codeGenSolanaProcessor(abisDir)
+}

package/src/cli/upload.ts

@@ -0,0 +1,86 @@
+import { execSync } from 'child_process'
+import { createHash } from 'crypto'
+import FormData from 'form-data'
+import fs from 'fs'
+import { SentioProjectConfig } from './config'
+import { ReadKey } from './key'
+import path from 'path'
+import chalk from 'chalk'
+import { buildProcessor } from './build'
+import fetch from 'node-fetch'
+
+export async function uploadFile(options: SentioProjectConfig, apiKeyOverride: string) {
+  if (options.build) {
+    await buildProcessor(false, options.targets)
+  }
+
+  console.log(chalk.blue('Uploading'))
+
+  const PROCESSOR_FILE = path.join(process.cwd(), 'dist/lib.js')
+
+  const url = new URL(options.host)
+  const apiKey = apiKeyOverride || ReadKey(options.host)
+
+  const isProd = options.host === 'https://app.sentio.xyz'
+  if (!apiKey) {
+    const cmd = isProd ? 'sentio login' : 'sentio login --host=' + options.host
+    console.error(chalk.red('No Credential found for', options.host, '. Please run `' + cmd + '`.'))
+    process.exit(1)
+  }
+
+  if (!fs.existsSync(PROCESSOR_FILE)) {
+    console.error(chalk.red('File not existed ', PROCESSOR_FILE, "don't use --nobuild"))
+    process.exit(1)
+  }
+
+  const stat = fs.statSync(PROCESSOR_FILE)
+  console.log('Packed processor file size', Math.floor(stat.size / 1024) + 'K, last modified', stat.mtime)
+  const content = fs.readFileSync(PROCESSOR_FILE)
+  const hash = createHash('sha256')
+  hash.update(content)
+  const digest = hash.digest('hex')
+
+  const data = new FormData()
+  data.append('attachment', fs.createReadStream(PROCESSOR_FILE))
+  data.append('sha256', digest)
+
+  let commitSha
+  try {
+    commitSha = execSync('git rev-parse HEAD').toString().trim()
+    data.append('commitSha', commitSha)
+  } catch (e) {
+    chalk.yellow(e)
+  }
+
+  url.pathname = '/api/v1/processors'
+
+  let packageJson: { version: string }
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    packageJson = require('../package.json')
+  } catch (e) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    packageJson = require('../../package.json')
+  }
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'api-key': apiKey,
+      project: options.project,
+      version: packageJson.version,
+    },
+    body: data,
+  })
+
+  if (res.ok) {
+    console.log(chalk.green('Upload success: '))
+    console.log('\t', chalk.blue('sha256:'), digest)
+    if (commitSha) {
+      console.log('\t', chalk.blue('Git commit SHA:'), commitSha)
+    }
+  } else {
+    console.error(chalk.red('Upload Failed'))
+    console.error(chalk.red(await res.text()))
+  }
+}

package/src/cli/webpack.config.js

@@ -0,0 +1,42 @@
+/* eslint-disable */
+const path = require('path')
+
+module.exports = {
+  entry: {
+    lib: './src/processor.ts',
+  },
+  devtool: 'inline-source-map',
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: 'ts-loader',
+        exclude: /node_modules/,
+      },
+    ],
+  },
+  resolve: {
+    extensions: ['.ts', '.js'],
+  },
+  output: {
+    filename: '[name].js',
+    path: path.resolve(process.cwd(), 'dist'),
+  },
+  target: 'node',
+  mode: 'production',
+  externals: [
+    {
+      ethers: 'commonjs2 ethers',
+      '@sentio/sdk': 'root sentio_sdk',
+      bs58: 'commonjs2 bs58',
+      "bignumber.js": 'commonjs2 bignumber.js',
+      'bn.js': 'commonjs2 bn.js',
+    },
+    function ({ context, request }, callback) {
+      if (/^@(ethersproject|solana|project-serum).*$/.test(request)) {
+        return callback(null, 'commonjs ' + request)
+      }
+      callback()
+    },
+  ],
+}

package/src/context.ts

@@ -0,0 +1,93 @@
+import { CounterResult, GaugeResult } from './gen/processor/protos/processor'
+import { BaseContract, EventFilter } from 'ethers'
+import { Block, Log } from '@ethersproject/abstract-provider'
+import { Meter } from './meter'
+import Long from 'long'
+
+export class EthContext {
+  chainId: number
+  log?: Log
+  block?: Block
+  blockNumber: Long
+  gauges: GaugeResult[] = []
+  counters: CounterResult[] = []
+  meter: Meter
+
+  constructor(chainId: number, block?: Block, log?: Log) {
+    this.chainId = chainId
+    this.log = log
+    this.block = block
+    if (log) {
+      this.blockNumber = Long.fromNumber(log.blockNumber)
+    } else if (block) {
+      this.blockNumber = Long.fromNumber(block.number)
+    }
+    this.meter = new Meter(this)
+  }
+}
+
+export class Context<
+  TContract extends BaseContract,
+  TContractBoundView extends BoundContractView<TContract, ContractView<TContract>>
+> extends EthContext {
+  contract: TContractBoundView
+
+  constructor(view: TContractBoundView, chainId: number, block?: Block, log?: Log) {
+    super(chainId, block, log)
+    view.context = this
+    this.contract = view
+  }
+}
+
+export class ContractView<TContract extends BaseContract> {
+  filters: { [name: string]: (...args: Array<any>) => EventFilter }
+  protected contract: TContract
+
+  constructor(contract: TContract) {
+    this.contract = contract
+    this.filters = contract.filters
+  }
+
+  get rawContract() {
+    return this.contract
+  }
+
+  get provider() {
+    return this.contract.provider
+  }
+}
+
+export class BoundContractView<TContract extends BaseContract, TContractView extends ContractView<TContract>> {
+  protected view: TContractView
+  // context will be set right after context creation (in context's constructor)
+  context: Context<TContract, BoundContractView<TContract, TContractView>>
+
+  constructor(view: TContractView) {
+    this.view = view
+  }
+
+  get rawContract() {
+    return this.view.rawContract
+  }
+
+  get provider() {
+    return this.view.provider
+  }
+
+  get filters() {
+    return this.view.filters
+  }
+}
+
+export class SolanaContext {
+  gauges: GaugeResult[] = []
+  counters: CounterResult[] = []
+  meter: Meter
+
+  address: string
+
+  constructor(address: string) {
+    this.meter = new Meter(this)
+    this.address = address
+  }
+}

package/src/contract-namer.ts

@@ -0,0 +1,17 @@
+export class ContractNamer {
+  defaultName: string
+  counter: number
+
+  constructor(defaultName: string) {
+    this.defaultName = defaultName
+    this.counter = 0
+  }
+
+  public nextName(): string {
+    const id = this.counter++
+    if (id > 0) {
+      return this.defaultName + '_' + id
+    }
+    return this.defaultName
+  }
+}

package/src/error.ts

@@ -0,0 +1,43 @@
+// Transform error in more readable format
+import { Context } from './context'
+import { errors } from 'ethers'
+
+class EthersError extends Error {
+  constructor(message: string, stack?: string) {
+    super(message)
+    this.stack = stack
+  }
+
+  toString() {
+    return this.message + '\n' + this.stack?.toString()
+  }
+}
+
+export function transformEtherError(e: Error, ctx: Context<any, any> | undefined): Error {
+  let msg = ''
+  // @ts-ignore expected error fields
+  if (e.code === errors.CALL_EXCEPTION) {
+    // @ts-ignore expected error fields
+    if (e.data === '0x') {
+      if (ctx) {
+        msg =
+          "jsonrpc eth_call return '0x' (likely contract not existed) at chain " +
+          ctx.chainId +
+          ': ' +
+          JSON.stringify(e)
+      } else {
+        msg = "jsonrpc eth_call return '0x' (likely contract not existed): " + JSON.stringify(e)
+      }
+    }
+    return new EthersError(msg, e.stack)
+  }
+
+  if (e instanceof EthersError) {
+    return e
+  }
+
+  // TODO gracefully handle more errors
+
+  msg = 'ethers call error\n' + e.message + '\n' + e.stack?.toString()
+  return new Error(msg)
+}

package/src/gen/builtin.ts

@@ -0,0 +1,22 @@
+import Long from 'long'
+
+type Builtin =
+  | Date
+  | Function
+  | Uint8Array
+  | string
+  | number
+  | boolean
+  | undefined;
+
+export 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>;

package/src/gen/google/protobuf/empty.ts

@@ -0,0 +1,70 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+
+export interface Empty {}
+
+function createBaseEmpty(): Empty {
+  return {};
+}
+
+export const Empty = {
+  encode(_: Empty, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Empty {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEmpty();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(_: any): Empty {
+    return {};
+  },
+
+  toJSON(_: Empty): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  fromPartial(_: DeepPartial<Empty>): Empty {
+    const message = createBaseEmpty();
+    return message;
+  },
+};
+
+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>;
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}