@sentio/sdk 1.7.14 → 1.7.17

package/src/builtin/weth9/test-utils.ts

@@ -0,0 +1,89 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import { Log } from "@ethersproject/providers";
+import {
+  getWeth9Contract,
+  ApprovalEventObject,
+  TransferEventObject,
+  DepositEventObject,
+  WithdrawalEventObject,
+} from ".";
+const mockField = {
+  blockHash:
+    "0x0000000000000000000000000000000000000000000000000000000000000000",
+  blockNumber: 0,
+  logIndex: 0,
+  removed: false,
+  transactionHash:
+    "0x0000000000000000000000000000000000000000000000000000000000000000",
+  transactionIndex: 0,
+};
+
+export function mockApprovalLog(
+  contractAddress: string,
+  event: ApprovalEventObject
+): Log {
+  const contract = getWeth9Contract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    contract.rawContract.interface.getEvent("Approval"),
+    Object.values(event)
+  );
+  return {
+    ...mockField,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockTransferLog(
+  contractAddress: string,
+  event: TransferEventObject
+): Log {
+  const contract = getWeth9Contract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    contract.rawContract.interface.getEvent("Transfer"),
+    Object.values(event)
+  );
+  return {
+    ...mockField,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockDepositLog(
+  contractAddress: string,
+  event: DepositEventObject
+): Log {
+  const contract = getWeth9Contract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    contract.rawContract.interface.getEvent("Deposit"),
+    Object.values(event)
+  );
+  return {
+    ...mockField,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockWithdrawalLog(
+  contractAddress: string,
+  event: WithdrawalEventObject
+): Log {
+  const contract = getWeth9Contract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    contract.rawContract.interface.getEvent("Withdrawal"),
+    Object.values(event)
+  );
+  return {
+    ...mockField,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}

package/src/chain-config.ts

@@ -0,0 +1,6 @@
+export interface ChainConfig {
+  ChainID: string
+  Https: string[]
+  WebSockets?: string[]
+  ChainServer?: string
+}

package/src/cli/build.ts

@@ -0,0 +1,196 @@
+import chalk from 'chalk'
+import path from 'path'
+import fs from 'fs'
+import { exec } from 'child_process'
+import { EVM, SOLANA, Target } from './config'
+
+export async function buildProcessor(onlyGen: boolean, targets: Target[]) {
+  if (!onlyGen) {
+    await installDeps()
+  }
+
+  // targets.forEach(async (target) => await buildProcessorForTarget(onlyGen, target))
+  for (const target of targets) {
+    await buildProcessorForTarget(onlyGen, target)
+  }
+
+  if (!onlyGen) {
+    const WEBPACK_CONFIG = path.join(__dirname, 'webpack.config.js')
+    await execStep('yarn tsc -p .', 'Compile')
+    await execStep('yarn webpack --config=' + WEBPACK_CONFIG, 'Packaging')
+  }
+}
+
+async function buildProcessorForTarget(onlyGen: boolean, target: Target) {
+  if (target.chain === EVM) {
+    await codeGenEthersProcessor(target.abisDir ?? path.join('abis', 'evm'))
+  } else if (target.chain === SOLANA) {
+    codeGenSolanaProcessor(target.abisDir ?? path.join('abis', 'solana'))
+  }
+
+  if (onlyGen) {
+    return
+  }
+}
+
+async function installDeps() {
+  await execStep('yarn install --ignore-scripts', 'Yarn Install')
+}
+
+export async function codeGenEthersProcessor(
+  abisDir: string,
+  ETHERS_TARGET = path.join(__dirname, '../target-ethers-sentio'),
+  outDir = 'src/types/internal'
+) {
+  if (!fs.existsSync(abisDir)) {
+    return
+  }
+
+  let haveJson = false
+  const files = fs.readdirSync(abisDir)
+  for (const file of files) {
+    if (file.toLowerCase().endsWith('.json')) {
+      haveJson = true
+      break
+    }
+  }
+  if (!haveJson) {
+    return
+  }
+
+  // TODO this will fail during postinstall, need to locate real typechain path
+  await execStep(
+    'yarn typechain --target ' + ETHERS_TARGET + ` --out-dir ${outDir} ${path.join(abisDir, '*.json')}`,
+    'Type definitions gen'
+  )
+}
+
+export function codeGenSolanaProcessor(abisDir: string, root = '', targetPath = path.join('src', 'types')) {
+  const abisFolder = path.join(root, abisDir)
+  const abisFiles = fs.readdirSync(abisFolder)
+  const typeFolder = path.join(root, targetPath)
+  for (const file of abisFiles) {
+    if (path.extname(file) === '.json') {
+      if (!fs.existsSync(typeFolder)) {
+        fs.mkdirSync(typeFolder)
+      }
+      const idlContent = fs.readFileSync(path.join(abisFolder, file), 'utf-8')
+      const idlObj = JSON.parse(idlContent)
+      const idlName = idlObj.name
+      const idlFile = path.join(typeFolder, idlName + '.ts')
+      fs.writeFileSync(idlFile, `export const ${idlName}_idl = ${idlContent}`)
+      fs.writeFileSync(path.join(typeFolder, `${idlName}_processor.ts`), codeGenSolanaIdlProcessor(idlObj))
+    }
+  }
+}
+
+function codeGenSolanaIdlProcessor(idlObj: any): string {
+  const idlName = idlObj.name
+  const idlNamePascalCase = toPascalCase(idlName)
+  const instructions: any[] = idlObj.instructions
+  return `import { BorshInstructionCoder, Instruction, Idl, BN } from '@project-serum/anchor'
+import { SolanaBaseProcessor, SolanaContext, SolanaBindOptions } from "@sentio/sdk"
+import { ${idlName}_idl } from "./${idlName}"
+import bs58 from 'bs58'
+import { PublicKey } from '@solana/web3.js'
+
+export class ${idlNamePascalCase}Processor extends SolanaBaseProcessor {
+  static bind(options: SolanaBindOptions): ${idlNamePascalCase}Processor {
+    if (options && !options.name) {
+      options.name = '${idlNamePascalCase}'
+    }
+    return new ${idlNamePascalCase}Processor(options)
+  }
+
+  decodeInstruction: (rawInstruction: string) => Instruction | null = (rawInstruction) => {
+    const instructionCoder = new BorshInstructionCoder(${idlName}_idl as Idl)
+    const decodedIns = instructionCoder.decode(Buffer.from(bs58.decode(rawInstruction)))
+    return decodedIns
+  }
+
+  ${instructions.map((ins) => codeGenSolanaInstruction(idlNamePascalCase, ins)).join('')}
+}
+  `
+}
+
+function codeGenSolanaInstruction(idlName: string, ins: any): string {
+  const instructionName = ins.name
+  const argsTypeString = codeGenInstructionArgs(ins.args)
+  return `
+  on${
+    instructionName.charAt(0).toUpperCase() + instructionName.slice(1)
+  }(handler: (args: ${argsTypeString}, ctx: SolanaContext) => void): ${idlName}Processor {
+    this.onInstruction('${instructionName}', (ins: Instruction, ctx) => {
+      if (ins) {
+        handler(ins.data as ${argsTypeString}, ctx)
+      }
+    })
+    return this
+  }
+  `
+}
+
+function codeGenInstructionArgs(args: { name: string; type: string }[]): string {
+  return `{ ${args.map((arg) => arg.name + ': ' + mapType(arg.type)).join(', ')} }`
+}
+
+// Reference: https://github.com/coral-xyz/anchor/blob/93332766f13e86efbe77c9986722731742317ede/ts/src/program/namespace/types.ts#L104
+function mapType(tpe: string): string {
+  switch (tpe) {
+    case 'publicKey':
+      return 'PublicKey'
+    case 'bool':
+      return 'boolean'
+    case 'string':
+      return 'string'
+    case 'u8':
+    case 'i8':
+    case 'u16':
+    case 'i16':
+    case 'u32':
+    case 'i32':
+    case 'f32':
+    case 'f64':
+      return 'number'
+    case 'u64':
+    case 'i64':
+    case 'u128':
+    case 'i128':
+      return 'BN'
+    default:
+      return 'any'
+  }
+}
+
+function toPascalCase(str: string) {
+  return `${str}`
+    .toLowerCase()
+    .replace(new RegExp(/[-_]+/, 'g'), ' ')
+    .replace(new RegExp(/[^\w\s]/, 'g'), '')
+    .replace(new RegExp(/\s+(.)(\w*)/, 'g'), ($1, $2, $3) => `${$2.toUpperCase() + $3}`)
+    .replace(new RegExp(/\w/), (s) => s.toUpperCase())
+}
+
+async function execStep(cmd: string, stepName: string) {
+  const child = exec(cmd)
+  console.log(chalk.blue(stepName + ' begin'))
+
+  if (!child.stdout || !child.stderr) {
+    console.error(chalk.red(stepName + ' failed'))
+    process.exit(1)
+  }
+
+  child.stdout.pipe(process.stdout)
+  child.stderr.pipe(process.stderr)
+
+  await new Promise((resolve) => {
+    child.on('close', resolve)
+  })
+
+  if (child.exitCode) {
+    console.error(chalk.red(stepName + ' failed'))
+    process.exit(child.exitCode)
+  }
+  console.log(chalk.blue(stepName + ' success'))
+  console.log()
+}

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()))
+  }
+}