@audius/sdk 0.0.0

package/initScripts/mainnet.js

@@ -0,0 +1,131 @@
+const Web3 = require('../src/web3')
+const path = require('path')
+
+const { setServiceVersion, addServiceType } = require('./helpers/version')
+const { getStakingParameters } = require('./helpers/spRegistration')
+const { getClaimInfo, fundNewClaim } = require('./helpers/claim')
+
+const AudiusLibs = require('../src/index')
+
+const isServer = true
+
+const args = process.argv
+if (args.length < 3) {
+  _throwArgError()
+}
+
+/*
+ *
+ * export AUDIUS_PRIVATE_KEY=
+   export AUDIUS_OWNER_WALLET=
+ * */
+const run = async () => {
+  try {
+    const configFile = args[2]
+    const commandToRun = args[3]
+    const config = require(path.join(__dirname, configFile))
+
+    const privateKey = _getEnv('AUDIUS_PRIVATE_KEY')
+    const ownerWallet = _getEnv('AUDIUS_OWNER_WALLET')
+    const audiusLibs = await getAudiusLibs(config, privateKey, ownerWallet)
+    switch (commandToRun) {
+      case 'setversion':
+        const serviceType = args[4]
+        const versionStr = args[5]
+        let dryRun = true
+        // if args[6] is defined and the value is either bool or string false, set dryRun to false
+        if (args[6] && (['false', false].includes(args[6]))) {
+          dryRun = false
+        }
+        if (!serviceType || !versionStr) {
+          throw new Error('missing arguments - format: node mainnet.js setversion <serviceType> <versionStr>')
+        }
+        await setServiceVersion(audiusLibs, serviceType, versionStr, privateKey, dryRun)
+        break
+      case 'addservicetype':
+        const newServiceType = args[4]
+        const serviceTypeMin = args[5]
+        const serviceTypeMax = args[6]
+        if (!newServiceType || !serviceTypeMin || !serviceTypeMax) {
+          throw new Error('missing arguments - format: node mainnet.js addservicetype <serviceType> <serviceTypeMin> <serviceTypeMax>')
+        }
+        await addServiceType(audiusLibs, newServiceType, serviceTypeMin, serviceTypeMax, privateKey)
+        break
+      case 'getclaim':
+        await getClaimInfo(audiusLibs)
+        break
+      case 'fundclaim':
+        if (!args[4]) {
+          throw new Error('missing argument - format: node mainnet.js fundclaim <amountOfAuds>')
+        }
+
+        const amountOfAuds = args[4]
+        await fundNewClaim(audiusLibs, amountOfAuds, privateKey)
+        break
+      case 'stakeinfo':
+        await getStakingParameters(audiusLibs)
+        break
+      default:
+        _throwArgError()
+    }
+
+    process.exit(0)
+  } catch (e) {
+    throw e
+  }
+}
+
+run()
+
+function getLibsConfig (config, privateKey, ownerWallet) {
+  let audiusLibsConfig
+  if (!privateKey || !ownerWallet) {
+    throw new Error('Missing private key or owner wallet')
+  }
+  console.log('Querying environment variables:')
+  console.log(privateKey)
+  console.log(ownerWallet)
+
+  const dataWeb3 = new Web3(new Web3.providers.HttpProvider(config.dataWeb3ProviderEndpoint))
+  const web3DataContractConfig = {
+    registryAddress: config.dataRegistryAddress,
+    useExternalWeb3: true,
+    externalWeb3Config: {
+      web3: dataWeb3,
+      ownerWallet: ownerWallet
+    }
+  }
+
+  const ethWeb3 = new Web3(new Web3.providers.HttpProvider(config.ethWeb3ProviderEndpoint))
+  audiusLibsConfig = {
+    web3Config: web3DataContractConfig,
+    ethWeb3Config: AudiusLibs.configEthWeb3(
+      config.ethTokenAddress, // Token Address
+      config.ethRegistryAddress,
+      ethWeb3,
+      ownerWallet
+    ),
+    discoveryProviderConfig: AudiusLibs.configDiscoveryProvider(),
+    isServer: isServer
+  }
+  return audiusLibsConfig
+}
+
+async function getAudiusLibs (config, privateKey, ownerWallet) {
+  const audiusLibsConfig = getLibsConfig(config, privateKey, ownerWallet)
+  const audiusLibs = new AudiusLibs(audiusLibsConfig)
+  await audiusLibs.init()
+  return audiusLibs
+}
+
+function _getEnv (env) {
+  const value = process.env[env]
+  if (typeof value === 'undefined') {
+    throw new Error(`${env} has not been set.`)
+  }
+  return value
+}
+
+function _throwArgError () {
+  throw new Error('missing argument - format: node mainnet.js <configFilePath> [setversion, fundclaim, getclaim, stakeinfo] [additional options]')
+}

