@audius/sdk 0.0.0

package/src/services/dataContracts/AudiusContracts.ts

@@ -0,0 +1,234 @@
+import { Utils, Logger } from '../../utils'
+
+// load classes wrapping contracts
+import { RegistryClient } from './RegistryClient'
+import { UserFactoryClient } from './UserFactoryClient'
+import { TrackFactoryClient } from './TrackFactoryClient'
+import { SocialFeatureFactoryClient } from './SocialFeatureFactoryClient'
+import { PlaylistFactoryClient } from './PlaylistFactoryClient'
+import { UserLibraryFactoryClient } from './UserLibraryFactoryClient'
+import { IPLDBlacklistFactoryClient } from './IPLDBlacklistFactoryClient'
+import { UserReplicaSetManagerClient } from './UserReplicaSetManagerClient'
+import type { Web3Manager } from '../web3Manager'
+import type { ContractClient } from '../contracts/ContractClient'
+
+// Make sure the json file exists before importing because it could silently fail
+// import data contract ABI's
+const RegistryABI = Utils.importDataContractABI('Registry.json').abi
+const UserFactoryABI = Utils.importDataContractABI('UserFactory.json').abi
+const TrackFactoryABI = Utils.importDataContractABI('TrackFactory.json').abi
+const SocialFeatureFactoryABI = Utils.importDataContractABI(
+  'SocialFeatureFactory.json'
+).abi
+const PlaylistFactoryABI = Utils.importDataContractABI(
+  'PlaylistFactory.json'
+).abi
+const UserLibraryFactoryABI = Utils.importDataContractABI(
+  'UserLibraryFactory.json'
+).abi
+const IPLDBlacklistFactoryABI = Utils.importDataContractABI(
+  'IPLDBlacklistFactory.json'
+).abi
+const UserReplicaSetManagerABI = Utils.importDataContractABI(
+  'UserReplicaSetManager.json'
+).abi
+
+// define contract registry keys
+const UserFactoryRegistryKey = 'UserFactory'
+const TrackFactoryRegistryKey = 'TrackFactory'
+const SocialFeatureFactoryRegistryKey = 'SocialFeatureFactory'
+const PlaylistFactoryRegistryKey = 'PlaylistFactory'
+const UserLibraryFactoryRegistryKey = 'UserLibraryFactory'
+const IPLDBlacklistFactoryRegistryKey = 'IPLDBlacklistFactory'
+const UserReplicaSetManagerRegistryKey = 'UserReplicaSetManager'
+
+export class AudiusContracts {
+  web3Manager: Web3Manager
+  registryAddress: string
+  isServer: boolean
+  logger: Logger
+  RegistryClient: RegistryClient
+  UserFactoryClient: UserFactoryClient
+  TrackFactoryClient: TrackFactoryClient
+  SocialFeatureFactoryClient: SocialFeatureFactoryClient
+  PlaylistFactoryClient: PlaylistFactoryClient
+  UserLibraryFactoryClient: UserLibraryFactoryClient
+  IPLDBlacklistFactoryClient: IPLDBlacklistFactoryClient
+  contractClients: ContractClient[]
+  UserReplicaSetManagerClient: UserReplicaSetManagerClient | undefined | null
+  contracts: Record<string, string> | undefined
+  contractAddresses: Record<string, string> | undefined
+
+  constructor(
+    web3Manager: Web3Manager,
+    registryAddress: string,
+    isServer: boolean,
+    logger = console
+  ) {
+    this.web3Manager = web3Manager
+    this.registryAddress = registryAddress
+    this.isServer = isServer
+    this.logger = logger
+
+    this.RegistryClient = new RegistryClient(
+      this.web3Manager,
+      RegistryABI,
+      this.registryAddress
+    )
+    this.getRegistryAddressForContract =
+      this.getRegistryAddressForContract.bind(this)
+
+    this.UserFactoryClient = new UserFactoryClient(
+      this.web3Manager,
+      UserFactoryABI,
+      UserFactoryRegistryKey,
+      this.getRegistryAddressForContract,
+      this.logger
+    )
+
+    this.TrackFactoryClient = new TrackFactoryClient(
+      this.web3Manager,
+      TrackFactoryABI,
+      TrackFactoryRegistryKey,
+      this.getRegistryAddressForContract,
+      this.logger
+    )
+
+    this.SocialFeatureFactoryClient = new SocialFeatureFactoryClient(
+      this.web3Manager,
+      SocialFeatureFactoryABI,
+      SocialFeatureFactoryRegistryKey,
+      this.getRegistryAddressForContract,
+      this.logger
+    )
+
+    this.PlaylistFactoryClient = new PlaylistFactoryClient(
+      this.web3Manager,
+      PlaylistFactoryABI,
+      PlaylistFactoryRegistryKey,
+      this.getRegistryAddressForContract,
+      this.logger
+    )
+
+    this.UserLibraryFactoryClient = new UserLibraryFactoryClient(
+      this.web3Manager,
+      UserLibraryFactoryABI,
+      UserLibraryFactoryRegistryKey,
+      this.getRegistryAddressForContract,
+      this.logger
+    )
+
+    this.IPLDBlacklistFactoryClient = new IPLDBlacklistFactoryClient(
+      this.web3Manager,
+      IPLDBlacklistFactoryABI,
+      IPLDBlacklistFactoryRegistryKey,
+      this.getRegistryAddressForContract,
+      this.logger
+    )
+
+    this.contractClients = [
+      this.UserFactoryClient,
+      this.TrackFactoryClient,
+      this.SocialFeatureFactoryClient,
+      this.PlaylistFactoryClient,
+      this.UserLibraryFactoryClient,
+      this.IPLDBlacklistFactoryClient
+    ]
+  }
+
+  async init() {
+    if (this.isServer) {
+      await Promise.all(
+        this.contractClients.map(async (client) => await client.init())
+      )
+      await this.initUserReplicaSetManagerClient()
+    }
+  }
+
+  // Special case initialization flow for UserReplicaSetManagerClient backwards compatibility
+  // Until the contract is deployed and added to the data contract registry, replica set
+  // operations will flow through the existing UserFactory
+  async initUserReplicaSetManagerClient() {
+    try {
+      if (
+        this.UserReplicaSetManagerClient &&
+        this.UserReplicaSetManagerClient._contractAddress !==
+          '0x0000000000000000000000000000000000000000'
+      ) {
+        return
+      }
+
+      this.UserReplicaSetManagerClient = new UserReplicaSetManagerClient(
+        this.web3Manager,
+        UserReplicaSetManagerABI,
+        UserReplicaSetManagerRegistryKey,
+        this.getRegistryAddressForContract,
+        this.logger
+      )
+      await this.UserReplicaSetManagerClient.init()
+      if (
+        this.UserReplicaSetManagerClient._contractAddress ===
+        '0x0000000000000000000000000000000000000000'
+      ) {
+        throw new Error(
+          `Failed retrieve address for ${this.UserReplicaSetManagerClient.contractRegistryKey}`
+        )
+      }
+      const seedComplete =
+        await this.UserReplicaSetManagerClient.getSeedComplete()
+      if (!seedComplete) {
+        throw new Error('UserReplicaSetManager pending seed operation')
+      }
+    } catch (e) {
+      // Nullify failed attempt to initialize
+      console.log(
+        `Failed to initialize UserReplicaSetManagerClient with error ${
+          (e as Error).message
+        }`
+      )
+      this.UserReplicaSetManagerClient = null
+    }
+  }
+
+  /* ------- CONTRACT META-FUNCTIONS ------- */
+
+  /**
+   * Retrieves contract address from Registry by key, caching previously retrieved data.
+   * Refreshes cache if cached value is empty or zero address.
+   * Value is empty during first time call, and zero if call is made before contract is deployed,
+   *    since Registry sets default value of all contract keys to zero address if not registered.
+   * @param contractName registry key of contract
+   */
+  async getRegistryAddressForContract(contractName: string) {
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer#Computed_property_names
+    this.contracts = this.contracts ?? { [this.registryAddress]: 'registry' }
+    this.contractAddresses = this.contractAddresses ?? {
+      registry: this.registryAddress
+    }
+
+    if (
+      !this.contractAddresses[contractName] ||
+      Utils.isZeroAddress(this.contractAddresses[contractName] as string)
+    ) {
+      const address = (await this.RegistryClient.getContract(
+        contractName
+      )) as string
+      this.contracts[address] = contractName
+      this.contractAddresses[contractName] = address
+    }
+    return this.contractAddresses[contractName] as string
+  }
+
+  async getRegistryContractForAddress(address: string) {
+    if (!this.contracts) {
+      throw new Error('No contracts found. Have you called init() yet?')
+    }
+    const contractRegistryKey = this.contracts[address]
+    if (!contractRegistryKey) {
+      throw new Error(
+        `No registry contract found for contract address ${address}`
+      )
+    }
+    return contractRegistryKey
+  }
+}

