@audius/sdk 0.0.0

package/src/api/base.js

@@ -0,0 +1,122 @@
+const Services = Object.freeze({
+  IDENTITY_SERVICE: 'Identity Service',
+  HEDGEHOG: 'Hedgehog',
+  DISCOVERY_PROVIDER: 'Discovery Provider',
+  CREATOR_NODE: 'Creator Node',
+  COMSTOCK: 'Comstock',
+  SOLANA_WEB3_MANAGER: 'Solana Web3 Manager'
+})
+
+class Base {
+  constructor (
+    userStateManager,
+    identityService,
+    hedgehog,
+    discoveryProvider,
+    web3Manager,
+    contracts,
+    ethWeb3Manager,
+    ethContracts,
+    solanaWeb3Manager,
+    anchorAudiusData,
+    wormholeClient,
+    creatorNode,
+    comstock,
+    captcha,
+    isServer,
+    logger = console
+  ) {
+    this.userStateManager = userStateManager
+    this.identityService = identityService
+    this.hedgehog = hedgehog
+    this.discoveryProvider = discoveryProvider
+    this.web3Manager = web3Manager
+    this.contracts = contracts
+    this.ethWeb3Manager = ethWeb3Manager
+    this.ethContracts = ethContracts
+    this.solanaWeb3Manager = solanaWeb3Manager
+    this.anchorAudiusData = anchorAudiusData
+    this.wormholeClient = wormholeClient
+    this.creatorNode = creatorNode
+    this.comstock = comstock
+    this.captcha = captcha
+    this.isServer = isServer
+    this.logger = logger
+
+    this._serviceMapping = {
+      [Services.IDENTITY_SERVICE]: this.identityService,
+      [Services.HEDGEHOG]: this.hedgehog,
+      [Services.DISCOVERY_PROVIDER]: this.discoveryProvider,
+      [Services.CREATOR_NODE]: this.creatorNode,
+      [Services.COMSTOCK]: this.comstock,
+      [Services.SOLANA_WEB3_MANAGER]: this.solanaWeb3Manager
+    }
+  }
+
+  REQUIRES (...services) {
+    services.forEach(s => {
+      if (!this._serviceMapping[s]) return Base._missingService(services)
+    })
+  }
+
+  IS_OBJECT (o) {
+    if (typeof (o) !== 'object') return Base._invalidType('object')
+  }
+
+  OBJECT_HAS_PROPS (o, props, requiredProps) {
+    const missingProps = []
+    props.forEach(prop => {
+      if (!Object.prototype.hasOwnProperty.call(o, prop)) missingProps.push(prop)
+    })
+    if (missingProps.length > 0) return Base._missingProps(missingProps)
+
+    const missingRequiredProps = []
+    requiredProps.forEach(prop => {
+      if (!Object.prototype.hasOwnProperty.call(o, prop) || o[prop] === '') missingRequiredProps.push(prop)
+    })
+    if (missingRequiredProps.length > 0) return Base._missingPropValues(missingRequiredProps)
+  }
+
+  FILE_IS_VALID (file) {
+    if (this.isServer) {
+      if (!file ||
+          typeof file !== 'object' ||
+          typeof file.pipe !== 'function' ||
+          !file.readable) { return Base._invalidFile() }
+    } else {
+      if (!file ||
+        typeof file !== 'object') { return Base._missingFile() }
+    }
+  }
+
+  /* ------- PRIVATE  ------- */
+
+  static _missingService (...serviceNames) {
+    throw new Error(`Requires the following services: ${serviceNames.join(', ')}`)
+  }
+
+  static _invalidType (type) {
+    throw new Error(`Argument must be of type ${type}`)
+  }
+
+  static _missingProps (props) {
+    throw new Error(`Missing props ${props.join(', ')}`)
+  }
+
+  static _missingPropValues (props) {
+    throw new Error(`Missing field values ${props.join(', ')}`)
+  }
+
+  static _invalidFile () {
+    throw new Error('Expected file as readable stream')
+  }
+
+  static _missingFile () {
+    throw new Error('Missing or malformed file')
+  }
+}
+
+module.exports = {
+  Base,
+  Services
+}

package/src/api/file.js

