@audius/sdk 0.0.0

package/initScripts/configureLocalDiscProv.js

@@ -0,0 +1,167 @@
+const fs = require('fs')
+const path = require('path')
+const readline = require('readline')
+const ethContractsMigrationOutput = require('../../eth-contracts/migrations/migration-output.json')
+const solanaConfig = require('../../solana-programs/solana-program-config.json')
+
+const ETH_CONTRACTS_REGISTRY = 'audius_eth_contracts_registry'
+const SOLANA_TRACK_LISTEN_COUNT_ADDRESS = 'audius_solana_track_listen_count_address'
+const SOLANA_ENDPOINT = 'audius_solana_endpoint'
+
+const SOLANA_SIGNER_GROUP_ADDRESS = 'audius_solana_signer_group_address'
+
+const SOLANA_USER_BANK_ADDRESS = 'audius_solana_user_bank_program_address'
+const SOLANA_WAUDIO_MINT = 'audius_solana_waudio_mint'
+
+const SOLANA_REWARDS_MANAGER_ADDRESS = 'audius_solana_rewards_manager_program_address'
+const SOLANA_REWARDS_MANAGER_ACCOUNT = 'audius_solana_rewards_manager_account'
+
+const SOLANA_ANCHOR_PROGRAM_ID = 'audius_solana_anchor_data_program_id'
+const SOLANA_ANCHOR_ADMIN_STORAGE_PUBLIC_KEY = 'audius_solana_anchor_admin_storage_public_key'
+
+// LOCAL DEVELOPMENT ONLY
+// Updates audius_eth_contracts_registry in discovery provider
+const configureLocalDiscProv = async () => {
+  const ethRegistryAddress = ethContractsMigrationOutput.registryAddress
+  const solanaTrackListenCountAddress = solanaConfig.trackListenCountAddress
+  const signerGroup = solanaConfig.signerGroup
+  const solanaEndpoint = solanaConfig.endpoint
+  const waudioMint = solanaConfig.splToken
+  const claimableTokenAddress = solanaConfig.claimableTokenAddress
+  const rewardsManagerAddress = solanaConfig.rewardsManagerAddress
+  const rewardsManagerAccount = solanaConfig.rewardsManagerAccount
+  const anchorProgramId = solanaConfig.anchorProgramId
+  const anchorAdminStoragePublicKey = solanaConfig.anchorAdminStoragePublicKey
+  console.log(`waudioAddress: ${waudioMint}, claimableTokenAddress: ${claimableTokenAddress}, waudioMint=${waudioMint}`)
+  const envPath = path.join(process.cwd(), '../../', 'discovery-provider/compose/.env')
+
+  await _updateDiscoveryProviderEnvFile(
+    envPath,
+    envPath,
+    ethRegistryAddress,
+    solanaTrackListenCountAddress,
+    solanaEndpoint,
+    signerGroup,
+    waudioMint,
+    claimableTokenAddress,
+    rewardsManagerAddress,
+    rewardsManagerAccount,
+    anchorProgramId,
+    anchorAdminStoragePublicKey,
+  )
+}
+
+// Write an update to the local discovery provider config .env file
+const _updateDiscoveryProviderEnvFile = async (
+  readPath,
+  writePath,
+  ethRegistryAddress,
+  solanaTrackListenCountAddress,
+  solanaEndpoint,
+  signerGroup,
+  waudioMint,
+  claimableTokenAddress,
+  rewardsManagerAddress,
+  rewardsManagerAccount,
+  anchorProgramId,
+  anchorAdminStoragePublicKey,
+) => {
+  const fileStream = fs.createReadStream(readPath)
+  const rl = readline.createInterface({
+    input: fileStream,
+    crlfDelay: Infinity
+  })
+  const output = []
+  let ethRegistryAddressFound = false
+  let solanaTrackListenCountAddressFound = false
+  let solanaEndpointFound = false
+  let signerGroupFound = false
+
+  let waudioMintFound = false
+  let claimableTokenAddressFound = false
+  let rewardsAddressFound = false
+  let rewardsAccountFound = false
+  let anchorProgramIdFound = false
+  let anchorAdminStoragePublicKeyFound = false
+
+  const ethRegistryAddressLine = `${ETH_CONTRACTS_REGISTRY}=${ethRegistryAddress}`
+  const solanaTrackListenCountAddressLine = `${SOLANA_TRACK_LISTEN_COUNT_ADDRESS}=${solanaTrackListenCountAddress}`
+  const solanaEndpointLine = `${SOLANA_ENDPOINT}=${solanaEndpoint}`
+  const signerGroupLine = `${SOLANA_SIGNER_GROUP_ADDRESS}=${signerGroup}`
+  const waudioMintLine = `${SOLANA_WAUDIO_MINT}=${waudioMint}`
+  const claimableTokenAddressLine = `${SOLANA_USER_BANK_ADDRESS}=${claimableTokenAddress}`
+  const rewardsManagerAddressLine = `${SOLANA_REWARDS_MANAGER_ADDRESS}=${rewardsManagerAddress}`
+  const rewardsManagerAccountLine = `${SOLANA_REWARDS_MANAGER_ACCOUNT}=${rewardsManagerAccount}`
+  const anchorProgramIdLine = `${SOLANA_ANCHOR_PROGRAM_ID}=${anchorProgramId}`
+  const anchorAdminStoragePublicKeyLine = `${SOLANA_ANCHOR_ADMIN_STORAGE_PUBLIC_KEY}=${anchorAdminStoragePublicKey}`
+
+  for await (const line of rl) {
+    if (line.includes(ETH_CONTRACTS_REGISTRY)) {
+      output.push(ethRegistryAddressLine)
+      ethRegistryAddressFound = true
+    } else if (line.includes(SOLANA_TRACK_LISTEN_COUNT_ADDRESS)) {
+      output.push(solanaTrackListenCountAddressLine)
+      solanaTrackListenCountAddressFound = true
+    } else if (line.includes(SOLANA_ENDPOINT)) {
+      output.push(solanaEndpointLine)
+      solanaEndpointFound = true
+    } else if (line.includes(SOLANA_SIGNER_GROUP_ADDRESS)) {
+      output.push(signerGroupLine)
+      signerGroupFound = true
+    } else if (line.includes(SOLANA_USER_BANK_ADDRESS)) {
+      output.push(claimableTokenAddressLine)
+      claimableTokenAddressFound = true
+    } else if (line.includes(SOLANA_WAUDIO_MINT)) {
+      output.push(waudioMintLine)
+      waudioMintFound = true
+    } else if (line.includes(SOLANA_REWARDS_MANAGER_ADDRESS)) {
+      output.push(rewardsManagerAddressLine)
+      rewardsAddressFound = true
+    } else if (line.includes(SOLANA_REWARDS_MANAGER_ACCOUNT)) {
+      output.push(rewardsManagerAccountLine)
+      rewardsAccountFound = true
+    } else if (line.includes(SOLANA_ANCHOR_PROGRAM_ID)) {
+      output.push(anchorProgramIdLine)
+      anchorProgramIdFound = true
+    } else if (line.includes(SOLANA_ANCHOR_ADMIN_STORAGE_PUBLIC_KEY)) {
+      output.push(anchorAdminStoragePublicKeyLine)
+      anchorAdminStoragePublicKeyFound = true
+    } else {
+      output.push(line)
+    }
+  }
+  if (!ethRegistryAddressFound) {
+    output.push(ethRegistryAddressLine)
+  }
+  if (!solanaTrackListenCountAddressFound) {
+    output.push(solanaTrackListenCountAddressLine)
+  }
+  if (!solanaEndpointFound) {
+    output.push(solanaEndpointLine)
+  }
+  if (!signerGroupFound) {
+    output.push(signerGroupLine)
+  }
+  if (!waudioMintFound) {
+    output.push(waudioMintLine)
+  }
+  if (!claimableTokenAddressFound) {
+    output.push(claimableTokenAddressLine)
+  }
+  if (!rewardsAddressFound) {
+    output.push(rewardsManagerAddressLine)
+  }
+  if (!rewardsAccountFound) {
+    output.push(rewardsManagerAccountLine)
+  }
+  if (!anchorProgramIdFound) {
+    output.push(anchorProgramIdLine)
+  }
+  if (!anchorAdminStoragePublicKeyFound) {
+    output.push(anchorAdminStoragePublicKeyLine)
+  }
+  fs.writeFileSync(writePath, output.join('\n'))
+  console.log(`Updated DISCOVERY PROVIDER ${writePath} ${ETH_CONTRACTS_REGISTRY}=${ethRegistryAddress} ${output}`)
+}
+
+configureLocalDiscProv()

