@audius/sdk 0.0.0

package/src/sanityChecks/index.js

@@ -0,0 +1,31 @@
+const isCreator = require('./isCreator')
+const sanitizeNodes = require('./sanitizeNodes')
+const addSecondaries = require('./addSecondaries')
+const syncNodes = require('./syncNodes')
+const rolloverNodes = require('./rolloverNodes')
+const recoveryEmail = require('./needsRecoveryEmail')
+const assignReplicaSetIfNecessary = require('./assignReplicaSetIfNecessary')
+
+// Checks to run at startup to ensure a user is in a good state.
+class SanityChecks {
+  constructor (libsInstance, options = { skipRollover: false }) {
+    this.libs = libsInstance
+    this.options = options
+  }
+
+  /**
+   * Runs sanity checks
+   * @param {Set<string>} creatorNodeWhitelist
+   */
+  async run (creatorNodeWhitelist = null) {
+    await isCreator(this.libs)
+    await sanitizeNodes(this.libs)
+    await addSecondaries(this.libs)
+    await assignReplicaSetIfNecessary(this.libs)
+    await syncNodes(this.libs)
+    if (!this.options.skipRollover) await rolloverNodes(this.libs, creatorNodeWhitelist)
+    await recoveryEmail(this.libs)
+  }
+}
+
+module.exports = SanityChecks

package/src/sanityChecks/isCreator.js

@@ -0,0 +1,73 @@
+const axios = require('axios')
+
+/** Sanity check for whether a user is a creator. If not, make them one. */
+
+const hasCID = async (node, cid) => {
+  const url = `${node.endpoint}/ipfs/${cid}`
+  try {
+    const res = await axios.head(url)
+    return res.status === 200
+  } catch (e) {
+    return false
+  }
+}
+
+const hasAllCID = async (node, cids) => {
+  const hasAll = await Promise.all(cids.map(cid => hasCID(node, cid)))
+  return hasAll.every(Boolean)
+}
+
+const findCorrectNode = async (nodes, cids) => {
+  for (let i = 0; i < nodes.length; ++i) {
+    const hasAll = await hasAllCID(nodes[i], cids)
+    if (hasAll) return nodes[i]
+  }
+  return null
+}
+
+const isCreator = async (libs) => {
+  console.debug('Sanity Check - isCreator')
+  const user = libs.userStateManager.getCurrentUser()
+  if (
+    // There is no currently logged in user
+    !user ||
+    // The user has no tracks (they shouldn't become a creator)
+    !user.track_count ||
+    // The user is a creator and has a creator node endpoint
+    (user.is_creator && user.creator_node_endpoint)
+  ) return
+
+  console.debug('Sanity Check - isCreator - Running Check')
+
+  // Find the CIDs for all of the user's content (tracks + images)
+  let cids = [
+    user.profile_picture,
+    user.cover_photo
+  ]
+  const tracks = await libs.Track.getTracks(500, 0, null, user.user_id)
+  tracks.forEach(track => {
+    cids.push(track.cover_art)
+    cids.push(track.metadata_multihash)
+    track.track_segments.forEach(segment => {
+      cids.push(segment.multihash)
+    })
+  })
+  cids = cids.filter(Boolean)
+
+  // Check whether all the CIDs are availabile on a creator node
+  const nodes = await libs.ServiceProvider.listCreatorNodes()
+  const correctNode = await findCorrectNode(nodes, cids)
+
+  // Upgrade the user to a creator
+  if (correctNode) {
+    try {
+      console.debug('Sanity Check - isCreator - Upgrading to Creator')
+      await libs.User.upgradeToCreator(null, correctNode.endpoint)
+    } catch (e) {
+      console.error(e)
+      // We were actually a creator the whole time O_O
+    }
+  }
+}
+
+module.exports = isCreator

package/src/sanityChecks/needsRecoveryEmail.js