package/initScripts/manageProdRelayerWallets.js

@@ -0,0 +1,191 @@
+const Web3 = require('web3')
+const crypto = require('crypto')
+const EthereumWallet = require('ethereumjs-wallet')
+const EthereumTx = require('ethereumjs-tx').Transaction
+const axios = require('axios')
+
+// Switch to mainnet eth - ropsten is enabled by default to prevent accidental prod manipulation
+// const ethWeb3ProviderEndpoint = 'https://ropsten.infura.io/v3/c569c6faf4f14d15a49d0044e7ddd668'
+const ethWeb3ProviderEndpoint = 'https://mainnet.infura.io/v3/3a78237a7f4f42e69cf69cf9db7cecd6'
+// const ethWeb3ProviderEndpoint = 'https://eth-mainnet.alchemyapi.io/v2/iSnek4T02BFCUEkcPGKo0eEY1aWLJgxF'
+
+const fs = require('fs')
+
+// 0.0001 ETH, 100000000000000 wei
+
+// TBD: Actual target minimum for each relayer
+// const minimumBalance = 100000000000000
+
+// 0.1 eth =           100000000000000000 wei
+
+// 0.25 eth =          250000000000000000
+// const minimumBalance = 250000000000000000
+// 0.075 eth
+const minimumBalance = 75000000000000000
+
+const ethWeb3 = new Web3(new Web3.providers.HttpProvider(ethWeb3ProviderEndpoint))
+
+/*
+Expected format of prod-relayer-config.json
+{
+    "funderPublicKey": "0x755f4...",
+    "funderPrivateKey": "5d30...",
+    "relayerWallets": [
+      { "publicKey": "0x2c3...",
+        "privateKey":
+         "d77e00f6..." },
+         ...]
+    }
+*/
+
+/**
+ * Make sure you save the `prod-relayer-config.json` file from LastPass to libs/initScripts
+ */
+
+const configFilePath = './prod-relayer-config.json'
+if (!fs.existsSync(configFilePath)) {
+  throw new Error('Please ensure you have prod-relayer-config.json saved locally and have set the path')
+}
+
+const prodRelayerInfo = require(configFilePath)
+
+const generateNewAccounts = async () => {
+  const numWallets = 1
+  const wallets = []
+  for (let i = 0; i < numWallets; i++) {
+    const privateKey = crypto.randomBytes(32).toString('hex')
+    const privateKeyBuffer = Buffer.from(privateKey, 'hex')
+    const walletObj = EthereumWallet.fromPrivateKey(privateKeyBuffer)
+    const info = {
+      publicKey: walletObj.getAddressString(),
+      privateKey
+    }
+    wallets.push(info)
+  }
+  console.log(wallets)
+  await queryAccountBalances(wallets)
+}
+
+const queryAccountBalances = async (wallets) => {
+  for (let i = 0; i < wallets.length; i++) {
+    const pubKey = wallets[i].publicKey
+    const balance = await ethWeb3.eth.getBalance(pubKey)
+    console.log(`Found balance ${ethWeb3.utils.fromWei(balance)} eth (${balance} wei) for ${pubKey}`)
+  }
+  console.log(`\n\nQueried ${wallets.length} wallets`)
+}
+
+const queryRelayerBalances = async () => {
+  const gasInfo = await getGasPrice()
+  const walletInfo = await loadProdRelayerWallets()
+  await queryAccountBalances(walletInfo.relayerWallets)
+  console.log(gasInfo, '\n')
+}
+
+const loadProdRelayerWallets = async () => {
+  const funder = {
+    publicKey: prodRelayerInfo.funderPublicKey,
+    privateKey: prodRelayerInfo.funderPrivateKey
+  }
+  // console.log(funder)
+  const relayerWallets = prodRelayerInfo.relayerWallets
+  // console.log(relayerWallets)
+  const funderbalance = await ethWeb3.eth.getBalance(funder.publicKey)
+  console.log(`\nFunder ${funder.publicKey} balance: ${ethWeb3.utils.fromWei(funderbalance)} eth (${funderbalance} wei)`)
+
+  console.log(`Minimum relayer balance: ${ethWeb3.utils.fromWei(minimumBalance.toString())} eth (${minimumBalance.toString()} wei)\n\n`)
+
+  return { funder, relayerWallets }
+}
+
+const getGasPrice = async () => {
+  const { data } = await axios({
+    url: 'https://identityservice.staging.audius.co/eth_gas_price',
+    method: 'get',
+    timeout: 3000
+  })
+  return data
+}
+
+const createAndSendTransaction = async (sender, receiverAddress, value, web3, gasPrice) => {
+  const privateKeyBuffer = Buffer.from(sender.privateKey, 'hex')
+  const walletAddress = EthereumWallet.fromPrivateKey(privateKeyBuffer)
+  const address = walletAddress.getAddressString()
+  //  "averageGweiHex": "0x1e08ffca00",
+  // const gasPrice = "0x1e08ffca00"
+  // fast price = 0x8d8f9fc00
+  // new fast price = 0x2e90edd000
+  // const gasPrice = "0x2e90edd000"
+  // const gasPrice = "0x1e80355e00"
+  // from identity - 0xf7100
+  const gasLimit = '0xf7100'
+  const nonce = await web3.eth.getTransactionCount(address)
+  console.log(`Sending tx from ${sender.publicKey} to ${receiverAddress} with nonce=${nonce}, gasPrice=${gasPrice}, gasLimit=${gasLimit}`)
+  const txParams = {
+    nonce: web3.utils.toHex(nonce),
+    gasPrice: gasPrice,
+    gasLimit: gasLimit,
+    to: receiverAddress,
+    value: web3.utils.toHex(value)
+  }
+  const tx = new EthereumTx(txParams)
+  tx.sign(privateKeyBuffer)
+  const signedTx = '0x' + tx.serialize().toString('hex')
+  try {
+    await web3.eth.sendSignedTransaction(signedTx)
+  } catch (e) {
+    console.log(`Failed with ${e}`)
+  }
+}
+
+const fundEthRelayerIfEmpty = async () => {
+  const walletInfo = await loadProdRelayerWallets()
+
+  const relayerWallets = walletInfo.relayerWallets
+
+  let gasInfo
+  let gasPrice
+
+  for (let i = 0; i < relayerWallets.length; i++) {
+    const relayerPublicKey = relayerWallets[i].publicKey
+    let balance = await ethWeb3.eth.getBalance(relayerPublicKey)
+    const validBalance = parseInt(balance) >= minimumBalance
+    console.log(`${i + 1} - Found balance ${balance} for ${relayerPublicKey}, validBal=${validBalance}`)
+    if (!validBalance) {
+      const missingBalance = minimumBalance - balance
+      console.log(`${i + 1} - Funding ${relayerPublicKey} with ${missingBalance}, currently ${balance}/${minimumBalance}`)
+      gasInfo = await getGasPrice()
+      gasPrice = gasInfo.fastestGweiHex
+      await createAndSendTransaction(
+        walletInfo.funder, // Always send from the designated FUNDER
+        relayerPublicKey, // Public key of receiving account
+        missingBalance, // Min
+        ethWeb3,
+        gasPrice
+      )
+      console.log(`${i + 1} - Finished Funding ${relayerPublicKey} with ${minimumBalance}`)
+      balance = await ethWeb3.eth.getBalance(relayerPublicKey)
+      console.log(`${i + 1} - Updated balance ${balance} for ${relayerPublicKey}`)
+    }
+  }
+  await queryAccountBalances(relayerWallets)
+}
+
+const args = process.argv
+const run = async () => {
+  switch (args[2]) {
+    case 'fundAllRelayers':
+      await fundEthRelayerIfEmpty()
+      break
+    case 'queryRelayerBalances':
+      await queryRelayerBalances()
+      break
+    case 'generatenewAccounts':
+      await generateNewAccounts()
+      break
+    default:
+      throw new Error('Invalid argument')
+  }
+}
+
+run()

