@sentio/cli 1.0.0

package/src/commands/run-version.ts

@@ -0,0 +1,32 @@
+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/config.ts

@@ -0,0 +1,72 @@
+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/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/upload.ts

@@ -0,0 +1,214 @@
+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/utils.ts

@@ -0,0 +1,10 @@
+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/webpack.config.js

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

package/templates/aptos/.gitignore

@@ -0,0 +1,107 @@
+.idea
+src/types
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# TypeScript v1 declaration files
+typings/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.test
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+
+# Next.js build output
+.next
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and *not* Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port