package/initScripts/helpers/claim.js

@@ -0,0 +1,43 @@
+const { getEthWeb3AndAccounts, convertAudsToWeiBN } = require('./utils')
+
+/**
+ * @param {Object} audiusLibs fully formed audius libs instance with eth contracts connection
+ */
+async function getClaimInfo (audiusLibs) {
+  if (!audiusLibs) throw new Error('audiusLibs is not defined')
+
+  // @dev - audius instance numbering is off-by-1 from accounts to
+  // align with creator/track numbering below, which are 1-indexed
+  const claimInfo = await audiusLibs.ethContracts.StakingProxyClient.getClaimInfo()
+  console.log('getClaimInfo', claimInfo)
+  return claimInfo
+}
+
+/**
+ * Funds the treasury that service providers can claim from
+ * @param {Object} audiusLibs fully formed audius libs instance with eth contracts connection
+ * @param {String} amountOfAUDS integer amount of auds tokens
+ * @param {String} privateKey The private key string
+ */
+async function fundNewClaim (audiusLibs, amountOfAUDS, privateKey = null) {
+  if (!audiusLibs) throw new Error('audiusLibs is not defined')
+  if (!amountOfAUDS) throw new Error('fundNewClaim requires an amountOfAUDS property')
+
+  const { ethWeb3 } = await getEthWeb3AndAccounts(audiusLibs)
+  const libOwner = audiusLibs.ethContracts.ethWeb3Manager.getWalletAddress()
+
+  console.log('/---- Funding new claim')
+  const bal = await audiusLibs.ethContracts.AudiusTokenClient.balanceOf(libOwner)
+  console.log(bal)
+  const claimAmountInAudWeiBN = convertAudsToWeiBN(ethWeb3, amountOfAUDS)
+  console.log(claimAmountInAudWeiBN)
+
+  // Actually perform fund op
+  const tx = await audiusLibs.ethContracts.StakingProxyClient.fundNewClaim(claimAmountInAudWeiBN, privateKey)
+  console.log(tx)
+  console.log('/---- End funding new claim')
+
+  return getClaimInfo(audiusLibs)
+}
+
+module.exports = { getClaimInfo, fundNewClaim }

