@audius/sdk 0.0.0

package/tests/providerSelectionTest.js

@@ -0,0 +1,241 @@
+const assert = require('assert')
+const sinon = require('sinon')
+
+const { ContractClient } = require('../src/services/contracts/ContractClient')
+const { Web3Manager } = require('../src/services/web3Manager')
+const { EthWeb3Manager } = require('../src/services/ethWeb3Manager')
+
+const CONTRACT_INIT_MAX_ATTEMPTS = 5
+
+let contractClient
+
+describe('Testing ContractClient class with ProviderSelection', () => {
+  afterEach(async () => {
+    // Reset stub
+    sinon.restore()
+  })
+
+  /**
+   * Given: audius gateway is healthy
+   * When: we do contract logic
+   * Should: do not use provider selection logic and use initially set audius gateway
+   */
+  it('should use initial audius gateway if healthy', async () => {
+    contractClient = createContractClientWithInternalWeb3()
+    sinon
+      .stub(contractClient.web3Manager.web3.eth, 'Contract')
+      .callsFake((arg1, arg2) => {
+        return arg1
+      })
+    const initWithProviderSelectionSpy = sinon.spy(contractClient, 'init')
+    const consoleSpy = sinon.spy(console, 'error')
+
+    await contractClient.init()
+
+    assert.strictEqual(
+      contractClient.web3Manager.getWeb3().currentProvider.host,
+      'https://audius.poa.network'
+    )
+    assert(initWithProviderSelectionSpy.calledOnce)
+    assert(consoleSpy.notCalled)
+  })
+
+  /**
+   * Given: both gatetways are unhealthy
+   * When: we do contract logic
+   * Should: try both gateways and then log error
+   *
+   * @notice when web3 is set to a new object, the second call will throw a different error
+   *    that is acceptable as we don't care about what the error is
+   */
+  it('should log error if both audius gateway and public gateway are unhealthy', async () => {
+    contractClient = createContractClientWithInternalWeb3()
+    sinon
+      .stub(contractClient.web3Manager.web3.eth, 'Contract')
+      .callsFake((arg1, arg2) => {
+        throw new Error('Bad provider')
+      })
+    const initWithProviderSelectionSpy = sinon.spy(contractClient, 'init')
+    const consoleSpy = sinon.spy(console, 'error')
+
+    await contractClient.init()
+
+    assert(
+      initWithProviderSelectionSpy.callCount === CONTRACT_INIT_MAX_ATTEMPTS
+    )
+    assert(consoleSpy.callCount === CONTRACT_INIT_MAX_ATTEMPTS)
+  })
+
+  /**
+   * Given: contractClient.web3Manager is instanceof ethWeb3Manager
+   * When: contract logic passes
+   * Should: pass on first try and use initially set gateway
+   */
+  it('should use initial gateway url if web3Manager is instanceof ethWeb3Manager and contract logic passes', async () => {
+    contractClient = createContractClientWithEthWeb3Manager()
+    sinon
+      .stub(contractClient.web3Manager.web3.eth, 'Contract')
+      .callsFake((arg1, arg2) => {
+        return arg1
+      })
+    const initWithProviderSelectionSpy = sinon.spy(contractClient, 'init')
+    const consoleSpy = sinon.spy(console, 'error')
+
+    await contractClient.init()
+
+    assert.strictEqual(
+      contractClient.web3Manager.getWeb3().currentProvider.host,
+      'https://eth.network'
+    )
+    assert(initWithProviderSelectionSpy.calledOnce)
+    assert(consoleSpy.notCalled)
+  })
+
+  /**
+   * Given: contractClient.web3Manager is instanceof ethWeb3Manager
+   * When: contract logic fails
+   * Should: do not do retry logic and log error
+   */
+  it('should log error if web3Manager is instanceof ethWeb3Manager and contract logic fails', async () => {
+    contractClient = createContractClientWithEthWeb3Manager()
+    sinon
+      .stub(contractClient.web3Manager.web3.eth, 'Contract')
+      .callsFake((arg1, arg2) => {
+        throw new Error('Bad provider')
+      })
+    const initWithProviderSelectionSpy = sinon.spy(contractClient, 'init')
+    const consoleSpy = sinon.spy(console, 'error')
+
+    await contractClient.init()
+
+    assert.strictEqual(
+      contractClient.web3Manager.getWeb3().currentProvider.host,
+      'https://eth.network'
+    )
+    assert(
+      initWithProviderSelectionSpy.callCount === CONTRACT_INIT_MAX_ATTEMPTS
+    )
+    assert(consoleSpy.callCount === CONTRACT_INIT_MAX_ATTEMPTS)
+  })
+
+  /**
+   * Given: we are using an external web3
+   * When: contract logic passes
+   * Should: pass on first try and use initially set gateway
+   */
+  it('should use initial gateway url if useExternalWeb3 is true and contract logic passes', async () => {
+    contractClient = createContractClientWithExternalWeb3()
+    sinon
+      .stub(contractClient.web3Manager.web3.eth, 'Contract')
+      .callsFake((arg1, arg2) => {
+        return arg1
+      })
+    const initWithProviderSelectionSpy = sinon.spy(contractClient, 'init')
+    const consoleSpy = sinon.spy(console, 'error')
+
+    await contractClient.init()
+
+    assert.strictEqual(
+      contractClient.web3Manager.getWeb3().currentProvider.host,
+      'https://audius.poa.network'
+    )
+    assert(initWithProviderSelectionSpy.calledOnce)
+    assert(consoleSpy.notCalled)
+  })
+
+  /**
+   * Given: we are using an external web3
+   * When: contract logic fails
+   * Should: do not do retry logic and log error
+   */
+  it('should log error if useExternalWeb3 is true and contract logic fails', async () => {
+    contractClient = createContractClientWithExternalWeb3()
+    sinon
+      .stub(contractClient.web3Manager.web3.eth, 'Contract')
+      .callsFake((arg1, arg2) => {
+        throw new Error('Bad provider')
+      })
+    const initWithProviderSelectionSpy = sinon.spy(contractClient, 'init')
+    const consoleSpy = sinon.spy(console, 'error')
+
+    await contractClient.init()
+
+    assert(
+      initWithProviderSelectionSpy.callCount === CONTRACT_INIT_MAX_ATTEMPTS
+    )
+    assert(consoleSpy.callCount === CONTRACT_INIT_MAX_ATTEMPTS)
+  })
+})
+// Helper stub and functions for providerSelectionTest
+
+// Available providers
+const gateways = ['https://audius.poa.network', 'https://public.poa.network']
+
+// Creates barebones web3 object
+function createWeb3Obj(host) {
+  return {
+    currentProvider: {
+      host
+    },
+    eth: {
+      Contract: () => {}
+    }
+  }
+}
+
+// Helper functions to create ContractClient instances with the appropriate properties
+
+function createContractClient(web3Manager) {
+  const getRegistryAddressFn = () => {
+    return '0xaaaaaaaaaaaaaaaaaaa'
+  }
+
+  if (web3Manager instanceof Web3Manager) {
+    sinon.stub(web3Manager, 'provider').callsFake((arg1, arg2) => {
+      return arg1
+    })
+  }
+
+  return new ContractClient(
+    web3Manager,
+    'contractABI',
+    'contractRegistryKey',
+    getRegistryAddressFn
+  )
+}
+
+function createContractClientWithInternalWeb3() {
+  const web3Config = {
+    useExternalWeb3: false,
+    internalWeb3Config: {
+      web3ProviderEndpoints: gateways
+    }
+  }
+  const web3Manager = new Web3Manager()
+  web3Manager.web3 = createWeb3Obj('https://audius.poa.network')
+  web3Manager.web3Config = web3Config
+  return createContractClient(web3Manager)
+}
+
+function createContractClientWithExternalWeb3() {
+  const web3Config = {
+    useExternalWeb3: true,
+    internalWeb3Config: {
+      web3ProviderEndpoints: gateways
+    }
+  }
+  const web3Manager = new Web3Manager()
+  web3Manager.web3 = createWeb3Obj('https://audius.poa.network')
+  web3Manager.web3Config = web3Config
+  return createContractClient(web3Manager)
+}
+
+function createContractClientWithEthWeb3Manager() {
+  const web3Config = {
+    providers: ['https://audius.eth.network'],
+    ownerWallet: '0xwallet'
+  }
+  const ethWeb3Manager = new EthWeb3Manager(web3Config)
+  ethWeb3Manager.web3 = createWeb3Obj('https://eth.network')
+  return createContractClient(ethWeb3Manager)
+}