package/src/services/dataContracts/IPLDBlacklistFactoryClient.ts

@@ -0,0 +1,73 @@
+import { ContractClient } from '../contracts/ContractClient'
+import * as signatureSchemas from '../../../data-contracts/signatureSchemas'
+import sigUtil, { EIP712TypedData } from 'eth-sig-util'
+import { Buffer as SafeBuffer } from 'safe-buffer'
+import type { Web3Manager } from '../web3Manager'
+
+type GeneratorFn = (
+  chainId: number,
+  contractAddress: string,
+  multihashDigest: string,
+  nonce: string
+) => EIP712TypedData
+
+export class IPLDBlacklistFactoryClient extends ContractClient {
+  async addIPLDToBlacklist(multihashDigest: string, privateKey = null) {
+    const [nonce, sig] = await this.getUpdateNonceAndSig(
+      signatureSchemas.generators.addIPLDToBlacklistRequestData,
+      multihashDigest,
+      privateKey
+    )
+    const method = await this.getMethod(
+      'addIPLDToBlacklist',
+      multihashDigest,
+      nonce,
+      sig
+    )
+
+    const receipt = await method.send({
+      from: this.web3Manager.getWalletAddress(),
+      gas: 200000
+    })
+    return receipt
+  }
+
+  /* ------- HELPERS ------- */
+
+  /**
+   * Gets a nonce and generates a signature for the given function. Private key is optional and
+   * will use that private key to create the  signature. Otherwise the web3Manager private key
+   * will be used.
+   * @param generatorFn signature scheme object function
+   * @param multihashDigest blockchain userId
+   * @param privateKey optional. if this is passed in, the signature will be from
+   * this private key. the type is a 64 character hex string
+   */
+  async getUpdateNonceAndSig(
+    generatorFn: GeneratorFn,
+    multihashDigest: string,
+    privateKey: string | null
+  ) {
+    const nonce = signatureSchemas.getNonce()
+    const chainId = await this.getEthNetId()
+    const contractAddress = await this.getAddress()
+    const signatureData = generatorFn(
+      chainId,
+      contractAddress,
+      multihashDigest,
+      nonce
+    )
+    let sig
+    if (privateKey) {
+      sig = sigUtil.signTypedData(
+        SafeBuffer.from(privateKey, 'hex') as unknown as Buffer,
+        {
+          data: signatureData
+        }
+      )
+    } else {
+      sig = await (this.web3Manager as Web3Manager).signTypedData(signatureData)
+    }
+    return [nonce, sig]
+  }
+}

