@audius/sdk 0.0.0

package/tests/governanceTest.js

@@ -0,0 +1,382 @@
+const helpers = require('./helpers')
+const assert = require('assert')
+const { convertAudsToWeiBN } = require('../initScripts/helpers/utils')
+const nock = require('nock')
+const { Vote } = require('../src/services/ethContracts/GovernanceClient')
+const time = require('@openzeppelin/test-helpers/src/time')
+const { initializeLibConfig } = require('./helpers')
+const AudiusLibs = require('../src')
+
+const { audiusInstance: audius0, getRandomLocalhost } = helpers
+
+let audius1
+let audius2
+let accounts = null
+let web3 = null
+let toBN = null
+let sp1
+let sp2
+const DEFAULT_STAKE = 210000
+const PROPOSAL_DESCRIPTION = 'TestDescription'
+const PROPOSAL_NAME = 'TestName'
+const testServiceType = 'discovery-provider'
+
+const setupAccounts = async () => {
+  // create additional libs instances
+  await audius0.init()
+  web3 = audius0.ethWeb3Manager.getWeb3()
+  toBN = web3.utils.toBN
+  accounts = await web3.eth.getAccounts()
+  sp1 = accounts[1]
+  sp2 = accounts[2]
+  const libsConf1 = await initializeLibConfig(sp1)
+  const libsConf2 = await initializeLibConfig(sp2)
+  audius1 = new AudiusLibs(libsConf1)
+  audius2 = new AudiusLibs(libsConf2)
+
+  // Init them all
+  await Promise.all([audius1.init(), audius2.init()])
+
+  // Register endpoints & stake
+  const inittedLibs = [audius0, audius1, audius2]
+  const defaultStake = convertAudsToWeiBN(
+    audius0.ethWeb3Manager.getWeb3(),
+    DEFAULT_STAKE
+  )
+  for (const lib of inittedLibs) {
+    const testEndpoint = getRandomLocalhost()
+    nock(testEndpoint)
+      .get('/health_check')
+      .reply(200, {
+        data: {
+          service: testServiceType,
+          version: '0.0.1'
+        }
+      })
+
+    await lib.ethContracts.ServiceProviderFactoryClient.register(
+      testServiceType,
+      testEndpoint,
+      defaultStake
+    )
+  }
+}
+
+const cleanupAccounts = async () => {
+  try {
+    await helpers.deregisterSPEndpoint(audius1, sp1, testServiceType)
+    await helpers.deregisterSPEndpoint(audius2, sp2, testServiceType)
+  } catch (e) {
+    console.error(e)
+    // no-op -- was already registered
+  }
+}
+
+const createProposal = () => {
+  const targetContractRegistryKey = web3.utils.utf8ToHex('DelegateManager')
+
+  const callValue = web3.utils.toWei('0', 'ether')
+  const functionSignature = 'slash(uint256,address)'
+  const slashAmount = web3.utils.toWei('500', 'ether')
+  const targetAddress = accounts[1]
+  const callData = [slashAmount, targetAddress]
+  const description = PROPOSAL_DESCRIPTION
+  const name = PROPOSAL_NAME
+
+  return {
+    targetContractRegistryKey,
+    callValue,
+    functionSignature,
+    callData,
+    name,
+    description
+  }
+}
+
+const submitProposal = async () => {
+  const proposal = createProposal()
+  return audius0.ethContracts.GovernanceClient.submitProposal(proposal)
+}
+
+const evaluateProposal = async (id, shouldVote = true) => {
+  // Vote
+  if (shouldVote) {
+    const voteYes = Vote.yes
+    await audius0.ethContracts.GovernanceClient.submitVote({
+      proposalId: id,
+      vote: voteYes
+    })
+  }
+
+  // Advance blocks
+  const currentBlock = (await web3.eth.getBlock('latest')).number
+  const desired = currentBlock + 20
+  await time.advanceBlockTo(desired)
+
+  // Evaluate
+  await audius0.ethContracts.GovernanceClient.evaluateProposalOutcome(id)
+}
+
+describe('Governance tests', function () {
+  this.timeout(5000)
+
+  before(async function () {
+    await setupAccounts()
+    await audius0.ethContracts.GovernanceClient.setVotingPeriod(10)
+    await audius0.ethContracts.GovernanceClient.setExecutionDelay(10)
+  })
+
+  afterEach(async function () {
+    // Cleanup outstanding proposals
+    const ids =
+      await audius0.ethContracts.GovernanceClient.getInProgressProposals()
+    for (let id of ids) {
+      await evaluateProposal(id, false)
+    }
+  })
+
+  after(async function () {
+    await cleanupAccounts()
+  })
+
+  it('Submits a proposal successfully', async function () {
+    const id = await submitProposal()
+    assert.ok(id >= 0)
+  })
+
+  it('Gets submitted proposal by ID', async function () {
+    // Submit the proposal
+    const id = await submitProposal()
+    const proposal =
+      await audius0.ethContracts.GovernanceClient.getProposalById(id)
+
+    // Sanity check proposal
+    assert.equal(proposal.proposalId, id)
+  })
+
+  it('Votes on proposals', async function () {
+    const id = await submitProposal()
+
+    // Submit a yes vote initially
+    const voteYes = Vote.yes
+    await audius0.ethContracts.GovernanceClient.submitVote({
+      proposalId: id,
+      vote: voteYes
+    })
+    const proposal =
+      await audius0.ethContracts.GovernanceClient.getProposalById(id)
+    const bnZero = toBN(0)
+    assert.ok(proposal.voteMagnitudeNo.eq(bnZero))
+    assert.ok(proposal.voteMagnitudeYes.gt(bnZero))
+
+    // Update the vote to be 'no'
+    const voteNo = Vote.no
+    await audius0.ethContracts.GovernanceClient.updateVote({
+      proposalId: id,
+      vote: voteNo
+    })
+    const proposal2 =
+      await audius0.ethContracts.GovernanceClient.getProposalById(id)
+    assert.ok(proposal2.voteMagnitudeYes.eq(bnZero))
+    assert.ok(proposal2.voteMagnitudeNo.gt(bnZero))
+  })
+
+  it('Queries for votes', async function () {
+    const id = await submitProposal()
+    const proposal =
+      await audius0.ethContracts.GovernanceClient.getProposalById(id)
+    const queryStartBlock = proposal.submissionBlockNumber
+    // Test for vote creation
+    const voteYes = Vote.yes
+    await audius0.ethContracts.GovernanceClient.submitVote({
+      proposalId: id,
+      vote: voteYes
+    })
+    const votes = await audius0.ethContracts.GovernanceClient.getVotes({
+      proposalId: id,
+      queryStartBlock
+    })
+    assert.equal(votes.length, 1)
+    assert.equal(votes[0].vote, 2)
+
+    // Test for vote update
+    const voteNo = Vote.no
+    await audius0.ethContracts.GovernanceClient.updateVote({
+      proposalId: id,
+      vote: voteNo
+    })
+    const updateVotes =
+      await audius0.ethContracts.GovernanceClient.getVoteUpdates({
+        proposalId: id,
+        queryStartBlock
+      })
+    assert.equal(updateVotes.length, 1)
+    assert.equal(updateVotes[0].vote, 1)
+  })
+
+  it('Gets in progress proposals', async function () {
+    const id = await submitProposal()
+    const inProgressIds =
+      await audius0.ethContracts.GovernanceClient.getInProgressProposals()
+    assert.equal(inProgressIds.length, 1)
+    assert.equal(inProgressIds[0], id)
+
+    // evaluate
+    await evaluateProposal(id)
+    const inProgressIds2 =
+      await audius0.ethContracts.GovernanceClient.getInProgressProposals()
+    assert.equal(inProgressIds2.length, 0)
+  })
+
+  it('Gets all proposals', async function () {
+    const blockNumber = await audius0.ethWeb3Manager
+      .getWeb3()
+      .eth.getBlockNumber()
+
+    const id = await submitProposal()
+    const inProgressIds =
+      await audius0.ethContracts.GovernanceClient.getProposals(blockNumber)
+    assert.equal(inProgressIds.length, 1)
+    assert.equal(inProgressIds[0].proposalId, id)
+
+    // evaluate
+    await evaluateProposal(id)
+    const inProgressIds2 =
+      await audius0.ethContracts.GovernanceClient.getProposals(blockNumber)
+    assert.equal(inProgressIds.length, 1)
+    assert.equal(inProgressIds[0].proposalId, id)
+  })
+
+  it('Gets a proposal evaluation', async function () {
+    const blockNumber = await audius0.ethWeb3Manager
+      .getWeb3()
+      .eth.getBlockNumber()
+
+    const id = await submitProposal()
+    await evaluateProposal(id)
+    const evaluation =
+      await audius0.ethContracts.GovernanceClient.getProposalEvaluation(id)
+    assert.equal(evaluation.length, 1)
+    assert.equal(evaluation[0].returnValues._numVotes, '1')
+  })
+
+  it('Gets a proposal submisson', async function () {
+    const blockNumber = await audius0.ethWeb3Manager
+      .getWeb3()
+      .eth.getBlockNumber()
+
+    const id = await submitProposal()
+    const submission =
+      await audius0.ethContracts.GovernanceClient.getProposalSubmission(id)
+    assert.equal(submission.description, PROPOSAL_DESCRIPTION)
+    assert.equal(submission.name, PROPOSAL_NAME)
+  })
+
+  it('Gets votes by address', async function () {
+    const id = await submitProposal()
+    const proposal =
+      await audius0.ethContracts.GovernanceClient.getProposalById(id)
+    const queryStartBlock = proposal.submissionBlockNumber
+
+    // submit votes
+    const voteYes = Vote.yes
+    const voteNo = Vote.no
+    await audius1.ethContracts.GovernanceClient.submitVote({
+      proposalId: id,
+      vote: voteYes
+    })
+    await audius2.ethContracts.GovernanceClient.submitVote({
+      proposalId: id,
+      vote: voteNo
+    })
+
+    // update some votes
+    await audius1.ethContracts.GovernanceClient.updateVote({
+      proposalId: id,
+      vote: voteNo
+    })
+    await audius2.ethContracts.GovernanceClient.updateVote({
+      proposalId: id,
+      vote: voteYes
+    })
+
+    // get submissions and updates
+    const account1Submissions =
+      await audius0.ethContracts.GovernanceClient.getVoteSubmissionsByAddress({
+        addresses: [accounts[1]],
+        queryStartBlock
+      })
+    const account2Updates =
+      await audius0.ethContracts.GovernanceClient.getVoteUpdatesByAddress({
+        addresses: [accounts[2]],
+        queryStartBlock
+      })
+
+    // assert filters work correctly
+    assert.equal(account1Submissions.length, 1)
+    assert.equal(account1Submissions[0].voter, accounts[1])
+    assert.equal(account2Updates.length, 1)
+    assert.equal(account2Updates[0].voter, accounts[2])
+  })
+
+  it('Gets Quorum Percent', async function () {
+    const percent =
+      await audius0.ethContracts.GovernanceClient.getVotingQuorumPercent()
+    assert.ok(typeof percent === 'number')
+  })
+
+  it('Gets voting period', async function () {
+    const period = await audius0.ethContracts.GovernanceClient.getVotingPeriod()
+    assert.ok(typeof period === 'number')
+  })
+
+  it('Gets execution delay', async function () {
+    const delay =
+      await audius0.ethContracts.GovernanceClient.getExecutionDelay()
+    assert.ok(typeof delay === 'number')
+  })
+
+  it('Gets target contract hash', async function () {
+    const id = await submitProposal()
+    const hash =
+      await audius0.ethContracts.GovernanceClient.getProposalTargetContractHash(
+        id
+      )
+    assert.ok(typeof hash === 'string')
+    assert.ok(hash.length > 0)
+  })
+
+  it('Gets vote by proposal and voter', async function () {
+    const id = await submitProposal()
+
+    // submit yes votes
+    const voteYes = Vote.yes
+    const voteNo = Vote.no
+    await audius1.ethContracts.GovernanceClient.submitVote({
+      proposalId: id,
+      vote: voteYes
+    })
+    const result =
+      await audius0.ethContracts.GovernanceClient.getVoteByProposalAndVoter({
+        proposalId: id,
+        voterAddress: accounts[1]
+      })
+    assert.equal(result, 2)
+
+    // submit yes vote, update to no vote
+    await audius2.ethContracts.GovernanceClient.submitVote({
+      proposalId: id,
+      vote: voteYes
+    })
+    await audius2.ethContracts.GovernanceClient.updateVote({
+      proposalId: id,
+      vote: voteNo
+    })
+    const result2 =
+      await audius0.ethContracts.GovernanceClient.getVoteByProposalAndVoter({
+        proposalId: id,
+        voterAddress: accounts[2]
+      })
+    assert.equal(result2, 1)
+  })
+})