@@ -0,0 +1,20 @@
+/**
+ * Sanity check for whether a user needs a recovery email to be sent.
+ * Users with accounts created before email recovery existed need
+ * to be sent an email on their next log-in just in case they get logged
+ * out of their account.
+ */
+const needsRecoveryEmail = async (libs) => {
+  console.debug('Sanity Check - needsRecoveryEmail')
+  const user = libs.userStateManager.getCurrentUser()
+  if (!user || !user.wallet) return
+
+  const events = await libs.identityService.getUserEvents(user.wallet)
+  if (events.needsRecoveryEmail) {
+    console.debug('Sanity Check - needsRecoveryEmail - Sending Email')
+    // Send email
+    await libs.Account.generateRecoveryLink()
+  }
+}
+
+module.exports = needsRecoveryEmail

package/src/sanityChecks/rolloverNodes.js

@@ -0,0 +1,74 @@
+const { Utils } = require('../utils')
+const { CreatorNode } = require('../services/creatorNode')
+
+const THREE_SECONDS = 3000
+const MAX_TRIES = 3
+
+/** Check if the user's primary creator node is healthy */
+const checkPrimaryHealthy = async (libs, primary, tries) => {
+  const healthy = await Utils.isHealthy(primary)
+  if (healthy) return healthy
+  else {
+    if (tries === 0) {
+      return false
+    }
+    await Utils.wait(THREE_SECONDS)
+    return checkPrimaryHealthy(libs, primary, tries - 1)
+  }
+}
+
+/** Gets new endpoints from a user's secondaries */
+const getNewPrimary = async (libs, secondaries) => {
+  for (const secondary of secondaries) {
+    const { isBehind } = await libs.creatorNode.getSyncStatus(secondary)
+    if (!isBehind) {
+      return secondary
+    }
+  }
+  throw new Error(`Could not find valid secondaries for user ${secondaries}`)
+}
+
+const rolloverNodes = async (libs, creatorNodeWhitelist) => {
+  console.debug('Sanity Check - rolloverNodes')
+  const user = libs.userStateManager.getCurrentUser()
+
+  if (!user || !user.is_creator) return
+
+  const primary = CreatorNode.getPrimary(user.creator_node_endpoint)
+  const healthy = await checkPrimaryHealthy(libs, primary, MAX_TRIES)
+  if (healthy) return
+
+  const secondaries = CreatorNode.getSecondaries(user.creator_node_endpoint)
+
+  try {
+    // Get a new primary
+    const newPrimary = await getNewPrimary(libs, secondaries)
+    const index = secondaries.indexOf(newPrimary)
+    // Get new secondaries and backfill up to 2
+    let newSecondaries = [...secondaries]
+    newSecondaries.splice(index, 1)
+    const autoselect = await libs.ServiceProvider.autoSelectCreatorNodes({
+      numberOfNodes: 2 - newSecondaries.length,
+      whitelist: creatorNodeWhitelist,
+      // Exclude ones we currently have
+      blacklist: new Set([newPrimary, ...newSecondaries]),
+      preferHigherPatchForPrimary: libs.User.preferHigherPatchForPrimary,
+      preferHigherPatchForSecondaries: libs.User.preferHigherPatchForSecondaries
+    })
+    newSecondaries = newSecondaries.concat([autoselect.primary, ...autoselect.secondaries])
+
+    // Set the new endpoint and connect to it
+    const newEndpoints = [newPrimary, ...newSecondaries]
+    await libs.creatorNode.setEndpoint(newEndpoints[0])
+
+    // Update the user
+    const newMetadata = { ...user }
+    newMetadata.creator_node_endpoint = newEndpoints.join(',')
+    console.debug(`Sanity Check - rolloverNodes - new nodes ${newMetadata.creator_node_endpoint}`)
+    await libs.User.updateCreator(user.user_id, newMetadata)
+  } catch (e) {
+    console.error(e)
+  }
+}
+
+module.exports = rolloverNodes

package/src/sanityChecks/sanitizeNodes.js

