@sentio/sdk 1.35.1-rc.2 → 1.36.0-rc.2

package/src/cli/commands/run-create.ts

@@ -1,115 +0,0 @@
-import commandLineArgs from 'command-line-args'
-import commandLineUsage from 'command-line-usage'
-import path from 'path'
-import fs from 'fs-extra'
-import chalk from 'chalk'
-import { getCliVersion } from '../utils'
-
-export function runCreate(argv: string[]) {
-  const optionDefinitions = [
-    {
-      name: 'help',
-      alias: 'h',
-      type: Boolean,
-      description: 'Display this usage guide.',
-    },
-    {
-      name: 'name',
-      alias: 'n',
-      defaultOption: true,
-      type: String,
-      description: 'Project name',
-    },
-    {
-      name: 'directory',
-      alias: 'd',
-      description: '(Optional) The root direct new project will be created, default current working dir',
-      type: String,
-    },
-    {
-      name: 'chain-type',
-      alias: 'c',
-      description:
-        'The type of project you want to create, can be evm, aptos, raw (if you want to start from scratch and support multiple types of chains)',
-      type: String,
-      defaultValue: 'evm',
-    },
-  ]
-
-  const options = commandLineArgs(optionDefinitions, { argv })
-  const usage = commandLineUsage([
-    {
-      header: 'Create a template project',
-      content: 'sentio create <name>',
-    },
-    {
-      header: 'Options',
-      optionList: optionDefinitions,
-    },
-  ])
-
-  if (options.help || !options.name) {
-    console.log(usage)
-  } else {
-    const chainType: string = options['chain-type'].toLowerCase()
-    switch (chainType) {
-      case 'evm':
-        break
-      case 'aptos':
-        break
-      case 'raw':
-        break
-      default:
-        console.error(chalk.red('non supported chain-type for template creation, use --help for more information.'))
-        console.log(usage)
-        process.exit(1)
-    }
-    const templateFolder = path.resolve(__dirname, '../../../templates', chainType)
-    const projectName = options.name || 'default'
-
-    const rootDir = options.directory || process.cwd()
-    const dstFolder = path.resolve(rootDir, projectName)
-    if (fs.existsSync(dstFolder)) {
-      console.error(chalk.red("can't create project '" + projectName + "', directory already existed"))
-      process.exit(1)
-    }
-
-    fs.copySync(templateFolder, dstFolder, {
-      filter: (src, _) => {
-        // TODO read from .gitignore to be more reliable
-        if (
-          src.endsWith('types') ||
-          src.endsWith('dist') ||
-          src.endsWith('node_modules') ||
-          src.endsWith('.lock') ||
-          src.endsWith('dist')
-        ) {
-          return false
-        }
-        return true
-      },
-      overwrite: false,
-    })
-    if (options.name) {
-      const sentioYamlPath = path.resolve(dstFolder, 'sentio.yaml')
-      fs.writeFileSync(sentioYamlPath, 'project: ' + projectName + '\n', { flag: 'w+' })
-
-      const packageJsonPath = path.resolve(dstFolder, 'package.json')
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
-
-      let cliVersion = getCliVersion()
-      if (!cliVersion.startsWith('^')) {
-        cliVersion = '^' + cliVersion
-      }
-
-      packageJson.dependencies['@sentio/sdk'] = cliVersion
-      packageJson.name = projectName
-
-      // Don't add directly to avoid deps issue
-      packageJson.scripts.postinstall = 'sentio gen'
-
-      fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))
-    }
-    console.log(chalk.green("successfully create project '" + projectName + "'"))
-  }
-}

package/src/cli/commands/run-login.ts