package/tests/helpers.js

@@ -0,0 +1,105 @@
+const nock = require('nock')
+
+const Web3 = require('../src/web3')
+const AudiusLibs = require('../src/index')
+const dataContractsConfig = require('../data-contracts/config.json')
+const ethContractsConfig = require('../eth-contracts/config.json')
+
+const creatorNodeEndpoint = 'http://localhost:4000'
+const discoveryProviderEndpoint = 'http://localhost:5000'
+const identityServiceEndpoint = 'http://localhost:7000'
+const dataWeb3ProviderEndpoint = 'http://localhost:8545'
+const ethWeb3ProviderEndpoint = 'http://localhost:8546'
+require('@openzeppelin/test-helpers/configure')({
+  provider: ethWeb3ProviderEndpoint,
+})
+const isServer = true
+
+const constants = {
+  trackMetadataCID: 'QmSH5gJPHg9xLzV823ty8BSGyHNP6ty22bgLsv5MLY3kBq',
+  trackMetadataCID2: 'QmSH5gJPHg9xLzV823ty8BSGyHNP6ty22bgLaaaaaaaaaa',
+  creatorMetadataCID: 'QmTDhoEDLE3k3CE5bu4mF1ogsEVkPwEAM41KsN7hZX1eWY',
+  '0x0': '0x0000000000000000000000000000000000000000000000000000000000000000',
+  creatorNodeURL1: 'http://localhost:8000/',
+  creatorNodeURL2: 'http://localhost:8001/',
+  signatureData: 'Click sign to authenticate with creator node:1543885912',
+  signatureAddress: '0x7d267e2f8dc64c53267c56dab55bf7050566baec',
+  signature: '0xbb3ffe5f32950ace5c0a8ecb9c43ab836b7b7146a56e2519ac1c662e9b00bdcd7de9a3f3265206c54f0b8094f8ac8832d32d5852492c1aa3e9493e28ae3a31b91b',
+  wallet: '0xdfdbe819b5710b750b3a00eb2fae8a59b85c66af',
+  ethContractsConfig: ethContractsConfig
+}
+
+const dataWeb3 = new Web3(new Web3.providers.HttpProvider(dataWeb3ProviderEndpoint))
+const ethWeb3 = new Web3(new Web3.providers.HttpProvider(ethWeb3ProviderEndpoint))
+
+const audiusLibsConfig = {
+  web3Config: AudiusLibs.configExternalWeb3(
+    dataContractsConfig.registryAddress,
+    dataWeb3
+  ),
+  ethWeb3Config: AudiusLibs.configEthWeb3(
+    ethContractsConfig.audiusTokenAddress,
+    ethContractsConfig.registryAddress,
+    ethWeb3,
+    ethContractsConfig.ownerWallet
+  ),
+  isServer: true
+}
+
+async function initializeLibConfig (ownerWallet) {
+  return {
+    web3Config: AudiusLibs.configExternalWeb3(
+      dataContractsConfig.registryAddress,
+      dataWeb3
+    ),
+    ethWeb3Config: AudiusLibs.configEthWeb3(
+      ethContractsConfig.audiusTokenAddress,
+      ethContractsConfig.registryAddress,
+      ethWeb3,
+      ownerWallet
+    ),
+    isServer: true
+  }
+}
+
+const getRandomLocalhost = () => {
+  return 'https://localhost:' + Math.floor(1000 + Math.random() * 9000)
+}
+
+const deregisterSPEndpoint = async (libs, account, type) => {
+  let previousRegisteredId = await libs.ethContracts.ServiceProviderFactoryClient.getServiceProviderIdFromAddress(
+    account,
+    type)
+  let prevSpInfo = await libs.ethContracts.ServiceProviderFactoryClient.getServiceEndpointInfo(
+    type,
+    previousRegisteredId)
+
+  let path = '/version'
+  let response = {
+    service: type,
+    version : '0.0.1'
+  }
+
+  if (type === 'discovery-provider') {
+    path = '/health_check'
+    response = {data: {...response}}
+  }
+
+  nock(prevSpInfo.endpoint)
+    .get(path)
+    .reply(200, response)
+  let tx = await libs.ethContracts.ServiceProviderFactoryClient.deregister(
+    type,
+    prevSpInfo.endpoint)
+}
+
+module.exports = {
+  constants,
+  // Export configured libs instance
+  audiusInstance: new AudiusLibs(audiusLibsConfig),
+  // Export libs config for re-use
+  audiusLibsConfig,
+  initializeLibConfig,
+  getRandomLocalhost,
+  deregisterSPEndpoint
+}