package/initScripts/helpers/distributeTokens.js

@@ -0,0 +1,24 @@
+const { getEthWeb3AndAccounts, convertAudsToWeiBN } = require('./utils')
+
+/**
+ * Local only
+ * @param {Object} audiusLibs fully formed audius libs instance with eth contracts connection
+ * @param {String} amountOfAUDS integer amount of auds tokens
+ */
+async function distributeTokens (audiusLibs, amountOfAUDS) {
+  if (!audiusLibs) throw new Error('audiusLibs is not defined')
+
+  const { ethWeb3, ethAccounts } = await getEthWeb3AndAccounts(audiusLibs)
+
+  const initialTokenInAudWeiBN = convertAudsToWeiBN(ethWeb3, amountOfAUDS)
+  await Promise.all(ethAccounts.map(async (account) => {
+    if (account === ethAccounts[0]) { return }
+    const tx = await audiusLibs.ethContracts.AudiusTokenClient.transfer(account, initialTokenInAudWeiBN)
+    console.log(`${tx.txReceipt.transactionHash} Transferred ${amountOfAUDS} to ${account}`)
+  }))
+  for (const account of ethAccounts) {
+    if (account === ethAccounts[0]) { continue }
+  }
+}
+
+module.exports = { distributeTokens }

package/initScripts/helpers/spRegistration.js

