@sentio/sdk 1.13.0 → 1.13.2

package/template/node_modules/@sentio/sdk/src/cli/build.ts

@@ -1,196 +0,0 @@
-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/template/node_modules/@sentio/sdk/src/cli/cli.ts

@@ -1,160 +0,0 @@
-#!/usr/bin/env node
-
-import commandLineArgs from 'command-line-args'
-import commandLineUsage from 'command-line-usage'
-import fs from 'fs'
-import path from 'path'
-
-import yaml from 'js-yaml'
-import { EVM, finalizeHost, FinalizeProjectName, SentioProjectConfig } from './config'
-import { uploadFile } from './upload'
-import chalk from 'chalk'
-import { buildProcessor } from './build'
-import { runLogin } from './commands/run-login'
-import { runCreate } from './commands/run-create'
-
-const mainDefinitions = [{ name: 'command', defaultOption: true }]
-const mainOptions = commandLineArgs(mainDefinitions, {
-  stopAtFirstUnknown: true,
-})
-const argv = mainOptions._unknown || []
-
-if (mainOptions.command === 'login') {
-  runLogin(argv)
-} else if (mainOptions.command === 'create') {
-  runCreate(argv)
-} else {
-  // For all the commands that need read project configs
-  // TODO move them to their own modules
-
-  // 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 === 'build') {
-    buildProcessor(false, processorConfig.targets)
-  } else if (mainOptions.command === 'gen') {
-    buildProcessor(true, processorConfig.targets)
-  } else {
-    const usage = commandLineUsage([
-      {
-        header: 'Sentio',
-        content: 'Login & Manage 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 create\t\t\t\tcreate a template project',
-          '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/template/node_modules/@sentio/sdk/src/cli/commands/run-create.ts

@@ -1,36 +0,0 @@
-import commandLineArgs from 'command-line-args'
-import commandLineUsage from 'command-line-usage'
-
-export function runCreate(argv: string[]) {
-  const optionDefinitions = [
-    {
-      name: 'help',
-      alias: 'h',
-      type: Boolean,
-      description: 'Display this usage guide.',
-    },
-    {
-      name: 'name',
-      alias: 'n',
-      type: String,
-      description: '(Required) Project name',
-    },
-  ]
-
-  const options = commandLineArgs(optionDefinitions, { argv })
-  if (options.help || !options.name) {
-    const usage = commandLineUsage([
-      {
-        header: 'Sentio Create',
-        content: 'Create a template project',
-      },
-      {
-        header: 'Options',
-        optionList: optionDefinitions,
-      },
-    ])
-    console.log(usage)
-  } else {
-    //
-  }
-}

package/template/node_modules/@sentio/sdk/src/cli/commands/run-login.ts

@@ -1,70 +0,0 @@
-import commandLineArgs from 'command-line-args'
-import commandLineUsage from 'command-line-usage'
-import { getFinalizedHost } from '../config'
-import chalk from 'chalk'
-import https from 'https'
-import http from 'http'
-import { WriteKey } from '../key'
-
-export function runLogin(argv: string[]) {
-  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 {
-    const host = getFinalizedHost(options.host)
-    console.log(chalk.blue('login to ' + host))
-    const url = new URL(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(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()
-  }
-}

package/template/node_modules/@sentio/sdk/src/cli/config.ts

@@ -1,45 +0,0 @@
-export interface SentioProjectConfig {
-  project: string
-  host: string
-  source: string
-  build: boolean
-  targets: Target[]
-}
-
-export function getFinalizedHost(host: string): string {
-  switch (host) {
-    case '':
-    case 'prod':
-      return 'https://app.sentio.xyz'
-    case 'test':
-      return 'https://test.sentio.xyz'
-    case 'staging':
-      return 'https://staging.sentio.xyz'
-    case 'local':
-      return 'http://localhost:10000'
-  }
-  return host
-}
-
-export function finalizeHost(config: SentioProjectConfig) {
-  config.host = getFinalizedHost(config.host)
-}
-
-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/template/node_modules/@sentio/sdk/src/cli/key.ts

@@ -1,43 +0,0 @@
-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/template/node_modules/@sentio/sdk/src/cli/solana-code-gen.ts

@@ -1,16 +0,0 @@
-#!/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/template/node_modules/@sentio/sdk/src/cli/upload.ts

@@ -1,88 +0,0 @@
-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)
-    }
-    const { ProjectSlug } = await res.json()
-    console.log('\t', chalk.blue('Check status:'), `${options.host}/${ProjectSlug}/datasource`)
-  } else {
-    console.error(chalk.red('Upload Failed'))
-    console.error(chalk.red(await res.text()))
-  }
-}

package/template/node_modules/@sentio/sdk/src/cli/webpack.config.js

@@ -1,42 +0,0 @@
-/* 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()
-    },
-  ],
-}