@@ -1,111 +0,0 @@
-import commandLineArgs from 'command-line-args'
-import commandLineUsage from 'command-line-usage'
-import { getAuthConfig, getFinalizedHost } from '../config'
-import { startServer } from './login-server'
-import url, { URL } from 'url'
-import * as crypto from 'crypto'
-import chalk from 'chalk'
-import { WriteKey } from '../key'
-import fetch from 'node-fetch'
-import open from 'open'
-
-const port = 20000
-
-export function runLogin(argv: string[]) {
-  const optionDefinitions = [
-    {
-      name: 'help',
-      alias: 'h',
-      type: Boolean,
-      description: 'Display this usage guide.',
-    },
-    {
-      name: 'host',
-      description: '(Optional) Override Sentio Host name',
-      type: String,
-    },
-    {
-      name: 'api-key',
-      type: String,
-      description: '(Optional) Your API key',
-    },
-  ]
-  const options = commandLineArgs(optionDefinitions, { argv })
-
-  const host = getFinalizedHost(options.host)
-  if (options.help) {
-    const usage = commandLineUsage([
-      {
-        header: 'Login to Sentio',
-        content: 'sentio login',
-      },
-      {
-        header: 'Options',
-        optionList: optionDefinitions,
-      },
-    ])
-    console.log(usage)
-  } else if (options['api-key']) {
-    console.log(chalk.blue('login to ' + host))
-    const apiKey = options['api-key']
-    checkKey(host, apiKey).then((res) => {
-      if (res.status == 200) {
-        WriteKey(host, apiKey)
-        console.log(chalk.green('login success'))
-      } else {
-        console.error(chalk.red('login failed, code:', res.status, res.statusText))
-      }
-    })
-  } else {
-    // https://auth0.com/docs/get-started/authentication-and-authorization-flow/call-your-api-using-the-authorization-code-flow-with-pkce
-    const verifier = base64URLEncode(crypto.randomBytes(32))
-    const challenge = base64URLEncode(sha256(verifier))
-
-    const conf = getAuthConfig(host)
-    if (conf.domain === '') {
-      console.error(chalk.red('invalid host, try login with an API key if it is a dev env'))
-      return
-    }
-    const authURL = new URL(conf.domain + `/authorize?`)
-    const params = new url.URLSearchParams({
-      response_type: 'code',
-      code_challenge: challenge,
-      code_challenge_method: 'S256',
-      client_id: conf.clientId,
-      redirect_uri: `http://localhost:${port}/callback`,
-      audience: conf.audience,
-      prompt: 'login',
-    })
-    authURL.search = params.toString()
-
-    console.log('Continue your authorization in the browser')
-    open(authURL.toString()).catch((reason) => {
-      console.error(chalk.red('Unable to open browser: ' + reason))
-      console.error(chalk.red('Open this url in your browser: ' + authURL.toString()))
-    })
-
-    startServer({
-      serverPort: port,
-      sentioHost: options.host,
-      codeVerifier: verifier,
-    })
-  }
-}
-
-function base64URLEncode(str: Buffer) {
-  return str.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '')
-}
-
-function sha256(str: string) {
-  return crypto.createHash('sha256').update(str).digest()
-}
-
-async function checkKey(host: string, apiKey: string) {
-  const checkApiKeyUrl = new URL('/api/v1/processors/check_key', host)
-  return fetch(checkApiKeyUrl, {
-    method: 'GET',
-    headers: {
-      'api-key': apiKey,
-    },
-  })
-}

package/src/cli/commands/run-version.ts

@@ -1,32 +0,0 @@
-import commandLineArgs from 'command-line-args'
-import commandLineUsage from 'command-line-usage'
-import { getCliVersion } from '../utils'
-
-export function runVersion(argv: string[]) {
-  const optionDefinitions = [
-    {
-      name: 'help',
-      alias: 'h',
-      type: Boolean,
-      description: 'Display this usage guide.',
-    },
-  ]
-  const options = commandLineArgs(optionDefinitions, { argv })
-
-  if (options.help) {
-    const usage = commandLineUsage([
-      {
-        header: 'Show current version',
-        content: 'sentio version',
-      },
-      {
-        header: 'Options',
-        optionList: optionDefinitions,
-      },
-    ])
-    console.log(usage)
-  } else {
-    console.log('CLI Version: ', getCliVersion())
-    // TODO show SDK version for current package
-  }
-}

package/src/cli/config.ts