@@ -0,0 +1,138 @@
+const { getEthWeb3AndAccounts, convertAudsToWeiBN } = require('./utils')
+
+/**
+ *
+ * @param {Object} audiusLibs fully formed audius libs instance with eth contracts connection
+ */
+async function getStakingParameters (audiusLibs) {
+  if (!audiusLibs) throw new Error('audiusLibs is not defined')
+
+  const min = await audiusLibs.ethContracts.StakingProxyClient.getMinStakeAmount()
+  const max = await audiusLibs.ethContracts.StakingProxyClient.getMaxStakeAmount()
+  console.log(`getStakingParameters: min: ${min}, max: ${max}`)
+  return { min, max }
+}
+
+/**
+ * Local only
+ * @param {Object} audiusLibs fully formed audius libs instance with eth contracts connection
+ * @param {String} serviceType service type trying to register
+ * @param {String} serviceEndpoint url string of service to register
+ * @param {String} amountOfAUDS integer amount of auds tokens
+ */
+async function registerLocalService (audiusLibs, serviceType, serviceEndpoint, amountOfAUDS) {
+  if (!audiusLibs) throw new Error('audiusLibs is not defined')
+  if (!amountOfAUDS) throw new Error('registerLocalService requires an amountOfAuds property')
+
+  const { ethWeb3 } = await getEthWeb3AndAccounts(audiusLibs)
+  console.log('\nregistering service providers/---')
+  const initialTokenInAudWeiBN = convertAudsToWeiBN(ethWeb3, amountOfAUDS)
+
+  try {
+    // Register service
+    console.log(`registering service ${serviceType} ${serviceEndpoint}`)
+    const tx = await audiusLibs.ethContracts.ServiceProviderFactoryClient.register(
+      serviceType,
+      serviceEndpoint,
+      initialTokenInAudWeiBN)
+    console.log(`registered service ${serviceType} ${serviceEndpoint} - ${tx.txReceipt.transactionHash}`)
+  } catch (e) {
+    if (!e.toString().includes('already registered')) {
+      console.log(e)
+    } else {
+      console.log(`\n${serviceEndpoint} already registered`)
+    }
+  }
+}
+
+async function updateServiceDelegateOwnerWallet (audiusLibs, serviceType, serviceEndpoint, updatedDelegateOwnerWallet) {
+  if (!audiusLibs || !serviceType || !serviceEndpoint || !updatedDelegateOwnerWallet) {
+    throw new Error('Missing required params')
+  }
+
+  try {
+    console.log(`Updating delegateOwnerWallet for ${serviceType} ${serviceEndpoint} with new wallet ${updatedDelegateOwnerWallet}`)
+    const tx = await audiusLibs.ethContracts.ServiceProviderFactoryClient.updateDelegateOwnerWallet(
+      serviceType, serviceEndpoint, updatedDelegateOwnerWallet
+    )
+    console.log(`Successfully updated delegateOwnerWallet for ${serviceType} ${serviceEndpoint} with new wallet ${updatedDelegateOwnerWallet} - ${JSON.stringify(tx, null, 2)}`)
+  } catch (e) {
+    throw new Error(`Failed to update delegateOwnerWallet for ${serviceType} ${serviceEndpoint} with new wallet ${updatedDelegateOwnerWallet} || ERROR ${e}`)
+  }
+}
+
+/**
+ * Local only
+ * @param {Object} audiusLibs fully formed audius libs instance with eth contracts connection
+ * @param {String} serviceType service type trying to register
+ * @param {String} serviceEndpoint url string of service to register
+ */
+async function deregisterLocalService (audiusLibs, serviceType, serviceEndpoint) {
+  if (!audiusLibs) throw new Error('audiusLibs is not defined')
+
+  try {
+    // de-register service
+    console.log(`\nde-registering service ${serviceType} ${serviceEndpoint}`)
+    const tx = await audiusLibs.ethContracts.ServiceProviderFactoryClient.deregister(
+      serviceType,
+      serviceEndpoint)
+    console.dir(tx, { depth: 5 })
+  } catch (e) {
+    console.log(e)
+  }
+}
+
+/**
+ * Local only
+ * @param {Object} audiusLibs fully formed audius libs instance with eth contracts connection
+ * @param {Array} serviceTypeList List of services to query
+ * @param {Boolean} queryUserReplicaSetManager Conditionally query L2 replica set contract
+ */
+async function queryLocalServices (audiusLibs, serviceTypeList, queryUserReplicaSetManager = false) {
+  if (!audiusLibs) throw new Error('audiusLibs is not defined')
+
+  console.log('\n----querying service providers')
+  const { ethAccounts } = await getEthWeb3AndAccounts(audiusLibs)
+  let cnodesInfoList = null
+
+  for (const spType of serviceTypeList) {
+    console.log(`${spType}`)
+    const spList = await audiusLibs.ethContracts.ServiceProviderFactoryClient.getServiceProviderList(spType)
+    if (spType === 'content-node') {
+      cnodesInfoList = spList
+    }
+    for (const sp of spList) {
+      console.log(sp)
+      const { spID, type, endpoint } = sp
+      const idFromEndpoint =
+        await audiusLibs.ethContracts.ServiceProviderFactoryClient.getServiceProviderIdFromEndpoint(endpoint)
+      console.log(`ID from endpoint: ${idFromEndpoint}`)
+      const infoFromId =
+        await audiusLibs.ethContracts.ServiceProviderFactoryClient.getServiceEndpointInfo(type, spID)
+      const jsonInfoFromId = JSON.stringify(infoFromId)
+      console.log(`Info from ID: ${jsonInfoFromId}`)
+      const idsFromAddress =
+        await audiusLibs.ethContracts.ServiceProviderFactoryClient.getServiceProviderIdsFromAddress(
+          ethAccounts[0],
+          type)
+      console.log(`SP IDs from owner wallet ${ethAccounts[0]}: ${idsFromAddress}`)
+    }
+
+    const numProvs = await audiusLibs.ethContracts.ServiceProviderFactoryClient.getTotalServiceTypeProviders(spType)
+    console.log(`${numProvs} instances of ${spType}`)
+  }
+  console.log('----done querying service providers')
+  if (queryUserReplicaSetManager) {
+    console.log('\n----querying UserReplicaSetManager on data-contracts')
+    for (const cnode of cnodesInfoList) {
+      const spInfoFromUrsm = await audiusLibs.contracts.UserReplicaSetManagerClient.getContentNodeWallets(cnode.spID)
+      const delegateWalletFromUrsmContract = spInfoFromUrsm.delegateOwnerWallet
+      const ownerWalletFromUrsmContract = spInfoFromUrsm.ownerWallet
+      console.log(`spID ${cnode.spID} | \
+eth-contracts delegateWallet=${cnode.delegateOwnerWallet}, data-contracts delegateOwnerWallet=${delegateWalletFromUrsmContract}, ownerWallet=${ownerWalletFromUrsmContract}`)
+    }
+    console.log('----done querying UserReplicaSetManager on data-contracts\n')
+  }
+}
+
+module.exports = { getStakingParameters, registerLocalService, deregisterLocalService, queryLocalServices, updateServiceDelegateOwnerWallet }