package/package.json

@@ -0,0 +1,125 @@
+{
+  "name": "@audius/sdk",
+  "version": "0.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/types.d.ts",
+  "browser": "dist/browser.js",
+  "legacy": "dist/legacy.js",
+  "legacyTypes": "dist/legacy.d.ts",
+  "core": "dist/core.js",
+  "coreTypes": "dist/core.d.ts",
+  "scripts": {
+    "init-local": "ts-node initScripts/local.js",
+    "test": "./scripts/test.sh",
+    "test-circle-ci": "./scripts/circleci-test.sh",
+    "test:unit": "ts-mocha 'src/**/*.test.{js,ts}' --exit",
+    "test:unit:watch": "ts-mocha 'src/**/*.test.{js,ts}' --watch",
+    "test:integration": "ts-mocha tests/index.js",
+    "setup": "./scripts/migrate_contracts.sh",
+    "build": "rollup -c",
+    "dev": "rollup -c -w",
+    "lint": "eslint ./src ./types",
+    "lint:fix": "npm run lint -- --fix",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@audius/anchor-audius-data": "0.0.2",
+    "@audius/hedgehog": "1.0.12",
+    "@certusone/wormhole-sdk": "0.1.1",
+    "@ethersproject/solidity": "5.0.5",
+    "@improbable-eng/grpc-web-node-http-transport": "0.15.0",
+    "@project-serum/anchor": "0.24.1",
+    "@solana/spl-token": "0.1.6",
+    "@solana/web3.js": "1.37.1",
+    "abi-decoder": "1.2.0",
+    "ajv": "6.12.2",
+    "async-retry": "1.3.1",
+    "axios": "0.19.2",
+    "borsh": "0.4.0",
+    "bs58": "4.0.1",
+    "cipher-base": "1.0.4",
+    "elliptic": "6.5.4",
+    "esm": "3.2.25",
+    "eth-sig-util": "2.5.4",
+    "ethereumjs-tx": "2.1.2",
+    "ethereumjs-util": "7.1.4",
+    "ethereumjs-wallet": "1.0.2",
+    "ethers": "5.4.7",
+    "form-data": "3.0.0",
+    "hashids": "2.2.10",
+    "interface-blockstore": "^2.0.3",
+    "interface-store": "^2.0.2",
+    "ipfs-unixfs-importer": "^9.0.6",
+    "jsonschema": "1.2.6",
+    "keccak256": "1.0.2",
+    "lodash": "4.17.21",
+    "node-localstorage": "^1.3.1",
+    "proper-url-join": "1.2.0",
+    "rollup-plugin-shim": "^1.0.0",
+    "safe-buffer": "5.2.1",
+    "secp256k1": "4.0.2",
+    "semver": "6.3.0",
+    "stream-browserify": "3.0.0",
+    "web3": "1.7.1"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "7.16.11",
+    "@openzeppelin/test-helpers": "0.5.6",
+    "@rollup/plugin-alias": "3.1.9",
+    "@rollup/plugin-babel": "5.3.1",
+    "@rollup/plugin-commonjs": "21.0.2",
+    "@rollup/plugin-json": "4.1.0",
+    "@rollup/plugin-node-resolve": "13.1.3",
+    "@rollup/plugin-typescript": "8.3.1",
+    "@tsconfig/node16-strictest": "1.0.0",
+    "@types/async-retry": "1.4.3",
+    "@types/bn.js": "5.1.0",
+    "@types/bs58": "4.0.1",
+    "@types/eth-sig-util": "^2.1.1",
+    "@types/expect": "24.3.0",
+    "@types/form-data": "^2.5.0",
+    "@types/hashids": "2.0.1",
+    "@types/mocha": "9.1.0",
+    "@types/node-localstorage": "1.3.0",
+    "@types/pify": "^5.0.1",
+    "@types/proper-url-join": "2.1.1",
+    "@types/semver": "7.3.9",
+    "@typescript-eslint/eslint-plugin": "4.33.0",
+    "eslint": "7.32.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-config-standard-with-typescript": "21.0.1",
+    "eslint-plugin-import": "2.25.4",
+    "eslint-plugin-mocha": "10.0.3",
+    "eslint-plugin-node": "11.1.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-promise": "5.2.0",
+    "mocha": "9.2.2",
+    "nock": "13.1.2",
+    "nyc": "15.1.0",
+    "prettier": "^2.6.1",
+    "prettier-config-standard": "^5.0.0",
+    "rollup": "2.70.1",
+    "rollup-plugin-dts": "4.2.0",
+    "rollup-plugin-ignore": "1.0.10",
+    "rollup-plugin-polyfill-node": "0.9.0",
+    "sinon": "9.0.2",
+    "standard": "16.0.4",
+    "ts-mocha": "9.0.2",
+    "ts-node": "10.7.0",
+    "typescript": "4.6.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AudiusProject/audius-protocol/tree/master/libs"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "author": "Audius",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/AudiusProject/audius-protocol/issues"
+  },
+  "homepage": "https://github.com/AudiusProject/audius-protocol/tree/master/libs"
+}