@@ -0,0 +1,24 @@
+/**
+ * Sanitize user.creator_node_endpoint
+ * Goal: Make it so we never end up in a state like creator_node_endpoint = "https://cn1.co,,"
+ */
+const sanitizeNodes = async (libs, secondaries) => {
+  console.debug('Sanity Check - sanitizeNodes')
+  const user = libs.userStateManager.getCurrentUser()
+
+  if (!user || !user.is_creator) return
+
+  const sanitizedEndpoint = user.creator_node_endpoint
+    .split(',')
+    .filter(Boolean)
+    .join(',')
+
+  if (sanitizedEndpoint !== user.creator_node_endpoint) {
+    console.debug(`Sanity Check - sanitizingNodes - ${user.creator_node_endpoint} -> ${sanitizedEndpoint}`)
+    const newMetadata = { ...user }
+    newMetadata.creator_node_endpoint = sanitizedEndpoint
+    await libs.User.updateCreator(user.user_id, newMetadata)
+  }
+}
+
+module.exports = sanitizeNodes

package/src/sanityChecks/syncNodes.js

@@ -0,0 +1,28 @@
+const { CreatorNode } = require('../services/creatorNode')
+/**
+ * Syncs a creator node if its blocknubmer is behind the passed
+ * in blocknumber.
+ */
+const syncNodeIfBehind = async (libs, endpoint) => {
+  try {
+    const { isBehind, isConfigured } = await libs.creatorNode.getSyncStatus(endpoint)
+    if (isBehind || !isConfigured) {
+      console.debug(`Sanity Check - syncNodes - syncing ${endpoint}`)
+      await libs.creatorNode.syncSecondary(endpoint)
+    }
+  } catch (e) {
+    console.error(e)
+  }
+}
+
+const syncNodes = async (libs) => {
+  console.debug('Sanity Check - syncNodes')
+  const user = libs.userStateManager.getCurrentUser()
+
+  if (!user || !user.is_creator) return
+
+  const secondaries = CreatorNode.getSecondaries(user.creator_node_endpoint)
+  await Promise.all(secondaries.map(secondary => syncNodeIfBehind(libs, secondary)))
+}
+
+module.exports = syncNodes

package/src/sdk/constants.ts

@@ -0,0 +1,10 @@
+export const CLAIM_DISTRIBUTION_CONTRACT_ADDRESS =
+  '0x683c19E621A0F107a291fdAB38f80179809d61B5'
+export const ETH_OWNER_WALLET = '0xC7310a03e930DD659E15305ed7e1F5Df0F0426C5'
+export const ETH_PROVIDER_URLS = 'https://eth.audius.co'
+export const ETH_REGISTRY_ADDRESS = '0xd976d3b4f4e22a238c1A736b6612D22f17b6f64C'
+export const ETH_TOKEN_ADDRESS = '0x18aAA7115705e8be94bfFEBDE57Af9BFc265B998'
+export const IDENTITY_SERVICE_ENDPOINT = 'https://identityservice.audius.co'
+export const REGISTRY_ADDRESS = '0xC611C82150b56E6e4Ec5973AcAbA8835Dd0d75A2'
+export const WEB3_PROVIDER_URL = 'https://poa-gateway.audius.co'
+export const WORMHOLE_ADDRESS = '0x6E7a1F7339bbB62b23D44797b63e4258d283E095'

package/src/sdk/index.ts

@@ -0,0 +1 @@
+export { sdk } from './sdk'

package/src/sdk/oauth/Oauth.ts