package/initScripts/helpers/utils.js

@@ -0,0 +1,34 @@
+const util = require('util')
+const exec = util.promisify(require('child_process').exec)
+/**
+ * *NOTE* - this should only be used for local functions
+ * Given an audiusLibs instance, return web3 instance from ethWeb3Manager
+ * @param {*} audiusLibs
+ */
+async function getEthWeb3AndAccounts (audiusLibs) {
+  const ethWeb3 = audiusLibs.ethWeb3Manager.getWeb3()
+  const ethAccounts = await ethWeb3.eth.getAccounts()
+  return { ethWeb3, ethAccounts }
+}
+
+function convertAudsToWeiBN (ethWeb3, amountOfAUDS) {
+  const tokenInWei = ethWeb3.utils.toWei(amountOfAUDS.toString(), 'ether')
+  return ethWeb3.utils.toBN(tokenInWei)
+}
+
+async function execParseOutput (cmd) {
+  const r = await exec(cmd)
+  const stdout = r.stdout
+  const parsed = JSON.parse(stdout)
+  return parsed
+}
+
+async function getDataContractAccounts () {
+  return execParseOutput('docker exec audius_ganache_cli cat contracts-ganache-accounts.json')
+}
+
+async function getEthContractAccounts () {
+  return execParseOutput('docker exec audius_ganache_cli_eth_contracts cat eth-contracts-ganache-accounts.json')
+}
+
+module.exports = { getEthWeb3AndAccounts, convertAudsToWeiBN, getDataContractAccounts, getEthContractAccounts }