package/rollup.config.js

@@ -0,0 +1,164 @@
+import commonjs from '@rollup/plugin-commonjs'
+import babel from '@rollup/plugin-babel'
+import json from '@rollup/plugin-json'
+import resolve from '@rollup/plugin-node-resolve'
+import typescript from '@rollup/plugin-typescript'
+import dts from 'rollup-plugin-dts'
+import nodePolyfills from 'rollup-plugin-polyfill-node'
+import alias from '@rollup/plugin-alias'
+import ignore from 'rollup-plugin-ignore'
+
+import pkg from './package.json'
+
+const extensions = ['.js', '.ts']
+
+const external = [
+  ...Object.keys(pkg.dependencies),
+  ...Object.keys(pkg.devDependencies),
+  'ethers/lib/utils',
+  'ethers/lib/index',
+  'hashids/cjs'
+]
+
+const commonConfig = {
+  plugins: [
+    commonjs({
+      extensions,
+      dynamicRequireTargets: [
+        'data-contracts/ABIs/*.json',
+        'eth-contracts/ABIs/*.json'
+      ]
+    }),
+    babel({ babelHelpers: 'bundled', extensions }),
+    json(),
+    resolve({ extensions, preferBuiltins: true }),
+    typescript()
+  ],
+  external
+}
+
+// For the browser bundle, these need to be internal because they either:
+// * contain deps that need to be polyfilled via `nodePolyfills`
+// * are ignored via `ignore`
+const browserInternal = [
+  'eth-sig-util',
+  'ethereumjs-tx',
+  'ethereumjs-util',
+  'ethereumjs-wallet',
+  'graceful-fs',
+  'node-localstorage',
+  'web3'
+]
+
+const browserConfig = {
+  plugins: [
+    ignore(['web3', 'graceful-fs', 'node-localstorage']),
+    resolve({ extensions, preferBuiltins: false }),
+    commonjs({
+      extensions,
+      transformMixedEsModules: true,
+      dynamicRequireTargets: [
+        'data-contracts/ABIs/*.json',
+        'eth-contracts/ABIs/*.json'
+      ]
+    }),
+    alias({
+      entries: [{ find: 'stream', replacement: 'stream-browserify' }]
+    }),
+    nodePolyfills(),
+    babel({ babelHelpers: 'bundled', extensions }),
+    json(),
+    typescript()
+  ],
+  external: external.filter((dep) => !browserInternal.includes(dep))
+}
+
+const browserLegacyConfig = {
+  plugins: [
+    ignore(['web3', 'graceful-fs', 'node-localstorage']),
+    resolve({ extensions, preferBuiltins: true }),
+    commonjs({
+      extensions,
+      dynamicRequireTargets: [
+        'data-contracts/ABIs/*.json',
+        'eth-contracts/ABIs/*.json'
+      ]
+    }),
+    alias({
+      entries: [{ find: 'stream', replacement: 'stream-browserify' }]
+    }),
+    babel({ babelHelpers: 'bundled', extensions }),
+    json(),
+    typescript()
+  ],
+  external
+}
+
+const commonTypeConfig = {
+  plugins: [dts()]
+}
+
+export default [
+  /**
+   * SDK
+   */
+  {
+    input: 'src/index.js',
+    output: [
+      { file: pkg.main, format: 'cjs', exports: 'auto', sourcemap: true }
+    ],
+    ...commonConfig
+  },
+
+  {
+    input: './src/types.ts',
+    output: [{ file: pkg.types, format: 'cjs' }],
+    ...commonTypeConfig
+  },
+
+  /**
+   * SDK bundled for a browser environment (includes polyfills for node libraries)
+   * Does not include libs but does include polyfills
+   */
+  {
+    input: 'src/sdk/index.ts',
+    output: [
+      { file: pkg.browser, format: 'cjs', exports: 'auto', sourcemap: true }
+    ],
+    ...browserConfig
+  },
+
+  /**
+   * Legacy bundle for a browser environment
+   * Includes libs but does not include polyfills
+   */
+  {
+    input: 'src/index.js',
+    output: [
+      { file: pkg.legacy, format: 'cjs', exports: 'auto', sourcemap: true }
+    ],
+    ...browserLegacyConfig
+  },
+
+  {
+    input: './src/types.ts',
+    output: [{ file: pkg.legacyTypes, format: 'cjs' }],
+    ...commonTypeConfig
+  },
+
+  /**
+   * core (used for eager requests)
+   */
+  {
+    input: 'src/core.ts',
+    output: [
+      { file: pkg.core, format: 'cjs', exports: 'auto', sourcemap: true }
+    ],
+    ...commonConfig
+  },
+  {
+    input: './src/core.ts',
+    output: [{ file: pkg.coreTypes, format: 'cjs' }],
+    ...commonTypeConfig
+  }
+]