@@ -0,0 +1,168 @@
+let urlJoin = require('proper-url-join')
+if (urlJoin && urlJoin.default) urlJoin = urlJoin.default
+
+const axios = require('axios')
+const { Base, Services } = require('./base')
+const { raceRequests } = require('../utils/network')
+const retry = require('async-retry')
+
+/**
+ * Downloads a file using an element in the DOM
+ * @param {*} url
+ * @param {*} filename
+ */
+const downloadURL = (url, filename) => {
+  if (document) {
+    const link = document.createElement('a')
+    link.href = url
+    link.target = '_blank'
+    link.download = filename
+    link.click()
+    return
+  }
+  throw new Error('No body document found')
+}
+
+class File extends Base {
+  constructor (user, ...args) {
+    super(...args)
+
+    this.User = user
+  }
+
+  /**
+   * Fetches a file from Content Node with a given CID.
+   * @param {string} cid IPFS content identifier
+   * @param {Array<string>} creatorNodeGateways Content Node gateways to fetch content from
+   * @param {?function} callback callback called on each successful/failed fetch with
+   *  [String, Bool](gateway, succeeded)
+   *  Can be used for tracking metrics on which gateways were used.
+   */
+  async fetchCID (
+    cid,
+    creatorNodeGateways,
+    callback = null,
+    responseType = 'blob',
+    trackId = null
+  ) {
+    const urls = []
+
+    creatorNodeGateways.forEach(gateway => {
+      let gatewayWithCid = urlJoin(gateway, cid)
+      if (trackId) gatewayWithCid = urlJoin(gatewayWithCid, { query: { trackId } })
+      urls.push(gatewayWithCid)
+    })
+
+    return retry(async (bail) => {
+      try {
+        const { response, errored } = await raceRequests(urls, callback, {
+          method: 'get',
+          responseType
+        }, /* timeout */ null)
+
+        if (!response) {
+          const allUnauthorized = errored.every(error => error.response.status === 403)
+          if (allUnauthorized) {
+            // In the case for a 403, do not retry fetching
+            bail(new Error('Unauthorized'))
+            return
+          }
+          throw new Error(`Could not fetch ${cid}`)
+        }
+        return response
+      } catch (e) {
+        // TODO: Remove this fallback logic when no more users/tracks/playlists
+        // contain "legacy" image formats (no dir cid)
+        if (cid.includes('/')) { // dirCID -- an image
+          console.debug(`Attempted to fetch image ${cid} via legacy method`)
+          // Try legacy image format
+          // Lop off anything like /480x480.jpg in the CID
+          const legacyUrls = creatorNodeGateways.map(gateway => urlJoin(gateway, cid.split('/')[0]))
+          try {
+            const { response } = await raceRequests(legacyUrls, callback, {
+              method: 'get',
+              responseType
+            }, /* timeout */ null)
+            if (!response) throw new Error(`Could not fetch ${cid} via legacy method`)
+            return response
+          } catch (e) {
+            throw new Error(`Failed to retrieve ${cid} by legacy method`)
+          }
+        }
+
+        // Throw so we can retry
+        throw new Error(`Failed to retrieve ${cid}`)
+      }
+    }, {
+      minTimeout: 500,
+      maxTimeout: 4000,
+      factor: 3,
+      retries: 5,
+      onRetry: (err, i) => {
+        // eslint-disable-next-line no-console
+        console.log(`FetchCID attempt ${i} error: ${err}`)
+      }
+    })
+  }
+
+  /**
+   * Fetches a file from Content Node with a given CID. Follows the same pattern
+   * as fetchCID, but resolves with a download of the file rather than
+   * returning the response content.
+   * @param {string} cid IPFS content identifier
+   * @param {Array<string>} creatorNodeGateways Content Node gateways to fetch content from
+   * @param {string?} filename optional filename for the download
+   */
+  async downloadCID (cid, creatorNodeGateways, filename) {
+    const urls = creatorNodeGateways.map(gateway => urlJoin(gateway, cid, { query: { filename } }))
+
+    try {
+      // Races requests and fires the download callback for the first endpoint to
+      // respond with a valid response to a `head` request.
+      const { response } = await raceRequests(urls, (url) => downloadURL(url, filename), {
+        method: 'head'
+      }, /* timeout */ 10000)
+      return response
+    } catch (e) {
+      throw new Error(`Failed to retrieve ${cid}`)
+    }
+  }
+
+  /**
+   * Checks if a CID exists on a Content Node.
+   * @param {string} cid IPFS content identifier
+   * @param {Array<string>} creatorNodeGateways Content Node gateways to fetch content from
+   * Eg. creatorNodeGateways = ["https://creatornode.audius.co/ipfs/", "https://creatornode2.audius.co/ipfs/"]
+   */
+  async checkIfCidAvailable (cid, creatorNodeGateways) {
+    const exists = {}
+
+    await Promise.all(creatorNodeGateways.map(async (gateway) => {
+      try {
+        const { status } = await axios({ url: urlJoin(gateway, cid), method: 'head' })
+        exists[gateway] = status === 200
+      } catch (err) {
+        exists[gateway] = false
+      }
+    }))
+
+    return exists
+  }
+
+  /**
+   * Uploads an image to the connected Content Node.
+   * @param {File} file
+   */
+  async uploadImage (file, square, timeoutMs = null) {
+    this.REQUIRES(Services.CREATOR_NODE)
+    this.FILE_IS_VALID(file)
+
+    // Assign a creator_node_endpoint to the user if necessary
+    await this.User.assignReplicaSetIfNecessary()
+
+    const resp = await this.creatorNode.uploadImage(file, square, /* onProgress */ undefined, timeoutMs)
+    return resp
+  }
+}
+
+module.exports = File