package/tests/registryClientTest.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 call getContract for creatorStorage key', async function () {
+  let address = await audiusInstance.contracts.RegistryClient.getContract('creatorStorage')
+  assert.notStrictEqual(address, helpers.constants['0x0'])
+})
+
+it('should call getContract for nonexistent key', async function () {
+  let address = await audiusInstance.contracts.RegistryClient.getContract('nonexistent')
+  // not helpers 0x0 because it's not a bytes32 zero value, different number of 0's
+  assert.strictEqual(address, '0x0000000000000000000000000000000000000000')
+})

package/tests/rewardsAttesterTest.js

@@ -0,0 +1,373 @@
+const assert = require('assert')
+const sinon = require('sinon')
+const {
+  AttestationPhases,
+  SubmitAndEvaluateError
+} = require('../src/api/rewards')
+const {
+  RewardsAttester,
+  AttestationDelayCalculator
+} = require('../src/services/solanaWeb3Manager/rewardsAttester')
+const { Utils } = require('../src/utils')
+const { encodeHashId } = Utils
+
+function MockLibs(getSlot = () => 100, getBlockNumber = () => 100) {
+  this.getSlot = getSlot
+  this.getBlockNumber = getBlockNumber
+  this.solanaWeb3Manager = {
+    getSlot: () => this.getSlot(),
+    hasBalance: ({ publicKey }) => true
+  }
+  this.web3Manager = {
+    getWeb3: () => ({
+      eth: {
+        getBlockNumber: () => this.getBlockNumber()
+      }
+    })
+  }
+  this.Rewards = {
+    submitAndEvaluate: (args) => {},
+    getUndisbursedChallenges: (args) => {},
+    ServiceProvider: {
+      getUniquelyOwnedDiscoveryNodes: (quorumSize, nodes) => {
+        return nodes.slice(0, quorumSize)
+      }
+    }
+  }
+  this.discoveryProvider = {
+    serviceSelector: {
+      findAll: ({ whitelist }) => {
+        return whitelist
+      }
+    }
+  }
+}
+
+let calc = null
+
+describe('Delay calculator tests', () => {
+  afterEach(async () => {
+    calc.stop()
+  })
+
+  it('Should get Slot and block threshold on fresh start', async () => {
+    calc = new AttestationDelayCalculator({
+      libs: new MockLibs(
+        () => 100,
+        () => 100
+      ),
+      runBehindSec: 5,
+      allowedStalenessSec: 1
+    })
+    await calc.start()
+    const slotThreshold = await calc.getSolanaSlotThreshold()
+    // Should be 90: 100 - 5 / 0.5 block/sec
+    assert.strictEqual(slotThreshold, 90)
+
+    const blockThreshold = await calc.getPOABlockThreshold()
+    // Should be 99: 100 - 5 / 5
+    assert.strictEqual(blockThreshold, 99)
+  })
+
+  it('Should cache slot and block values', async () => {
+    const libs = new MockLibs(
+      () => 100,
+      () => 100
+    )
+    calc = new AttestationDelayCalculator({
+      libs,
+      runBehindSec: 5,
+      allowedStalenessSec: 1
+    })
+    await calc.start()
+    await calc.getSolanaSlotThreshold()
+    await calc.getPOABlockThreshold()
+
+    // Test cached values
+    libs.getSlot = () => 110
+    libs.getBlockNumber = () => 110
+    const slotThreshold = await calc.getSolanaSlotThreshold()
+    assert.strictEqual(slotThreshold, 90)
+    const blockThreshold = await calc.getPOABlockThreshold()
+    assert.strictEqual(blockThreshold, 99)
+  })
+
+  it('Should get new values after the cache expires', async () => {
+    const libs = new MockLibs(
+      () => 100,
+      () => 100
+    )
+    calc = new AttestationDelayCalculator({
+      libs,
+      runBehindSec: 5,
+      allowedStalenessSec: 1
+    })
+    await calc.start()
+    await calc.getSolanaSlotThreshold()
+    await calc.getPOABlockThreshold()
+
+    // Test cached values
+    await new Promise((res) => setTimeout(res, 1100))
+    libs.getSlot = () => 110
+    libs.getBlockNumber = () => 110
+    const slotThreshold = await calc.getSolanaSlotThreshold()
+    assert.strictEqual(slotThreshold, 100)
+    const blockThreshold = await calc.getPOABlockThreshold()
+    assert.strictEqual(blockThreshold, 109)
+  })
+
+  it('Should update the solana slot properly', async () => {
+    const solSlot = {
+      last: 100
+    }
+    // new slots every 250ms
+    const i = setInterval(() => {
+      solSlot.last += 1
+    }, 250)
+
+    const libs = new MockLibs(
+      () => solSlot.last,
+      () => 100
+    )
+
+    calc = new AttestationDelayCalculator({
+      libs,
+      runBehindSec: 5,
+      allowedStalenessSec: 1,
+      solanaPollingInterval: 0.5
+    })
+    calc.start()
+    const slotThreshold1 = await calc.getSolanaSlotThreshold()
+    // Initially this should be 0.5sec/slot
+    assert.strictEqual(slotThreshold1, 90)
+
+    // Wait for staleness interval
+    await new Promise((res) => setTimeout(res, 1100))
+    const slotThreshold2 = await calc.getSolanaSlotThreshold()
+    // Current slot should be 104, and there should be 4 slots/sec,
+    // so 5 sec lag behind = 104 - 5 * 4 = 84
+    assert.strictEqual(slotThreshold2, 84)
+
+    clearInterval(i)
+  })
+})
+
+describe('Rewards Attester Tests', () => {
+  afterEach(async () => {
+    sinon.restore()
+  })
+
+  it('Should handle happy path attestation loop', async () => {
+    const libs = new MockLibs()
+
+    const attester = new RewardsAttester({
+      libs,
+      startingBlock: 0,
+      offset: 0,
+      parallelization: 2,
+      quorumSize: 2,
+      aaoEndpoint: 'https://fakeaao.co',
+      aaoAddress: '0xFakeOracle',
+      challengeIdsDenyList: [],
+      endpoints: ['https://dn1.co', 'https://dn2.co', 'https://dn3.co'],
+      isSolanaChallenge: () => false,
+      feePayerOverride: 'test feepayer override'
+    })
+
+    const rewardsMock = sinon.mock(libs.Rewards)
+
+    rewardsMock
+      .expects('getUndisbursedChallenges')
+      .exactly(3)
+      .onFirstCall()
+      .returns(withSuccess([1, 2].map((i) => makeChallenge(i, i))))
+      .onSecondCall()
+      .returns(withSuccess([3, 4].map((i) => makeChallenge(i, i))))
+      .onThirdCall()
+      .callsFake(() => {
+        attester.stop()
+        return {
+          success: []
+        }
+      })
+
+    rewardsMock
+      .expects('submitAndEvaluate')
+      .exactly(4)
+      .returns({ success: true })
+
+    await attester.start()
+    assert.equal(attester.startingBlock, 3)
+    assert.equal(attester.offset, 0)
+    rewardsMock.verify()
+  })
+
+  it('Sets offset correctly for unretryable errors with same starting block', async () => {
+    // This tests that we *add* offsets correctly if each challenge we return has the same starting block.
+    // For this test, fetch challenges in batches of 2, and the first 4 all share the same completed block
+    // and are unretryable, so the offset should be 4 by the end
+    const libs = new MockLibs()
+    const rewardsStub = sinon.stub(libs.Rewards)
+
+    const attester = new RewardsAttester({
+      libs,
+      startingBlock: 0,
+      offset: 0,
+      parallelization: 2,
+      quorumSize: 2,
+      aaoEndpoint: 'https://fakeaao.co',
+      aaoAddress: '0xFakeOracle',
+      challengeIdsDenyList: [],
+      endpoints: ['https://dn1.co', 'https://dn2.co', 'https://dn3.co'],
+      isSolanaChallenge: () => false,
+      feePayerOverride: 'test feepayer override'
+    })
+
+    const [attesterPromise, resolve] = makeAttesterPromise()
+
+    rewardsStub.getUndisbursedChallenges
+      .onFirstCall()
+      .returns(withSuccess([0, 1].map((i) => makeChallenge(i, 1))))
+      .onSecondCall()
+      .returns(withSuccess([2, 3].map((i) => makeChallenge(i, 1))))
+      .onThirdCall()
+      .callsFake(() => {
+        attester.stop()
+        resolve()
+        return withSuccess([])
+      })
+
+    // Entries 0-3 should return rejection (no retry)
+    rewardsStub.submitAndEvaluate
+      .withArgs(sinon.match({ specifier: sinon.match.in([0, 1, 2, 3]) }))
+      .returns({
+        success: false,
+        error: SubmitAndEvaluateError.AAO_ATTESTATION_REJECTION,
+        phase: AttestationPhases.AGGREGATE_ATTESTATIONS
+      })
+
+    await attester.start()
+    await attesterPromise
+
+    assert.equal(attester.startingBlock, 0)
+    assert.equal(attester.offset, 4)
+  })
+
+  it('Sets offset correctly for unretryable errors with different starting block', async () => {
+    // If we get some unretryable errors with a different starting block,
+    // we should *reset* the offset instead of accumulating it.
+
+    const libs = new MockLibs()
+    const rewardsStub = sinon.stub(libs.Rewards)
+
+    const attester = new RewardsAttester({
+      libs,
+      startingBlock: 0,
+      offset: 0,
+      parallelization: 2,
+      quorumSize: 2,
+      aaoEndpoint: 'https://fakeaao.co',
+      aaoAddress: '0xFakeOracle',
+      challengeIdsDenyList: [],
+      endpoints: ['https://dn1.co', 'https://dn2.co', 'https://dn3.co'],
+      isSolanaChallenge: () => false,
+      feePayerOverride: 'test feepayer override'
+    })
+
+    const [attesterPromise, resolve] = makeAttesterPromise()
+
+    rewardsStub.getUndisbursedChallenges
+      .onFirstCall()
+      .returns(withSuccess([0, 1].map((i) => makeChallenge(i, 1))))
+      .onSecondCall()
+      .returns(withSuccess([2, 3].map((i) => makeChallenge(i, 2))))
+      .onThirdCall()
+      .callsFake(() => {
+        attester.stop()
+        resolve()
+        return withSuccess([])
+      })
+
+    // Entries 0-3 should return rejection (no retry)
+    rewardsStub.submitAndEvaluate
+      .withArgs(sinon.match({ specifier: sinon.match.in([0, 1, 2, 3]) }))
+      .returns({
+        success: false,
+        error: SubmitAndEvaluateError.AAO_ATTESTATION_REJECTION,
+        phase: AttestationPhases.AGGREGATE_ATTESTATIONS
+      })
+
+    await attester.start()
+    await attesterPromise
+
+    assert.equal(attester.startingBlock, 1)
+    assert.equal(attester.offset, 2)
+  })
+
+  it('Handles errors in processChallenges after retrying', async () => {
+    // processChallenges needs to return an error after it retries and fails,
+    // so that clients can act upon the error
+
+    const libs = new MockLibs()
+    const rewardsMock = sinon.mock(libs.Rewards)
+
+    const attester = new RewardsAttester({
+      libs,
+      startingBlock: 0,
+      offset: 0,
+      parallelization: 2,
+      quorumSize: 2,
+      aaoEndpoint: 'https://fakeaao.co',
+      aaoAddress: '0xFakeOracle',
+      challengeIdsDenyList: [],
+      endpoints: ['https://dn1.co', 'https://dn2.co', 'https://dn3.co'],
+      isSolanaChallenge: () => false,
+      feePayerOverride: 'test feepayer override',
+      maxCooldownMsec: 100
+    })
+
+    // Have it always return a retryable error
+    rewardsMock
+      .expects("submitAndEvaluate")
+      .exactly(5)
+      .returns({
+        success: false,
+        error: SubmitAndEvaluateError.CHALLENGE_INCOMPLETE,
+        phase: AttestationPhases.AGGREGATE_ATTESTATIONS
+      })
+
+    const { errors } = await attester.processChallenges([
+      {
+        challengeId: 'profile-completion',
+        userId: encodeHashId(1),
+        specifier: '1',
+        amount: '1',
+        completedBlocknumber: 1,
+        handle: 'user_1',
+        wallet: '0x1'
+      }
+    ])
+
+    assert.equal(errors?.length, 1)
+  })
+})
+
+const makeAttesterPromise = () => {
+  let res = null
+  const promise = new Promise((resolve) => (res = resolve))
+  return [promise, res]
+}
+
+const withSuccess = (objs) => ({
+  success: objs
+})
+
+const makeChallenge = (index, completedBlocknumber) => ({
+  challenge_id: 'profile-completion',
+  user_id: encodeHashId(index),
+  specifier: index,
+  amount: '1',
+  completed_blocknumber: completedBlocknumber,
+  handle: `user_ ${index}`,
+  wallet: `0x${index}`
+})

package/tests/serviceTypeManagerClientTest.js

@@ -0,0 +1,33 @@
+const assert = require('assert')
+const helpers = require('./helpers')
+
+const latestVersionStr = '0.1.0'
+
+const audius0 = helpers.audiusInstance
+
+let serviceTypeList
+let ownerWallet
+let accounts
+
+before(async function () {
+  await audius0.init()
+  ownerWallet = audius0.ethWeb3Manager.getWalletAddress()
+  accounts = await audius0.ethWeb3Manager.getWeb3().eth.getAccounts()
+  serviceTypeList = await audius0.ethContracts.ServiceTypeManagerClient.getValidServiceTypes()
+})
+
+it('register service versions', async function () {
+  for (const serviceType of serviceTypeList) {
+    await audius0.ethContracts.ServiceTypeManagerClient.setServiceVersion(
+      serviceType,
+      latestVersionStr
+    )
+  }
+})
+
+it('query service versions', async function () {
+  for (const serviceType of serviceTypeList) {
+    let currentVersion = await audius0.ethContracts.ServiceTypeManagerClient.getCurrentVersion(serviceType)
+    assert(currentVersion === latestVersionStr, 'Expect latest version')
+  }
+})