@audius/sdk 0.0.0

package/src/utils/utils.ts

@@ -0,0 +1,235 @@
+import bs58 from 'bs58'
+import Web3 from '../web3'
+import axios, { AxiosResponse } from 'axios'
+import Hashids from 'hashids/cjs'
+import { MultiProvider } from './multiProvider'
+import { uuid } from './uuid'
+import {
+  importDataContractABIs,
+  importEthContractABIs
+} from './importContractABI'
+import { fileHasher } from './fileHasher'
+import type { ImageHasher, NonImageHasher, HashedImage } from './fileHasher'
+
+// Hashids
+
+const HASH_SALT = 'azowernasdfoia'
+const MIN_LENGTH = 5
+const hashids = new Hashids(HASH_SALT, MIN_LENGTH)
+
+const ZeroAddress = '0x0000000000000000000000000000000000000000'
+
+export type { ImageHasher, NonImageHasher, HashedImage }
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class -- this should just be esm
+export class Utils {
+  static importDataContractABI(pathStr: string) {
+    return importDataContractABIs(pathStr)
+  }
+
+  static importEthContractABI(pathStr: string) {
+    return importEthContractABIs(pathStr)
+  }
+
+  static utf8ToHex(utf8Str: string) {
+    return Web3.utils.utf8ToHex(utf8Str)
+  }
+
+  static padRight(hexStr: string, size: number) {
+    return Web3.utils.padRight(hexStr, size)
+  }
+
+  static hexToUtf8(hexStr: string) {
+    return Web3.utils.hexToUtf8(hexStr)
+  }
+
+  static keccak256(utf8Str: string) {
+    return Web3.utils.keccak256(utf8Str)
+  }
+
+  static isBN(number: number | string) {
+    return Web3.utils.isBN(number)
+  }
+
+  static toBN(number: number, base?: number) {
+    return new Web3.utils.BN(number, base)
+  }
+
+  static BN() {
+    return Web3.utils.BN
+  }
+
+  static checkStrLen(str: string, maxLen: number, minLen = 1) {
+    if (
+      str === undefined ||
+      str === null ||
+      str.length > maxLen ||
+      str.length < minLen
+    ) {
+      throw new Error(
+        `String '${str}' must be between ${minLen}-${maxLen} characters`
+      )
+    }
+  }
+
+  static async wait(milliseconds: number) {
+    return await new Promise<void>((resolve) =>
+      setTimeout(resolve, milliseconds)
+    )
+  }
+
+  // Regular expression to check if endpoint is a FQDN. https://regex101.com/r/kIowvx/2
+  static isFQDN(url: string) {
+    const FQDN =
+      /(?:^|[ \t])((https?:\/\/)?(?:localhost|[\w-]+(?:\.[\w-]+)+)(:\d+)?(\/\S*)?)/gm
+    return FQDN.test(url)
+  }
+
+  static isHttps(url: string) {
+    const https = /^https:\/\//
+    return https.test(url)
+  }
+
+  // Function to check if the endpont/health_check returns JSON object [ {'healthy':true} ]
+  static async isHealthy(url: string) {
+    try {
+      const { data: body } = await axios.get(url + '/health_check')
+      return body.data.healthy
+    } catch (error) {
+      return false
+    }
+  }
+
+  static formatOptionalMultihash(multihash: string) {
+    if (multihash) {
+      return this.decodeMultihash(multihash).digest
+    } else {
+      return this.utf8ToHex('')
+    }
+  }
+
+  static decodeMultihash(multihash: string) {
+    const base16Multihash = bs58.decode(multihash)
+    return {
+      digest: `0x${base16Multihash.slice(2).toString('hex')}`,
+      hashFn: parseInt(base16Multihash[0] as unknown as string),
+      size: parseInt(base16Multihash[1] as unknown as string)
+    }
+  }
+
+  /**
+   * Given a digest value (written on chain, obtained through AudiusABIDecoder.decodeMethod),
+   * convert back to a IFPS CIDv0
+   * @param multihashDigest digest value from decodeMultihash
+   * @returns String CID value
+   */
+  static encodeMultihash(multihashDigest: string) {
+    // the 1220 is from reconstructing the hashFn and size with digest, the opposite of decodeMultihash
+    // since IPFS CIDv0 has a fixed hashFn and size, the first two values are always 12 and 20
+    // concat them together with digest and encode back to base58
+    const digestStr = `1220${multihashDigest.replace('0x', '')}`
+    // convert digestStr from hex to base 58
+    return bs58.encode(Buffer.from(digestStr, 'hex'))
+  }
+
+  static parseDataFromResponse(response: AxiosResponse) {
+    if (!response || !response.data) return null
+
+    const obj = response.data
+
+    // adapted from https://github.com/jashkenas/underscore/blob/master/underscore.js _.isEmpty function
+    if (obj == null) return null
+    if ((Array.isArray(obj) || typeof obj === 'string') && obj.length === 0)
+      return null
+    if (Object.keys(obj).length === 0) return null
+
+    return obj
+  }
+
+  static async configureWeb3(
+    web3Provider: string,
+    chainNetworkId: string,
+    requiresAccount = true
+  ) {
+    // Initializing web3 with a HttpProvider wrapper for multiple providers
+    // ref: https://github.com/ChainSafe/web3.js/blob/1.x/packages/web3/types/index.d.ts#L31.
+    const web3Instance = new Web3(new MultiProvider(web3Provider))
+
+    try {
+      const networkId = await web3Instance.eth.net.getId()
+      if (chainNetworkId && networkId.toString() !== chainNetworkId) {
+        return false
+      }
+      if (requiresAccount) {
+        const accounts = await web3Instance.eth.getAccounts()
+        if (!accounts || accounts.length < 1) {
+          return false
+        }
+      }
+    } catch (e) {
+      return false
+    }
+
+    return web3Instance
+  }
+
+  static get zeroAddress() {
+    return ZeroAddress
+  }
+
+  static isZeroAddress(address: string) {
+    return address === Utils.zeroAddress
+  }
+
+  static makeUuid() {
+    return uuid()
+  }
+
+  /**
+   * Decodes a string id into an int. Returns null if an invalid ID.
+   */
+  static decodeHashId(id: string) {
+    try {
+      const ids = hashids.decode(id)
+      if (!ids.length) return null
+      const num = Number(ids[0])
+      if (isNaN(num)) return null
+      return num
+    } catch (e) {
+      console.error(`Failed to decode ${id}`, e)
+      return null
+    }
+  }
+
+  /**
+   * Encodes an int to a string based hashid
+   */
+  static encodeHashId(id: number | null) {
+    try {
+      if (id === null) return null
+      const encodedId = hashids.encode(id)
+      return encodedId
+    } catch (e) {
+      console.error(`Failed to encode ${id}`, e)
+      return null
+    }
+  }
+
+  /**
+   * If `promise` responds before `timeoutMs`,
+   * this function returns its response; else rejects with `timeoutMessage`
+   */
+  static async racePromiseWithTimeout(
+    promise: Promise<void>,
+    timeoutMs: number,
+    timeoutMessage: string
+  ) {
+    // eslint-disable-next-line promise/param-names
+    const timeoutPromise = new Promise((_promise, reject) => {
+      setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs)
+    })
+    return await Promise.race([promise, timeoutPromise])
+  }
+
+  static fileHasher = fileHasher
+}