@@ -1,72 +0,0 @@
-const HostMap: { [host: string]: string } = {
-  local: 'http://localhost:10000',
-  test: 'https://test.sentio.xyz',
-  staging: 'https://staging.sentio.xyz',
-  prod: 'https://app.sentio.xyz',
-}
-
-export interface SentioProjectConfig {
-  project: string
-  host: string
-  // source: string
-  build: boolean
-  // targets: Target[]
-  debug: boolean
-}
-
-export function getFinalizedHost(host: string): string {
-  if (host === undefined || host === '') {
-    host = 'prod'
-  }
-  return HostMap[host] ?? host
-}
-
-export function getAuthConfig(host: string): { domain: string; clientId: string; audience: string } {
-  let domain = '',
-    clientId = '',
-    audience = ''
-  switch (host) {
-    case HostMap['local']:
-      domain = 'https://sentio-dev.us.auth0.com'
-      clientId = 'qGDisObqQbcPeRA8k02POPZ2Df4KVCna'
-      audience = 'http://localhost:8080/v1'
-      break
-    case HostMap['prod']:
-      domain = 'https://auth.sentio.xyz'
-      clientId = 'xd80PeuvuZVHpBFh7yEdlSZdtE5mTpGe'
-      audience = 'https://app.sentio.xyz/api/v1'
-      break
-    case HostMap['test']:
-    case HostMap['staging']:
-      domain = 'https://auth.test.sentio.xyz'
-      clientId = 'qXVvovHaOE37SndxTZJxCKgZjw1axPax'
-      audience = 'https://test.sentio.xyz/api/v1'
-      break
-    default:
-      break
-  }
-  return { domain, clientId, audience }
-}
-
-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/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/src/cli/upload.ts