package/src/api/playlist.js

@@ -0,0 +1,328 @@
+const { Base, Services } = require('./base')
+const { Utils } = require('../utils')
+
+const MAX_PLAYLIST_LENGTH = 200
+
+class Playlists extends Base {
+  constructor (...args) {
+    super(...args)
+    this.getPlaylists = this.getPlaylists.bind(this)
+    this.getSavedPlaylists = this.getSavedPlaylists.bind(this)
+    this.getSavedAlbums = this.getSavedAlbums.bind(this)
+    this.createPlaylist = this.createPlaylist.bind(this)
+    this.addPlaylistTrack = this.addPlaylistTrack.bind(this)
+    this.orderPlaylistTracks = this.orderPlaylistTracks.bind(this)
+    this.validateTracksInPlaylist = this.validateTracksInPlaylist.bind(this)
+    this.uploadPlaylistCoverPhoto = this.uploadPlaylistCoverPhoto.bind(this)
+    this.updatePlaylistCoverPhoto = this.updatePlaylistCoverPhoto.bind(this)
+    this.updatePlaylistName = this.updatePlaylistName.bind(this)
+    this.updatePlaylistDescription = this.updatePlaylistDescription.bind(this)
+    this.updatePlaylistPrivacy = this.updatePlaylistPrivacy.bind(this)
+    this.addPlaylistRepost = this.addPlaylistRepost.bind(this)
+    this.deletePlaylistRepost = this.deletePlaylistRepost.bind(this)
+    this.deletePlaylistTrack = this.deletePlaylistTrack.bind(this)
+    this.addPlaylistSave = this.addPlaylistSave.bind(this)
+    this.deletePlaylistSave = this.deletePlaylistSave.bind(this)
+    this.deletePlaylist = this.deletePlaylist.bind(this)
+  }
+
+  /* ------- GETTERS ------- */
+
+  /**
+   * get full playlist objects, including tracks, for passed in array of playlistId
+   * @param {number} limit max # of items to return
+   * @param {number} offset offset into list to return from (for pagination)
+   * @param {Array} idsArray list of playlist ids
+   * @param {number} targetUserId the user whose playlists we're trying to get
+   * @param {boolean} withUsers whether to return users nested within the collection objects
+   * @returns {Array} array of playlist objects
+   * additional metadata fields on playlist objects:
+   *  {Integer} repost_count - repost count for given playlist
+   *  {Integer} save_count - save count for given playlist
+   *  {Boolean} has_current_user_reposted - has current user reposted given playlist
+   *  {Array} followee_reposts - followees of current user that have reposted given playlist
+   *  {Boolean} has_current_user_reposted - has current user reposted given playlist
+   *  {Boolean} has_current_user_saved - has current user saved given playlist
+   */
+  async getPlaylists (limit = 100, offset = 0, idsArray = null, targetUserId = null, withUsers = false) {
+    this.REQUIRES(Services.DISCOVERY_PROVIDER)
+    return this.discoveryProvider.getPlaylists(limit, offset, idsArray, targetUserId, withUsers)
+  }
+
+  /**
+   * Return saved playlists for current user
+   * NOTE in returned JSON, SaveType string one of track, playlist, album
+   * @param {number} limit - max # of items to return
+   * @param {number} offset - offset into list to return from (for pagination)
+   */
+  async getSavedPlaylists (limit = 100, offset = 0, withUsers = false) {
+    this.REQUIRES(Services.DISCOVERY_PROVIDER)
+    return this.discoveryProvider.getSavedPlaylists(limit, offset, withUsers)
+  }
+
+  /**
+   * Return saved albums for current user
+   * NOTE in returned JSON, SaveType string one of track, playlist, album
+   * @param {number} limit - max # of items to return
+   * @param {number} offset - offset into list to return from (for pagination)
+   */
+  async getSavedAlbums (limit = 100, offset = 0, withUsers = false) {
+    this.REQUIRES(Services.DISCOVERY_PROVIDER)
+    return this.discoveryProvider.getSavedAlbums(limit, offset, withUsers)
+  }
+
+  /* ------- SETTERS ------- */
+
+  /**
+   * Creates a new playlist
+   * @param {number} userId
+   * @param {string} playlistName
+   * @param {boolean} isPrivate
+   * @param {boolean} isAlbum
+   * @param {Array<number>} trackIds
+   */
+  async createPlaylist (userId, playlistName, isPrivate, isAlbum, trackIds) {
+    const maxInitialTracks = 50
+    const createInitialIdsArray = trackIds.slice(0, maxInitialTracks)
+    const postInitialIdsArray = trackIds.slice(maxInitialTracks)
+    let playlistId
+    let receipt = {}
+    try {
+      const response = await this.contracts.PlaylistFactoryClient.createPlaylist(
+        userId, playlistName, isPrivate, isAlbum, createInitialIdsArray
+      )
+      playlistId = response.playlistId
+      receipt = response.txReceipt
+
+      // Add remaining tracks
+      await Promise.all(postInitialIdsArray.map(trackId => {
+        return this.contracts.PlaylistFactoryClient.addPlaylistTrack(playlistId, trackId)
+      }))
+
+      // Order tracks
+      if (postInitialIdsArray.length > 0) {
+        receipt = await this.contracts.PlaylistFactoryClient.orderPlaylistTracks(playlistId, trackIds)
+      }
+    } catch (e) {
+      console.debug(`Reached libs createPlaylist catch block with playlist id ${playlistId}`)
+      console.error(e)
+      return { playlistId, error: true }
+    }
+    return { blockHash: receipt.blockHash, blockNumber: receipt.blockNumber, playlistId, error: false }
+  }
+
+  /**
+   * Adds a track to a given playlist
+   * @param {number} playlistId
+   * @param {number} trackId
+   */
+  async addPlaylistTrack (playlistId, trackId) {
+    this.REQUIRES(Services.DISCOVERY_PROVIDER)
+
+    const userId = this.userStateManager.getCurrentUserId()
+    const playlist = await this.discoveryProvider.getPlaylists(100, 0, [playlistId], userId)
+
+    // error if playlist does not exist or hasn't been indexed by discovery provider
+    if (!Array.isArray(playlist) || !playlist.length) {
+      throw new Error('Cannot add track - Playlist does not exist or has not yet been indexed by discovery provider')
+    }
+    // error if playlist already at max length
+    if (playlist[0].playlist_contents.track_ids.length >= MAX_PLAYLIST_LENGTH) {
+      throw new Error(`Cannot add track - playlist is already at max length of ${MAX_PLAYLIST_LENGTH}`)
+    }
+    return this.contracts.PlaylistFactoryClient.addPlaylistTrack(playlistId, trackId)
+  }
+
+  /**
+   * Reorders the tracks in a playlist
+   * @param {number} playlistId
+   * @param {Array<number>} trackIds
+   * @param {number?} retriesOverride [Optional, defaults to web3Manager.sendTransaction retries default]
+   */
+  async orderPlaylistTracks (playlistId, trackIds, retriesOverride) {
+    this.REQUIRES(Services.DISCOVERY_PROVIDER)
+    if (!Array.isArray(trackIds)) {
+      throw new Error('Cannot order playlist - trackIds must be array')
+    }
+
+    const userId = this.userStateManager.getCurrentUserId()
+    const playlist = await this.discoveryProvider.getPlaylists(100, 0, [playlistId], userId)
+
+    // error if playlist does not exist or hasn't been indexed by discovery provider
+    if (!Array.isArray(playlist) || !playlist.length) {
+      throw new Error('Cannot order playlist - Playlist does not exist or has not yet been indexed by discovery provider')
+    }
+
+    const playlistTrackIds = playlist[0].playlist_contents.track_ids.map(a => a.track)
+    // error if trackIds arg array length does not match playlist length
+    if (trackIds.length !== playlistTrackIds.length) {
+      throw new Error('Cannot order playlist - trackIds length must match playlist length')
+    }
+
+    // ensure existing playlist tracks and trackIds have same content, regardless of order
+    const trackIdsSorted = [...trackIds].sort()
+    const playlistTrackIdsSorted = playlistTrackIds.sort()
+    for (let i = 0; i < trackIdsSorted.length; i++) {
+      if (trackIdsSorted[i] !== playlistTrackIdsSorted[i]) {
+        throw new Error('Cannot order playlist - trackIds must have same content as playlist tracks')
+      }
+    }
+
+    return this.contracts.PlaylistFactoryClient.orderPlaylistTracks(playlistId, trackIds, retriesOverride)
+  }
+
+  /**
+   * Checks if a playlist has entered a corrupted state
+   * Check that each of the tracks within a playlist retrieved from discprov are in the onchain playlist
+   * Note: the onchain playlists stores the tracks as a mapping of track ID to track count and the
+   * track order is an event that is indexed by discprov. The track order event does not validate that the
+   * updated order of tracks has the correct track count, so a track order event w/ duplicate tracks can
+   * lead the playlist entering a corrupted state.
+   * @param {number} playlistId
+   */
+  async validateTracksInPlaylist (playlistId) {
+    this.REQUIRES(Services.DISCOVERY_PROVIDER, Services.CREATOR_NODE)
+
+    const userId = this.userStateManager.getCurrentUserId()
+    const playlistsReponse = await this.discoveryProvider.getPlaylists(1, 0, [playlistId], userId)
+
+    // error if playlist does not exist or hasn't been indexed by discovery provider
+    if (!Array.isArray(playlistsReponse) || !playlistsReponse.length) {
+      throw new Error('Cannot validate playlist - Playlist does not exist, is private and not owned by current user or has not yet been indexed by discovery provider')
+    }
+
+    const playlist = playlistsReponse[0]
+    const playlistTrackIds = playlist.playlist_contents.track_ids.map(a => a.track)
+
+    // Check if each track is in the playlist
+    const invalidTrackIds = []
+    for (const trackId of playlistTrackIds) {
+      const trackInPlaylist = await this.contracts.PlaylistFactoryClient.isTrackInPlaylist(playlistId, trackId)
+      if (!trackInPlaylist) invalidTrackIds.push(trackId)
+    }
+
+    return {
+      isValid: invalidTrackIds.length === 0,
+      invalidTrackIds
+    }
+  }
+
+  /**
+   * Uploads a cover photo for a playlist without updating the actual playlist
+   * @param {File} coverPhotoFile the file to upload as the cover photo
+   * @return {string} CID of the uploaded cover photo
+   */
+  async uploadPlaylistCoverPhoto (coverPhotoFile) {
+    this.REQUIRES(Services.CREATOR_NODE)
+
+    const updatedPlaylistImage = await this.creatorNode.uploadImage(
+      coverPhotoFile,
+      true // square
+    )
+    return updatedPlaylistImage.dirCID
+  }
+
+  /**
+   * Updates the cover photo for a playlist
+   * @param {number} playlistId
+   * @param {File} coverPhoto
+   */
+  async updatePlaylistCoverPhoto (playlistId, coverPhoto) {
+    this.REQUIRES(Services.CREATOR_NODE)
+
+    const updatedPlaylistImageDirCid = await this.uploadPlaylistCoverPhoto(coverPhoto, true)
+    return this.contracts.PlaylistFactoryClient.updatePlaylistCoverPhoto(
+      playlistId,
+      Utils.formatOptionalMultihash(updatedPlaylistImageDirCid)
+    )
+  }
+
+  /**
+   * Updates a playlist name
+   * @param {number} playlistId
+   * @param {string} playlistName
+   */
+  async updatePlaylistName (playlistId, playlistName) {
+    return this.contracts.PlaylistFactoryClient.updatePlaylistName(playlistId, playlistName)
+  }
+
+  /**
+   * Updates a playlist description
+   * @param {number} playlistId
+   * @param {string} updatedPlaylistDescription
+   */
+  async updatePlaylistDescription (playlistId, updatedPlaylistDescription) {
+    return this.contracts.PlaylistFactoryClient.updatePlaylistDescription(playlistId, updatedPlaylistDescription)
+  }
+
+  /**
+   * Updates whether a playlist is public or private
+   * @param {number} playlistId
+   * @param {boolean} updatedPlaylistPrivacy
+   */
+  async updatePlaylistPrivacy (playlistId, updatedPlaylistPrivacy) {
+    return this.contracts.PlaylistFactoryClient.updatePlaylistPrivacy(playlistId, updatedPlaylistPrivacy)
+  }
+
+  /**
+   * Reposts a playlist for a user
+   * @param {number} userId
+   * @param {number} playlistId
+   */
+  async addPlaylistRepost (playlistId) {
+    const userId = this.userStateManager.getCurrentUserId()
+    return this.contracts.SocialFeatureFactoryClient.addPlaylistRepost(userId, playlistId)
+  }
+
+  /**
+   * Undoes a repost on a playlist for a user
+   * @param {number} userId
+   * @param {number} playlistId
+   */
+  async deletePlaylistRepost (playlistId) {
+    const userId = this.userStateManager.getCurrentUserId()
+    return this.contracts.SocialFeatureFactoryClient.deletePlaylistRepost(userId, playlistId)
+  }
+
+  /**
+   * Marks a track to be deleted from a playlist. The playlist entry matching
+   * the provided timestamp is deleted in the case of duplicates.
+   * @param {number} playlistId
+   * @param {number} deletedTrackId
+   * @param {string} deletedPlaylistTimestamp parseable timestamp (to be copied from playlist metadata)
+   * @param {number?} retriesOverride [Optional, defaults to web3Manager.sendTransaction retries default]
+   */
+  async deletePlaylistTrack (playlistId, deletedTrackId, deletedPlaylistTimestamp, retriesOverride) {
+    return this.contracts.PlaylistFactoryClient.deletePlaylistTrack(playlistId, deletedTrackId, deletedPlaylistTimestamp, retriesOverride)
+  }
+
+  /**
+   * Saves a playlist on behalf of a user
+   * @param {number} userId
+   * @param {number} playlistId
+   */
+  async addPlaylistSave (playlistId) {
+    const userId = this.userStateManager.getCurrentUserId()
+    return this.contracts.UserLibraryFactoryClient.addPlaylistSave(userId, playlistId)
+  }
+
+  /**
+   * Unsaves a playlist on behalf of a user
+   * @param {number} userId
+   * @param {number} playlistId
+   */
+  async deletePlaylistSave (playlistId) {
+    const userId = this.userStateManager.getCurrentUserId()
+    return this.contracts.UserLibraryFactoryClient.deletePlaylistSave(userId, playlistId)
+  }
+
+  /**
+   * Marks a playlist as deleted
+   * @param {number} playlistId
+   */
+  async deletePlaylist (playlistId) {
+    return this.contracts.PlaylistFactoryClient.deletePlaylist(playlistId)
+  }
+}
+
+module.exports = Playlists

package/src/api/rewards.d.ts

@@ -0,0 +1,4 @@
+// Placeholder type for rewardsAttester.ts
+declare const SubmitAndEvaluateError: any
+
+export { SubmitAndEvaluateError }