package/tests/index.js

@@ -0,0 +1,14 @@
+require('./helpers')
+require('./registryClientTest')
+require('./userClientTest')
+require('./creatorNodeTest')
+require('./trackClientTest')
+require('./playlistClientTest')
+require('./socialFeatureClientTest')
+require('./serviceTypeManagerClientTest')
+require('./audiusTokenClientTest')
+require('./stakingTest')
+require('./providerSelectionTest')
+require('./governanceTest')
+require('./rewardsAttesterTest')
+require('./fileHasherTest')

package/tests/playlistClientTest.js

@@ -0,0 +1,157 @@
+const assert = require('assert')
+let helpers = require('./helpers')
+let {Utils} = require('../src/utils')
+
+let audiusInstance = helpers.audiusInstance
+let playlistOwnerId
+
+// First created playlist
+let playlistId = 1
+
+// Initial tracks
+let playlistTracks = []
+
+// Initial playlist configuration
+let initialPlaylistName = 'Test playlist name'
+let initialIsPrivate = false
+
+before(async function () {
+  await audiusInstance.init()
+  playlistOwnerId = (await audiusInstance.contracts.UserFactoryClient.addUser('playlistH')).userId
+
+  const cid = helpers.constants.trackMetadataCID // test metadata stored in DHT
+  const trackMultihashDecoded = Utils.decodeMultihash(cid)
+  playlistTracks.push((await audiusInstance.contracts.TrackFactoryClient.addTrack(
+    playlistOwnerId,
+    trackMultihashDecoded.digest,
+    trackMultihashDecoded.hashFn,
+    trackMultihashDecoded.size
+  )).trackId)
+  playlistTracks.push((await audiusInstance.contracts.TrackFactoryClient.addTrack(
+    playlistOwnerId,
+    trackMultihashDecoded.digest,
+    trackMultihashDecoded.hashFn,
+    trackMultihashDecoded.size
+  )).trackId)
+})
+
+// TODO: Add validation to the below test cases, currently they just perform chain operations.
+
+it('should create playlist', async function () {
+  const playlistId = await audiusInstance.contracts.PlaylistFactoryClient.createPlaylist(
+    playlistOwnerId,
+    initialPlaylistName,
+    initialIsPrivate,
+    false,
+    playlistTracks)
+})
+
+it('should create album', async function () {
+  const playlistId = await audiusInstance.contracts.PlaylistFactoryClient.createPlaylist(
+    playlistOwnerId,
+    initialPlaylistName,
+    initialIsPrivate,
+    true,
+    playlistTracks)
+})
+
+it('should create and delete playlist', async function () {
+  // create playlist
+  const { playlistId } = await audiusInstance.contracts.PlaylistFactoryClient.createPlaylist(
+    playlistOwnerId,
+    initialPlaylistName,
+    initialIsPrivate,
+    false,
+    playlistTracks)
+
+  // delete playlist + validate
+  const { playlistId: deletedPlaylistId } = await audiusInstance.contracts.PlaylistFactoryClient.deletePlaylist(playlistId)
+  assert.strictEqual(playlistId, deletedPlaylistId)
+})
+
+it('should add tracks to an existing playlist', async function () {
+  const cid = helpers.constants.trackMetadataCID // test metadata stored in DHT
+  const trackMultihashDecoded = Utils.decodeMultihash(cid)
+
+  // Add a new track
+  const { trackId } = await audiusInstance.contracts.TrackFactoryClient.addTrack(
+    playlistOwnerId,
+    trackMultihashDecoded.digest,
+    trackMultihashDecoded.hashFn,
+    trackMultihashDecoded.size
+  )
+  const track = await audiusInstance.contracts.TrackFactoryClient.getTrack(trackId)
+  assert.strictEqual(track.multihashDigest, trackMultihashDecoded.digest)
+
+  const addPlaylistTrackTx = await audiusInstance.contracts.PlaylistFactoryClient.addPlaylistTrack(
+    playlistId,
+    trackId)
+})
+
+it('should delete track from an existing playlist', async function () {
+  const cid = helpers.constants.trackMetadataCID // test metadata stored in DHT
+  const trackMultihashDecoded = Utils.decodeMultihash(cid)
+
+  // Add a new track
+  const { trackId } = await audiusInstance.contracts.TrackFactoryClient.addTrack(
+    playlistOwnerId,
+    trackMultihashDecoded.digest,
+    trackMultihashDecoded.hashFn,
+    trackMultihashDecoded.size
+  )
+  const track = await audiusInstance.contracts.TrackFactoryClient.getTrack(trackId)
+  assert.strictEqual(track.multihashDigest, trackMultihashDecoded.digest)
+
+  const addPlaylistTrackTx = await audiusInstance.contracts.PlaylistFactoryClient.addPlaylistTrack(
+    playlistId,
+    trackId)
+
+  const deletedTimestamp = 1552008725
+  // Delete the newly added track from the playlist
+  const deletedPlaylistTrackTx = await audiusInstance.contracts.PlaylistFactoryClient.deletePlaylistTrack(
+    playlistId,
+    trackId,
+    deletedTimestamp)
+})
+
+it('should reorder tracks in an existing playlist', async function () {
+  playlistTracks.push(playlistTracks.shift()) // put first element at end
+  const orderTracksTx = await audiusInstance.contracts.PlaylistFactoryClient.orderPlaylistTracks(
+    playlistId,
+    playlistTracks)
+})
+
+it('should update playlist privacy', async function () {
+  const updatedPrivacy = false
+  const updatePlaylistPrivacyTx = await audiusInstance.contracts.PlaylistFactoryClient.updatePlaylistPrivacy(
+    playlistId,
+    updatedPrivacy)
+})
+
+it('should update playlist name', async function () {
+  const updatedPlaylistName = 'Here is my updated playlist name'
+  const updatePlaylistNameTx = await audiusInstance.contracts.PlaylistFactoryClient.updatePlaylistName(
+    playlistId,
+    updatedPlaylistName)
+})
+
+it('should update playlist cover photo', async function () {
+  const cid = helpers.constants.trackMetadataCID // test metadata stored in DHT
+  const trackMultihashDecoded = Utils.decodeMultihash(cid)
+  const testPhotoDigest = trackMultihashDecoded.digest
+  const updatePlaylistCoverPhotoTx = await audiusInstance.contracts.PlaylistFactoryClient.updatePlaylistCoverPhoto(
+    playlistId,
+    testPhotoDigest)
+})
+
+it('should update playlist description', async function () {
+  const description = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis'
+  const updatePlaylistDescriptionTx = await audiusInstance.contracts.PlaylistFactoryClient.updatePlaylistDescription(
+    playlistId,
+    description)
+})
+
+it('should update playlist UPC', async function () {
+  const newUPC = '928152343234'
+  const updatePlaylistUPC = await audiusInstance.contracts.PlaylistFactoryClient.updatePlaylistUPC(playlistId, newUPC)
+})