@@ -0,0 +1,265 @@
+import type {
+  DiscoveryProvider,
+  UserProfile
+} from '../../services/discoveryProvider'
+
+export type LoginSuccessCallback = (profile: UserProfile) => void
+export type LoginErrorCallback = (errorMessage: string) => void
+export type ButtonOptions = {
+  size: 'small' | 'medium' | 'large'
+  corners: 'default' | 'pill'
+  customText: string
+  disableHoverGrow: boolean
+  fullWidth: boolean
+}
+
+const CSS = `
+.audiusLoginButton {
+  cursor: pointer;
+  font-family: Helvetica, Arial, sans-serif;
+  text-align: center;
+  color: #FFFFFF;
+  font-weight: 700;
+  font-size: 14px;
+  line-height: 100%;
+  align-items: center;
+  display: flex;
+  border: 0;
+  height: 28px;
+  justify-content: center;
+  padding: 0px 16px;
+  background: #CC0FE0;
+  border-radius: 4px;
+  transition: all 0.07s ease-in-out;
+}
+
+.audiusLoginButton:hover {
+  background: #D127E3;
+  transform: perspective(1px) scale3d(1.04, 1.04, 1.04);
+}
+
+.audiusLoginButton.disableHoverGrow:hover {
+  transform: none;
+}
+
+.audiusLoginButton:active {
+  background: #A30CB3;
+}
+
+.audiusLoginButton.pill {
+  border-radius: 99px;
+}
+
+.audiusLoginButton.fullWidth {
+  width: 100%;
+}
+
+.audiusLoginButton.small {
+  height: 20px;
+  font-size: 11px;
+  padding: 0px 32px;
+}
+
+.audiusLoginButton.large {
+  height: 40px;
+  font-size: 18px;
+  padding: 0px 18px;
+}
+`
+// From https://stackoverflow.com/a/27747377
+const generateId = (): string => {
+  const arr = new Uint8Array(40 / 2) // Result of function will be 40 chars long
+  // @ts-expect-error TS doesn't understand `msCrypto` (which provides compatibility for IE)
+  ;(window.crypto || window.msCrypto).getRandomValues(arr)
+  return Array.from(arr, function dec2hex(dec) {
+    return dec.toString(16).padStart(2, '0')
+  }).join('')
+}
+
+const generateAudiusLogoSvg = (size: 'small' | 'medium' | 'large') => {
+  let height: number
+  let paddingRight: number
+  if (size === 'small') {
+    height = 16
+    paddingRight = 5
+  } else if (size === 'medium') {
+    height = 18
+    paddingRight = 5
+  } else {
+    height = 24
+    paddingRight = 10
+  }
+  return `<svg width="${height}px" height="${height}px" viewBox="0 0 56 48" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" style="padding-right: ${paddingRight}px;">
+<g id="Assets" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+    <g id="assets" transform="translate(-1555.000000, -2588.000000)">
+        <g id="audiusLogoGlyph" transform="translate(1555.000000, 2588.000000)">
+            <path d="M55.8191698,46.0362519 L42.4551012,23.3458831 L36.1870263,12.7036635 L29.0910326,0.65551431 C28.5766233,-0.217848954 27.2890668,-0.218676884 26.7734944,0.654065432 L13.3787621,23.3270477 L7.90582764,32.5909699 C7.39025522,33.4637122 8.03324043,34.5553386 9.06332791,34.5560631 L19.4031138,34.56279 C19.881044,34.5631005 20.3230236,34.3136864 20.5623059,33.9087249 L25.9362708,24.8122516 L26.7580568,23.4212248 C26.790518,23.3662709 26.8260456,23.3149392 26.8641108,23.2669192 C27.4325516,22.5520012 28.5935412,22.6041608 29.0755951,23.4226737 L34.6514114,32.8894388 L35.682239,34.6396841 C35.7412402,34.7399672 35.7843808,34.8430445 35.813987,34.9470533 C36.0430129,35.7492145 35.4339691,36.6039494 34.5220954,36.6034319 L22.3586676,36.5954631 C21.8806317,36.5951526 21.4387578,36.8445667 21.1994756,37.2496317 L16.0236614,46.0105861 C15.5080889,46.8833284 16.1510741,47.9749548 17.1810559,47.9756793 L27.9002253,47.9827167 L41.2664086,47.9913065 L54.6590261,47.9999997 C55.6892193,48.0006207 56.3335791,46.9096152 55.8191698,46.0362519" id="Audius-Logo" fill="#ffffff" fill-rule="evenodd"></path>
+            <rect id="bound" x="0" y="0" width="56" height="48"></rect>
+        </g>
+    </g>
+</g>
+</svg>`
+}
+
+const OAUTH_URL = 'https://audius.co/oauth/auth'
+const CSRF_TOKEN_KEY = 'audiusOauthState'
+
+type OauthConfig = {
+  appName?: string
+  discoveryProvider: DiscoveryProvider
+}
+
+export class Oauth {
+  discoveryProvider: DiscoveryProvider
+  appName: string | null
+  activePopupWindow: null | Window
+  popupCheckInterval: NodeJS.Timer | null
+  loginSuccessCallback: LoginSuccessCallback | null
+  loginErrorCallback: LoginErrorCallback | null
+
+  constructor({ discoveryProvider, appName }: OauthConfig) {
+    if (typeof window === 'undefined') {
+      // TODO(nkang): Add link to documentation once written
+      throw new Error(
+        'Audius OAuth SDK functions are only available in browser. Refer to our documentation to learn how to implement Audius OAuth manually.'
+      )
+    }
+    this.discoveryProvider = discoveryProvider
+    this.appName = appName ?? null
+    this.activePopupWindow = null
+    this.loginSuccessCallback = null
+    this.loginErrorCallback = null
+    this.popupCheckInterval = null
+  }
+
+  init(
+    successCallback: LoginSuccessCallback,
+    errorCallback?: LoginErrorCallback
+  ) {
+    this.loginSuccessCallback = successCallback
+    this.loginErrorCallback = errorCallback ?? null
+    window.addEventListener(
+      'message',
+      (e: MessageEvent) => {
+        this._receiveMessage(e)
+      },
+      false
+    )
+  }
+
+  login() {
+    if (!this.appName) {
+      this._surfaceError('App name not set (set with `init` method).')
+      return
+    }
+    if (!this.loginSuccessCallback) {
+      this._surfaceError(
+        'Login success callback not set (set with `init` method).'
+      )
+      return
+    }
+
+    const csrfToken = generateId()
+    window.localStorage.setItem(CSRF_TOKEN_KEY, csrfToken)
+    const windowOptions =
+      'toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=no, resizable=no, copyhistory=no, width=375, height=720, top=100, left=100'
+    const originURISafe = encodeURIComponent(window.location.origin)
+    const appNameURISafe = encodeURI(this.appName)
+    const fullOauthUrl = `${OAUTH_URL}?scope=read&state=${csrfToken}&redirect_uri=postMessage&origin=${originURISafe}&app_name=${appNameURISafe}`
+    this.activePopupWindow = window.open(fullOauthUrl, '', windowOptions)
+    this._clearPopupCheckInterval()
+    this.popupCheckInterval = setInterval(() => {
+      if (this.activePopupWindow?.closed) {
+        this._surfaceError('The login popup was closed prematurely.')
+        if (this.popupCheckInterval) {
+          clearInterval(this.popupCheckInterval)
+        }
+      }
+    }, 500)
+  }
+
+  renderButton(element: HTMLElement, options?: ButtonOptions) {
+    if (!element) {
+      console.error('Target element for Audius OAuth button is empty.')
+    }
+    const style = document.createElement('style')
+    style.textContent = CSS
+    document.head.appendChild(style)
+    const button = document.createElement('button')
+    button.id = 'audius-login-button'
+    button.classList.add('audiusLoginButton')
+    if (options?.corners === 'pill') {
+      button.classList.add('pill')
+    }
+    if (options?.size === 'small') {
+      button.classList.add('small')
+    }
+    if (options?.size === 'large') {
+      button.classList.add('large')
+    }
+    if (options?.fullWidth) {
+      button.classList.add('fullWidth')
+    }
+    if (options?.disableHoverGrow) {
+      button.classList.add('disableHoverGrow')
+    }
+    button.innerHTML = `${generateAudiusLogoSvg(options?.size ?? 'medium')} ${
+      options?.customText ?? 'Continue With Audius'
+    }`
+    button.onclick = () => {
+      this.login()
+    }
+    element.replaceWith(button)
+  }
+
+  async verifyToken(token: string) {
+    return await this.discoveryProvider.verifyToken(token)
+  }
+
+  /* ------- INTERNAL FUNCTIONS ------- */
+
+  _surfaceError(errorMessage: string) {
+    if (this.loginErrorCallback) {
+      this.loginErrorCallback(errorMessage)
+    } else {
+      console.error(errorMessage)
+    }
+  }
+
+  _clearPopupCheckInterval() {
+    if (this.popupCheckInterval) {
+      clearInterval(this.popupCheckInterval)
+    }
+  }
+
+  async _receiveMessage(event: MessageEvent) {
+    const oauthOrigin = new URL(OAUTH_URL).origin
+    if (
+      event.origin !== oauthOrigin ||
+      event.source !== this.activePopupWindow ||
+      !event.data.state ||
+      !event.data.token
+    ) {
+      return
+    }
+    this._clearPopupCheckInterval()
+    if (this.activePopupWindow) {
+      if (!this.activePopupWindow.closed) {
+        this.activePopupWindow.close()
+      }
+      this.activePopupWindow = null
+    }
+    if (window.localStorage.getItem(CSRF_TOKEN_KEY) !== event.data.state) {
+      this._surfaceError('State mismatch.')
+    }
+    // Verify token and decode
+    const decodedJwt = await this.verifyToken(event.data.token)
+    if (decodedJwt) {
+      if (this.loginSuccessCallback) {
+        this.loginSuccessCallback(decodedJwt)
+      }
+    } else {
+      this._surfaceError('The token was invalid.')
+    }
+  }
+}