package/src/services/dataContracts/PlaylistFactoryClient.ts

@@ -0,0 +1,370 @@
+import { ContractClient } from '../contracts/ContractClient'
+import * as signatureSchemas from '../../../data-contracts/signatureSchemas'
+import type { Web3Manager } from '../web3Manager'
+
+const MAX_PLAYLIST_LENGTH = 199
+
+export class PlaylistFactoryClient extends ContractClient {
+  override web3Manager!: Web3Manager
+  /* ------- SETTERS ------- */
+
+  async createPlaylist(
+    userId: number,
+    playlistName: string,
+    isPrivate: boolean,
+    isAlbum: boolean,
+    trackIds: number[]
+  ) {
+    if (!Array.isArray(trackIds) || trackIds.length > MAX_PLAYLIST_LENGTH) {
+      throw new Error(
+        `Cannot create playlist - trackIds must be array with length <= ${MAX_PLAYLIST_LENGTH}`
+      )
+    }
+
+    const nonce = signatureSchemas.getNonce()
+    const chainId = await this.getEthNetId()
+    const contractAddress = await this.getAddress()
+    const trackIdsHash = this.web3Manager
+      .getWeb3()
+      .utils.soliditySha3(
+        this.web3Manager.getWeb3().eth.abi.encodeParameter('uint[]', trackIds)
+      )
+    const signatureData =
+      signatureSchemas.generators.getCreatePlaylistRequestData(
+        chainId,
+        contractAddress,
+        userId,
+        playlistName,
+        isPrivate,
+        isAlbum,
+        trackIdsHash,
+        nonce
+      )
+    const sig = await this.web3Manager.signTypedData(signatureData)
+
+    const method = await this.getMethod(
+      'createPlaylist',
+      userId,
+      playlistName,
+      isPrivate,
+      isAlbum,
+      trackIds,
+      nonce,
+      sig
+    )
+
+    const tx = await this.web3Manager.sendTransaction(
+      method,
+      this.contractRegistryKey,
+      contractAddress
+    )
+    return {
+      playlistId: parseInt(
+        tx.events?.['PlaylistCreated']?.returnValues._playlistId,
+        10
+      ),
+      txReceipt: tx
+    }
+  }
+
+  async deletePlaylist(playlistId: number) {
+    const nonce = signatureSchemas.getNonce()
+    const chainId = await this.getEthNetId()
+    const contractAddress = await this.getAddress()
+    const signatureData =
+      signatureSchemas.generators.getDeletePlaylistRequestData(
+        chainId,
+        contractAddress,
+        playlistId,
+        nonce
+      )
+
+    const sig = await this.web3Manager.signTypedData(signatureData)
+    const method = await this.getMethod(
+      'deletePlaylist',
+      playlistId,
+      nonce,
+      sig
+    )
+
+    const tx = await this.web3Manager.sendTransaction(
+      method,
+      this.contractRegistryKey,
+      contractAddress
+    )
+    return {
+      playlistId: parseInt(
+        tx.events?.['PlaylistDeleted']?.returnValues._playlistId,
+        10
+      ),
+      txReceipt: tx
+    }
+  }
+
+  async addPlaylistTrack(playlistId: number, addedTrackId: number) {
+    const nonce = signatureSchemas.getNonce()
+    const chainId = await this.getEthNetId()
+    const contractAddress = await this.getAddress()
+    const signatureData =
+      signatureSchemas.generators.getAddPlaylistTrackRequestData(
+        chainId,
+        contractAddress,
+        playlistId,
+        addedTrackId,
+        nonce
+      )
+    const sig = await this.web3Manager.signTypedData(signatureData)
+
+    const method = await this.getMethod(
+      'addPlaylistTrack',
+      playlistId,
+      addedTrackId,
+      nonce,
+      sig
+    )
+
+    return await this.web3Manager.sendTransaction(
+      method,
+      this.contractRegistryKey,
+      contractAddress
+    )
+  }
+
+  async deletePlaylistTrack(
+    playlistId: number,
+    deletedTrackId: number,
+    deletedPlaylistTimestamp: number,
+    retries: number
+  ) {
+    const nonce = signatureSchemas.getNonce()
+    const chainId = await this.getEthNetId()
+    const contractAddress = await this.getAddress()
+    const signatureData =
+      signatureSchemas.generators.getDeletePlaylistTrackRequestData(
+        chainId,
+        contractAddress,
+        playlistId,
+        deletedTrackId,
+        deletedPlaylistTimestamp,
+        nonce
+      )
+
+    const sig = await this.web3Manager.signTypedData(signatureData)
+    const method = await this.getMethod(
+      'deletePlaylistTrack',
+      playlistId,
+      deletedTrackId,
+      deletedPlaylistTimestamp,
+      nonce,
+      sig
+    )
+
+    return await this.web3Manager.sendTransaction(
+      method,
+      this.contractRegistryKey,
+      contractAddress,
+      retries
+    )
+  }
+
+  async orderPlaylistTracks(
+    playlistId: number,
+    trackIds: number[],
+    retries: number
+  ) {
+    const nonce = signatureSchemas.getNonce()
+    const chainId = await this.getEthNetId()
+    const contractAddress = await this.getAddress()
+    const trackIdsHash = this.web3Manager
+      .getWeb3()
+      .utils.soliditySha3(
+        this.web3Manager.getWeb3().eth.abi.encodeParameter('uint[]', trackIds)
+      )
+    const signatureData =
+      signatureSchemas.generators.getOrderPlaylistTracksRequestData(
+        chainId,
+        contractAddress,
+        playlistId,
+        trackIdsHash,
+        nonce
+      )
+    const sig = await this.web3Manager.signTypedData(signatureData)
+
+    const method = await this.getMethod(
+      'orderPlaylistTracks',
+      playlistId,
+      trackIds,
+      nonce,
+      sig
+    )
+
+    return await this.web3Manager.sendTransaction(
+      method, // contractMethod
+      this.contractRegistryKey,
+      contractAddress,
+      retries
+    )
+  }
+
+  async updatePlaylistPrivacy(
+    playlistId: number,
+    updatedPlaylistPrivacy: string
+  ) {
+    const nonce = signatureSchemas.getNonce()
+    const chainId = await this.getEthNetId()
+    const contractAddress = await this.getAddress()
+    const signatureData =
+      signatureSchemas.generators.getUpdatePlaylistPrivacyRequestData(
+        chainId,
+        contractAddress,
+        playlistId,
+        updatedPlaylistPrivacy,
+        nonce
+      )
+    const sig = await this.web3Manager.signTypedData(signatureData)
+
+    const method = await this.getMethod(
+      'updatePlaylistPrivacy',
+      playlistId,
+      updatedPlaylistPrivacy,
+      nonce,
+      sig
+    )
+
+    return await this.web3Manager.sendTransaction(
+      method,
+      this.contractRegistryKey,
+      contractAddress
+    )
+  }
+
+  async updatePlaylistName(playlistId: number, updatedPlaylistName: string) {
+    const nonce = signatureSchemas.getNonce()
+    const chainId = await this.getEthNetId()
+    const contractAddress = await this.getAddress()
+    const signatureData =
+      signatureSchemas.generators.getUpdatePlaylistNameRequestData(
+        chainId,
+        contractAddress,
+        playlistId,
+        updatedPlaylistName,
+        nonce
+      )
+    const sig = await this.web3Manager.signTypedData(signatureData)
+
+    const method = await this.getMethod(
+      'updatePlaylistName',
+      playlistId,
+      updatedPlaylistName,
+      nonce,
+      sig
+    )
+
+    return await this.web3Manager.sendTransaction(
+      method,
+      this.contractRegistryKey,
+      contractAddress
+    )
+  }
+
+  async updatePlaylistCoverPhoto(
+    playlistId: number,
+    updatedPlaylistImageMultihashDigest: string
+  ) {
+    const nonce = signatureSchemas.getNonce()
+    const chainId = await this.getEthNetId()
+    const contractAddress = await this.getAddress()
+    const signatureData =
+      signatureSchemas.generators.getUpdatePlaylistCoverPhotoRequestData(
+        chainId,
+        contractAddress,
+        playlistId,
+        updatedPlaylistImageMultihashDigest,
+        nonce
+      )
+    const sig = await this.web3Manager.signTypedData(signatureData)
+
+    const method = await this.getMethod(
+      'updatePlaylistCoverPhoto',
+      playlistId,
+      updatedPlaylistImageMultihashDigest,
+      nonce,
+      sig
+    )
+
+    return await this.web3Manager.sendTransaction(
+      method,
+      this.contractRegistryKey,
+      contractAddress
+    )
+  }
+
+  async updatePlaylistDescription(
+    playlistId: number,
+    updatedPlaylistDescription: string
+  ) {
+    const nonce = signatureSchemas.getNonce()
+    const chainId = await this.getEthNetId()
+    const contractAddress = await this.getAddress()
+    const signatureData =
+      signatureSchemas.generators.getUpdatePlaylistDescriptionRequestData(
+        chainId,
+        contractAddress,
+        playlistId,
+        updatedPlaylistDescription,
+        nonce
+      )
+    const sig = await this.web3Manager.signTypedData(signatureData)
+    const method = await this.getMethod(
+      'updatePlaylistDescription',
+      playlistId,
+      updatedPlaylistDescription,
+      nonce,
+      sig
+    )
+
+    return await this.web3Manager.sendTransaction(
+      method,
+      this.contractRegistryKey,
+      contractAddress
+    )
+  }
+
+  async updatePlaylistUPC(playlistId: number, updatedPlaylistUPC: string) {
+    const nonce = signatureSchemas.getNonce()
+    const chainId = await this.getEthNetId()
+    const contractAddress = await this.getAddress()
+    const signatureData =
+      signatureSchemas.generators.getUpdatePlaylistUPCRequestData(
+        chainId,
+        contractAddress,
+        playlistId,
+        this.web3Manager.getWeb3().utils.utf8ToHex(updatedPlaylistUPC),
+        nonce
+      )
+    const sig = await this.web3Manager.signTypedData(signatureData)
+    const method = await this.getMethod(
+      'updatePlaylistUPC',
+      playlistId,
+      this.web3Manager.getWeb3().utils.utf8ToHex(updatedPlaylistUPC),
+      nonce,
+      sig
+    )
+
+    return await this.web3Manager.sendTransaction(
+      method,
+      this.contractRegistryKey,
+      contractAddress
+    )
+  }
+
+  async isTrackInPlaylist(playlistId: number, trackId: number) {
+    const method = await this.getMethod(
+      'isTrackInPlaylist',
+      playlistId,
+      trackId
+    )
+    const result = await method.call()
+    return result
+  }
+}