package/src/utils/uuid.ts

@@ -0,0 +1,14 @@
+export const uuid = () => {
+  // https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript/873856#873856
+  const s = []
+  const hexDigits = '0123456789abcdef'
+  for (let i = 0; i < 36; i++) {
+    s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1)
+  }
+  s[14] = '4' // bits 12-15 of the time_hi_and_version field to 0010
+  s[19] = hexDigits.substr((s[19] as string & 0x3) | 0x8, 1) // bits 6-7 of the clock_seq_hi_and_reserved to 01
+  s[8] = s[13] = s[18] = s[23] = '-'
+
+  const uuid = s.join('')
+  return uuid
+}

package/src/web3.d.ts

@@ -0,0 +1,9 @@
+import Web3Type from 'web3'
+import BN from 'bn.js'
+declare const Web3: typeof Web3Type & {
+  utils: {
+    BN: typeof BN
+  }
+}
+
+export default Web3

package/src/web3.js

@@ -0,0 +1,8 @@
+let Web3
+if (typeof window !== 'undefined' && window && window.Web3) {
+  Web3 = window.Web3
+} else {
+  Web3 = require('web3')
+}
+
+module.exports = Web3

package/tests/assets/static_text.txt

@@ -0,0 +1 @@
+is mayonnaise an instrument

package/tests/audiusTokenClientTest.js

@@ -0,0 +1,37 @@
+const assert = require('assert')
+const helpers = require('./helpers')
+
+const libs = helpers.audiusInstance
+
+let token
+let ownerWallet
+let accounts
+let initialSupply
+
+before(async function () {
+  await libs.init()
+  token = libs.ethContracts.AudiusTokenClient
+  ownerWallet = libs.ethWeb3Manager.getWalletAddress()
+  accounts = await libs.ethWeb3Manager.getWeb3().eth.getAccounts()
+  toBN = libs.ethWeb3Manager.getWeb3().utils.toBN
+})
+
+it('Should test transfer', async function () {
+  const initialOwnerBalance = await token.balanceOf(ownerWallet)
+  const initialAccount1Balance = await token.balanceOf(accounts[1])
+  const amount = toBN('1000')
+  await token.transfer(accounts[1], amount)
+
+  const finalOwnerBalance = await token.balanceOf(ownerWallet)
+  const finalAccount1Balance = await token.balanceOf(accounts[1])
+  const expectedOwnerBalance = initialOwnerBalance.sub(amount)
+  const expectedAccount1Balance = initialAccount1Balance.add(amount)
+  assert(
+    finalOwnerBalance.eq(expectedOwnerBalance),
+    'Expect owner balance to decrease'
+  )
+  assert(
+    finalAccount1Balance.eq(expectedAccount1Balance),
+    'Expect account 1 balance to increase'
+  )
+})