package/initScripts/helpers/version.js

@@ -0,0 +1,93 @@
+const web3 = require('web3')
+
+/**
+ *
+ * @param {Object} audiusLibs fully formed audius libs instance with eth contracts connection
+ * @param {String} serviceType service type trying to register
+ * @param {String} serviceVersionStr version string to register
+ * @param {String?} privateKey optional private key string
+ * @param {Boolean?} dryRun Optional parameter to return the generated parameters without sending tx
+ */
+async function setServiceVersion (audiusLibs, serviceType, serviceVersionStr, privateKey = null, dryRun = false) {
+  if (!audiusLibs) throw new Error('audiusLibs is not defined')
+
+  const validServiceTypes = ['discovery-node', 'content-node']
+  if (!validServiceTypes.includes(serviceType)) {
+    throw new Error(`Invalid serviceType: ${serviceType}, must be in ${validServiceTypes}`)
+  }
+
+  console.log('----version init---')
+  let resp
+  try {
+    resp = await audiusLibs.ethContracts.ServiceTypeManagerClient.setServiceVersion(
+      serviceType,
+      serviceVersionStr,
+      privateKey,
+      dryRun
+    )
+  } catch (e) {
+    if (!e.toString().includes('Already registered')) {
+      console.log(e)
+      return
+    } else {
+      console.log('Already registered')
+    }
+  }
+
+  // this prints out the fields and values to be submitted onto the Governance dashboard
+  // to create new proposals
+  if (dryRun) {
+    console.log(`
+      Set latest ${serviceType} version on chain to v${serviceVersionStr}
+      ServiceTypeManagerProxy
+      setServiceVersion(bytes32,bytes32)
+      ${resp}
+
+      Description:
+      Git SHA - <SHA>
+      Link to release - <URL>
+    `)
+  }
+
+  const versionTx = await audiusLibs.ethContracts.ServiceTypeManagerClient.getCurrentVersion(serviceType)
+  const numVersionsTx = await audiusLibs.ethContracts.ServiceTypeManagerClient.getNumberOfVersions(serviceType)
+  console.log(`${serviceType} | current version: ${versionTx} | number of versions : ${numVersionsTx}`)
+
+  console.log('/----version init---')
+}
+
+/**
+ * Add a new service type on chain
+ * @param {Object} audiusLibs fully formed audius libs instance with eth contracts connection
+ * @param {String} serviceType service type trying to register
+ * @param {String} serviceTypeMin minimum stake for serviceType
+ * @param {String} serviceTypeMax maximum stake for serviceType
+ * @param {String?} privateKey optional private key string
+ */
+async function addServiceType (audiusLibs, serviceType, serviceTypeMin, serviceTypeMax, privateKey = null) {
+  if (!audiusLibs) throw new Error('audiusLibs is not defined')
+
+  console.log('----addServiceType---')
+  const weiMin = web3.utils.toWei(serviceTypeMin.toString(), 'ether')
+  const weiMax = web3.utils.toWei(serviceTypeMax.toString(), 'ether')
+
+  try {
+    const resp = await audiusLibs.ethContracts.ServiceTypeManagerClient.addServiceType(
+      serviceType,
+      weiMin,
+      weiMax,
+      privateKey)
+    console.log(resp)
+  } catch (e) {
+    console.error('Could not add new service type', e)
+  }
+
+  const serviceTypeInfo = await audiusLibs.ethContracts.ServiceTypeManagerClient.getServiceTypeInfo(serviceType)
+  console.log(`Expected values for ${serviceType} | expected min ${weiMin} | expected max ${weiMax}`)
+  console.log(`Values from contract: ${JSON.stringify(serviceTypeInfo)}`)
+  console.log(`Min: ${serviceTypeInfo.minStake.toString()} Max: ${serviceTypeInfo.maxStake.toString()}`)
+
+  console.log('/----addServiceType---')
+}
+
+module.exports = { setServiceVersion, addServiceType }