package/src/sdk/oauth/index.ts

@@ -0,0 +1 @@
+export * from './Oauth'

package/src/sdk/sdk.ts

@@ -0,0 +1,102 @@
+import {
+  DiscoveryProvider,
+  DiscoveryProviderConfig
+} from '../services/discoveryProvider'
+import { EthContracts, EthContractsConfig } from '../services/ethContracts'
+import { EthWeb3Config, EthWeb3Manager } from '../services/ethWeb3Manager'
+import { IdentityService } from '../services/identity'
+import { UserStateManager } from '../userStateManager'
+import { Oauth } from './oauth'
+
+import {
+  CLAIM_DISTRIBUTION_CONTRACT_ADDRESS,
+  ETH_OWNER_WALLET,
+  ETH_PROVIDER_URLS,
+  ETH_REGISTRY_ADDRESS,
+  ETH_TOKEN_ADDRESS,
+  IDENTITY_SERVICE_ENDPOINT,
+  WORMHOLE_ADDRESS
+} from './constants'
+
+type Web3Config = {
+  providers: string[]
+}
+
+type SdkConfig = {
+  appName: string
+  discoveryNodeConfig?: DiscoveryProviderConfig
+  ethContractsConfig?: EthContractsConfig
+  ethWeb3Config?: EthWeb3Config
+  identityServiceConfig?: IdentityService
+  web3Config?: Web3Config
+}
+
+/**
+ * The Audius SDK
+ */
+export const sdk = async (config?: SdkConfig) => {
+  const {
+    appName,
+    discoveryNodeConfig,
+    ethContractsConfig,
+    ethWeb3Config,
+    identityServiceConfig
+  } = config ?? {}
+
+  /** Initialize services */
+
+  const userStateManager = new UserStateManager()
+
+  const identityService = new IdentityService({
+    identityServiceEndpoint: IDENTITY_SERVICE_ENDPOINT,
+    ...identityServiceConfig
+  })
+
+  const ethWeb3Manager = new EthWeb3Manager({
+    identityService,
+    web3Config: {
+      ownerWallet: ETH_OWNER_WALLET,
+      ...ethWeb3Config,
+      providers: formatProviders(ethWeb3Config?.providers ?? ETH_PROVIDER_URLS)
+    }
+  })
+
+  const ethContracts = new EthContracts({
+    ethWeb3Manager,
+    tokenContractAddress: ETH_TOKEN_ADDRESS,
+    registryAddress: ETH_REGISTRY_ADDRESS,
+    claimDistributionContractAddress: CLAIM_DISTRIBUTION_CONTRACT_ADDRESS,
+    wormholeContractAddress: WORMHOLE_ADDRESS,
+    ...ethContractsConfig
+  })
+
+  const discoveryNode = new DiscoveryProvider({
+    ethContracts,
+    userStateManager,
+    ...discoveryNodeConfig
+  })
+
+  // TODO: potentially don't await this and have a different method (callback/event) to
+  // know when the sdk is initialized
+  await discoveryNode.init()
+
+  const oauth =
+    typeof window !== 'undefined'
+      ? new Oauth({ discoveryProvider: discoveryNode, appName })
+      : undefined
+
+  return {
+    oauth,
+    discoveryNode
+  }
+}
+
+const formatProviders = (providers: string | string[]) => {
+  if (typeof providers === 'string') {
+    return providers.split(',')
+  } else if (Array.isArray(providers)) {
+    return providers
+  } else {
+    throw new Error('Providers must be of type string, Array, or Web3 instance')
+  }
+}