@@ -1,214 +0,0 @@
-import { execSync } from 'child_process'
-import { createHash } from 'crypto'
-import fs from 'fs'
-import readline from 'readline'
-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'
-import { getCliVersion } from './utils'
-import { URL } from 'url'
-
-async function createProject(options: SentioProjectConfig, apiKey: string) {
-  const url = new URL('/api/v1/projects', options.host)
-  const [ownerName, slug] = options.project.includes('/') ? options.project.split('/') : [undefined, options.project]
-  return fetch(url, {
-    method: 'POST',
-    headers: {
-      'api-key': apiKey,
-    },
-    body: JSON.stringify({ slug, ownerName, visibility: 'PRIVATE' }),
-  })
-}
-
-export async function uploadFile(options: SentioProjectConfig, apiKeyOverride: string) {
-  if (options.build) {
-    await buildProcessor(false)
-  }
-
-  console.log(chalk.blue('Prepare to upload'))
-
-  const PROCESSOR_FILE = path.join(process.cwd(), 'dist/lib.js')
-
-  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')
-
-  let triedCount = 0
-  const upload = async () => {
-    let commitSha = ''
-    let gitUrl = ''
-    const sha256 = digest
-    try {
-      commitSha = execSync('git rev-parse HEAD').toString().trim()
-    } catch (e) {
-      chalk.yellow(e)
-    }
-    try {
-      gitUrl = execSync('git remote get-url origin').toString().trim()
-    } catch (e) {
-      // skip errors
-    }
-    console.log(chalk.blue(triedCount > 1 ? 'Retry uploading' : 'Uploading'))
-
-    // get gcs upload url
-    const initUploadResRaw = await initUpload(options.host, apiKey, options.project, getCliVersion())
-    if (!initUploadResRaw.ok) {
-      console.error(chalk.red('Failed to get upload url'))
-      console.error(chalk.red((await initUploadResRaw.json()).message))
-
-      if (initUploadResRaw.status === 404) {
-        // create project if not exist
-        const rl = readline.createInterface({
-          input: process.stdin,
-          output: process.stdout,
-        })
-        const prompt = async () => {
-          const answer: string = await new Promise((resolve) =>
-            rl.question(`Do you want to create it and continue the uploading process? (yes/no) `, resolve)
-          )
-          if (['y', 'yes'].includes(answer.toLowerCase())) {
-            rl.close()
-            const res = await createProject(options, apiKey)
-            if (!res.ok) {
-              console.error(chalk.red('Create Project Failed'))
-              console.error(chalk.red((await res.json()).message))
-              return
-            }
-            console.log(chalk.green('Project created'))
-            await upload()
-          } else if (['n', 'no'].includes(answer.toLowerCase())) {
-            rl.close()
-          } else {
-            await prompt()
-          }
-        }
-        await prompt()
-      }
-      return
-    }
-    const initUploadRes = await initUploadResRaw.json()
-    const uploadUrl = initUploadRes['url'] as string
-
-    // do actual uploading
-    const file = fs.createReadStream(PROCESSOR_FILE)
-    const uploadResRaw = await fetch(uploadUrl, {
-      method: 'PUT',
-      headers: {
-        'Content-Type': 'application/octet-stream',
-      },
-      body: file,
-    })
-    if (!uploadResRaw.ok) {
-      console.error(chalk.red('Failed to upload'))
-      console.error(chalk.red(await uploadResRaw.text()))
-      return
-    }
-
-    // finish uploading
-    const finishUploadResRaw = await finishUpload(
-      options.host,
-      apiKey,
-      options.project,
-      getCliVersion(),
-      sha256,
-      commitSha,
-      gitUrl,
-      options.debug
-    )
-    if (!finishUploadResRaw.ok) {
-      console.error(chalk.red('Failed to finish uploading'))
-      console.error(chalk.red(await finishUploadResRaw.text()))
-      return
-    }
-
-    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 { projectFullSlug } = await finishUploadResRaw.json()
-    console.log('\t', chalk.blue('Check status:'), `${options.host}/${projectFullSlug}/datasource`)
-  }
-
-  let error: Error
-  const tryUploading = async () => {
-    if (triedCount++ >= 5) {
-      console.error(error)
-      return
-    }
-    try {
-      await upload()
-    } catch (e) {
-      if (e.constructor.name === 'FetchError' && e.type === 'system' && e.code === 'EPIPE') {
-        error = e
-        await new Promise((resolve) => setTimeout(resolve, 1000))
-        await tryUploading()
-      } else {
-        console.error(e)
-      }
-    }
-  }
-
-  await tryUploading()
-}
-
-async function initUpload(host: string, apiKey: string, projectSlug: string, sdkVersion: string) {
-  const initUploadUrl = new URL(`/api/v1/processors/init_upload`, host)
-  return fetch(initUploadUrl, {
-    method: 'POST',
-    headers: {
-      'api-key': apiKey,
-    },
-    body: JSON.stringify({
-      project_slug: projectSlug,
-      sdk_version: sdkVersion,
-    }),
-  })
-}
-
-async function finishUpload(
-  host: string,
-  apiKey: string,
-  projectSlug: string,
-  sdkVersion: string,
-  sha256: string,
-  commitSha: string,
-  gitUrl: string,
-  debug: boolean
-) {
-  const finishUploadUrl = new URL(`/api/v1/processors/finish_upload`, host)
-  return fetch(finishUploadUrl, {
-    method: 'POST',
-    headers: {
-      'api-key': apiKey,
-    },
-    body: JSON.stringify({
-      project_slug: projectSlug,
-      sdk_version: sdkVersion,
-      sha256: sha256,
-      commit_sha: commitSha,
-      git_url: gitUrl,
-      debug: debug,
-    }),
-  })
-}

package/src/cli/utils.ts

@@ -1,10 +0,0 @@
-import fs from 'fs-extra'
-import path from 'path'
-
-export function getCliVersion() {
-  const packageJsonPath = path.resolve(__dirname, '../../package.json')
-  const packageJsonContent = fs.readFileSync(packageJsonPath, 'utf-8')
-  const packageJson = JSON.parse(packageJsonContent)
-
-  return packageJson.version
-}

package/src/cli/webpack.config.js

@@ -1,47 +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: [
-    {
-      protobufjs: 'commonjs2 protobufjs',
-      aptos: 'commonjs2 aptos-sdk',
-      ethers: 'commonjs2 ethers',
-      bs58: 'commonjs2 bs58',
-      "bignumber.js": 'commonjs2 bignumber.js',
-      'bn.js': 'commonjs2 bn.js',
-      'csv-parse': 'commonjs2 csv-parse',
-    },
-    function ({ context, request }, callback) {
-      if (/^@(ethersproject|solana|project-serum|nice-grpc).*$/.test(request)) {
-        return callback(null, 'commonjs ' + request)
-      }
-      if (request.startsWith("@sentio/sdk")) {
-        return callback(null, 'commonjs2 ' + request)
-      }
-      callback()
-    },
-  ],
-}