package/tests/creatorNodeTest.js

@@ -0,0 +1,19 @@
+const assert = require('assert')
+let helpers = require('./helpers')
+
+let audiusInstance = helpers.audiusInstance
+
+before(async function () {
+  await audiusInstance.init()
+})
+
+it('should verify signature', async function () {
+  const address = await audiusInstance.web3Manager.verifySignature(helpers.constants.signatureData, helpers.constants.signature)
+  assert.strictEqual(address, helpers.constants.signatureAddress)
+})
+
+it('should detect malformed signature', async function () {
+  const malformedData = helpers.constants.signatureData.replace('1', '2')
+  const address = await audiusInstance.web3Manager.verifySignature(malformedData, helpers.constants.signature)
+  assert.notStrictEqual(address, helpers.constants.signatureAddress)
+})

package/tests/fileHasherTest.js

@@ -0,0 +1,125 @@
+const assert = require('assert')
+const fs = require('fs')
+const path = require('path')
+const uuid = require('uuid')
+const sinon = require('sinon')
+
+const { Utils } = require('../src/utils')
+
+describe('test fileHasher with randomized text content', () => {
+  let randomText, randomTextFilePath
+
+  const createRandomText = () => {
+    return uuid.v4()
+  }
+
+  const createRandomTextFile = () => {
+    const filePath = path.join(__dirname, './assets/random.txt')
+    fs.writeFileSync(filePath, createRandomText())
+  }
+
+  before(() => {
+    createRandomTextFile()
+    randomText = createRandomText()
+    randomTextFilePath = path.join(__dirname, './assets/random.txt')
+  })
+
+  afterEach(() => {
+    sinon.restore()
+  })
+
+  it('[random - generateNonImageCid] passing in improper content throws', async () => {
+    try {
+      await Utils.fileHasher.generateNonImageCid(randomText)
+      throw new Error('passing in improper data should have failed')
+    } catch (e) {
+      assert.ok(e.toString().includes('Could not convert content into buffer'))
+    }
+  })
+
+  it('[random - generateNonImageCids] if `hashNonImages()` errors, `generateNonImageCid()` throws', async () => {
+    sinon
+      .stub(Utils.fileHasher, 'hashNonImages')
+      .throws(new Error('failed to generate only hash'))
+
+    try {
+      await Utils.fileHasher.generateNonImageCid(randomTextFilePath)
+      throw new Error(
+        '`generateNonImageCid` should throw if `hashNonImages` fails'
+      )
+    } catch (e) {
+      assert.ok(e.toString().includes('failed to generate only hash'))
+    }
+  })
+
+  it('[random - generateImageCids] if `hashImages()` errors, `generateImageCids()` throws', async () => {
+    sinon
+      .stub(Utils.fileHasher, 'hashImages')
+      .throws(new Error('failed to generate only hash'))
+
+    try {
+      await Utils.fileHasher.generateImageCids(randomTextFilePath)
+      throw new Error(
+        '`generateImageCids` should throw if `hashImages` fails'
+      )
+    } catch (e) {
+      assert.ok(e.toString().includes('failed to generate only hash'))
+    }
+  })
+})
+
+describe('test FileHasher with static content', () => {
+  const staticTextPath = path.join(__dirname, './assets/static_text.txt')
+  const staticImagePath = path.join(__dirname, './assets/static_image.png')
+
+  const files = [
+    // index 0 - static text
+    {
+      type: 'text',
+      path: staticTextPath,
+      buffer: fs.readFileSync(staticTextPath),
+      cid: 'QmNXk37dMvg8QYhy2S8AtV8stQRDCL91ybCretxFK8R4Yd'
+    },
+    // index 1 - static image
+    {
+      type: 'image',
+      path: staticImagePath,
+      buffer: fs.readFileSync(staticImagePath),
+      cid: 'QmQzgdAxHH2jsthbwHg6mGonniu2quqJPYNankGUK2Sn8a'
+    }
+  ]
+
+  afterEach(() => {
+    sinon.restore()
+  })
+
+  for (let i = 0; i < files.length; i++) {
+    const filePath = files[i].path
+
+    it('[static - generateNonImageCid] passing in improper content throws', async () => {
+      try {
+        await Utils.fileHasher.generateNonImageCid('some static string')
+        throw new Error('passing in improper data should have failed')
+      } catch (e) {
+        assert.ok(
+          e.toString().includes('Could not convert content into buffer')
+        )
+      }
+    })
+
+    it('[static - generateNonImageCid] if `hashNonImages()` errors, `generateNonImageCid()` throws', async () => {
+      sinon
+        .stub(Utils.fileHasher, 'hashNonImages')
+        .throws(new Error('failed to generate only hash'))
+
+      try {
+        await Utils.fileHasher.generateNonImageCid(filePath)
+        throw new Error(
+          '`generateNonImageCid` should throw if `hashNonImages` fails'
+        )
+      } catch (e) {
+        assert.ok(e.toString().includes('failed to generate only hash'))
+      }
+    })
+  }
+})