@audius/sdk 1.0.36 → 1.0.37

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@audius/sdk",
-  "version": "1.0.36",
+  "version": "1.0.37",
   "audius": {
-    "releaseSHA": "f5d39ff9c22d1fe9b5ca9c14261a1690575af34d"
+    "releaseSHA": "dd0ddae94286c577c8a34ada50f2f79f613b55d2"
   },
   "description": "",
   "main": "dist/index.cjs.js",

package/src/api/Account.ts

@@ -131,8 +131,7 @@ export class Account extends Base {
     handleUserBankOutcomes = (_outcome?: string, _errorCodes?: {}) => {},
     userBankOutcomes: Partial<UserBankOutcomes> = {},
     feePayerOverride: Nullable<string> = null,
-    generateRecoveryLink = true,
-    useEntityManager = false
+    generateRecoveryLink = true
   ) {
     const phases = {
       ADD_REPLICA_SET: 'ADD_REPLICA_SET',
@@ -200,35 +199,15 @@ export class Account extends Base {
         })()
       }
       // Add user to chain
-      if (!useEntityManager) {
-        phase = phases.ADD_USER
-        const response = await this.User.addUser(metadata)
-        userId = response.userId
-        blockHash = response.blockHash
-        blockNumber = response.blockNumber
-
-        // Assign replica set to user, updates creator_node_endpoint on chain, and then update metadata object on content node + chain (in this order)
-        phase = phases.ADD_REPLICA_SET
-        metadata = (await this.User.assignReplicaSet({ userId }))!
-        // Upload profile pic and cover photo to primary Content Node and sync across secondaries
-        phase = phases.UPLOAD_PROFILE_IMAGES
-        await this.User.uploadProfileImages(
-          profilePictureFile!,
-          coverPhotoFile!,
-          metadata,
-          useEntityManager
-        )
-      } else {
-        const newMetadata = await this.User.createEntityManagerUser({
-          metadata
-        })
-        await this.User.uploadProfileImages(
-          profilePictureFile!,
-          coverPhotoFile!,
-          newMetadata,
-          useEntityManager
-        )
-      }
+      const newMetadata = await this.User.createEntityManagerUser({
+        metadata
+      })
+
+      await this.User.uploadProfileImages(
+        profilePictureFile!,
+        coverPhotoFile!,
+        newMetadata
+      )
     } catch (e: any) {
       return {
         error: e.message,

package/src/api/Track.ts

@@ -396,8 +396,7 @@ export class Track extends Base {
     trackFile: File,
     coverArtFile: File,
     metadata: TrackMetadata,
-    onProgress: () => void,
-    useEntityManager: boolean
+    onProgress: () => void
   ) {
     this.REQUIRES(Services.CREATOR_NODE)
     this.FILE_IS_VALID(trackFile)
@@ -461,36 +460,22 @@ export class Track extends Base {
       phase = phases.ADDING_TRACK
 
       // Write metadata to chain
-      let txReceipt: TransactionReceipt
-      let trackId: number
-      if (useEntityManager) {
-        trackId = await this._generateTrackId()
-        const response = await this.contracts.EntityManagerClient!.manageEntity(
-          ownerId,
-          EntityManagerClient.EntityType.TRACK,
-          trackId,
-          EntityManagerClient.Action.CREATE,
-          metadataMultihash
-        )
-        txReceipt = response.txReceipt
-      } else {
-        const multihashDecoded = Utils.decodeMultihash(metadataMultihash)
-        const response = await this.contracts.TrackFactoryClient.addTrack(
-          ownerId,
-          multihashDecoded.digest,
-          multihashDecoded.hashFn,
-          multihashDecoded.size
-        )
-        txReceipt = response.txReceipt
-        trackId = response.trackId
-      }
+      const trackId = await this._generateTrackId()
+      const response = await this.contracts.EntityManagerClient!.manageEntity(
+        ownerId,
+        EntityManagerClient.EntityType.TRACK,
+        trackId,
+        EntityManagerClient.Action.CREATE,
+        metadataMultihash
+      )
+      const txReceipt = response.txReceipt
 
       phase = phases.ASSOCIATING_TRACK
       // Associate the track id with the file metadata and block number
       await this.creatorNode.associateTrack(
         trackId,
         metadataFileUUID,
-        txReceipt!.blockNumber,
+        txReceipt.blockNumber,
         transcodedTrackUUID
       )
       return {
@@ -577,10 +562,7 @@ export class Track extends Base {
    * Adds tracks to chain for this user
    * Associates tracks with user on creatorNode
    */
-  async addTracksToChainAndCnode(
-    trackMultihashAndUUIDList: ChainInfo[],
-    useEntityManager: boolean
-  ) {
+  async addTracksToChainAndCnode(trackMultihashAndUUIDList: ChainInfo[]) {
     this.REQUIRES(Services.CREATOR_NODE)
     const ownerId = this.userStateManager.getCurrentUserId()
     if (!ownerId) {
@@ -601,30 +583,16 @@ export class Track extends Base {
             trackInfo
 
           // Write metadata to chain
-          let txReceipt: TransactionReceipt
-          let trackId: number
-          if (useEntityManager && this.contracts.EntityManagerClient) {
-            trackId = await this._generateTrackId()
-            const response =
-              await this.contracts.EntityManagerClient.manageEntity(
-                ownerId,
-                EntityManagerClient.EntityType.TRACK,
-                trackId,
-                EntityManagerClient.Action.CREATE,
-                metadataMultihash
-              )
-            txReceipt = response.txReceipt
-          } else {
-            const multihashDecoded = Utils.decodeMultihash(metadataMultihash)
-            const response = await this.contracts.TrackFactoryClient.addTrack(
+          const trackId = await this._generateTrackId()
+          const response =
+            await this.contracts.EntityManagerClient!.manageEntity(
               ownerId,
-              multihashDecoded.digest,
-              multihashDecoded.hashFn,
-              multihashDecoded.size
+              EntityManagerClient.EntityType.TRACK,
+              trackId,
+              EntityManagerClient.Action.CREATE,
+              metadataMultihash
             )
-            txReceipt = response.txReceipt
-            trackId = response.trackId
-          }
+          const txReceipt = response.txReceipt
           addedToChain[i] = {
             trackId,
             metadataFileUUID,
@@ -680,7 +648,7 @@ export class Track extends Base {
    * such as track content, cover art are already on creator node.
    * @param metadata json of the track metadata with all fields, missing fields will error
    */
-  async updateTrack(metadata: TrackMetadata, useEntityManager: boolean) {
+  async updateTrack(metadata: TrackMetadata) {
     this.REQUIRES(Services.CREATOR_NODE)
     this.IS_OBJECT(metadata)
 
@@ -696,28 +664,15 @@ export class Track extends Base {
     const { metadataMultihash, metadataFileUUID } =
       await this.creatorNode.uploadTrackMetadata(metadata)
     // Write the new metadata to chain
-    let txReceipt: TransactionReceipt
     const trackId: number = metadata.track_id
-    if (useEntityManager) {
-      const response = await this.contracts.EntityManagerClient!.manageEntity(
-        ownerId,
-        EntityManagerClient.EntityType.TRACK,
-        trackId,
-        EntityManagerClient.Action.UPDATE,
-        metadataMultihash
-      )
-      txReceipt = response.txReceipt
-    } else {
-      const multihashDecoded = Utils.decodeMultihash(metadataMultihash)
-      const response = await this.contracts.TrackFactoryClient.updateTrack(
-        trackId,
-        ownerId,
-        multihashDecoded.digest,
-        multihashDecoded.hashFn,
-        multihashDecoded.size
-      )
-      txReceipt = response.txReceipt
-    }
+    const response = await this.contracts.EntityManagerClient!.manageEntity(
+      ownerId,
+      EntityManagerClient.EntityType.TRACK,
+      trackId,
+      EntityManagerClient.Action.UPDATE,
+      metadataMultihash
+    )
+    const txReceipt = response.txReceipt
     // Re-associate the track id with the new metadata
     await this.creatorNode.associateTrack(
       trackId,
@@ -805,22 +760,18 @@ export class Track extends Base {
    * Marks a tracks as deleted
    * @param trackId
    */
-  async deleteTrack(trackId: number, useEntityManager: boolean) {
-    if (useEntityManager) {
-      const ownerId = this.userStateManager.getCurrentUserId()
+  async deleteTrack(trackId: number) {
+    const ownerId = this.userStateManager.getCurrentUserId()
 
-      if (!ownerId) throw new Error('No users loaded for this wallet')
+    if (!ownerId) throw new Error('No users loaded for this wallet')
 
-      return await this.contracts.EntityManagerClient!.manageEntity(
-        ownerId,
-        EntityManagerClient.EntityType.TRACK,
-        trackId,
-        EntityManagerClient.Action.DELETE,
-        ''
-      )
-    } else {
-      return await this.contracts.TrackFactoryClient.deleteTrack(trackId)
-    }
+    return await this.contracts.EntityManagerClient!.manageEntity(
+      ownerId,
+      EntityManagerClient.EntityType.TRACK,
+      trackId,
+      EntityManagerClient.Action.DELETE,
+      ''
+    )
   }
 
   /* ------- PRIVATE  ------- */

package/src/api/Users.ts

@@ -422,8 +422,7 @@ export class Users extends Base {
   async uploadProfileImages(
     profilePictureFile: File,
     coverPhotoFile: File,
-    metadata: UserMetadata,
-    useEntityManager: boolean
+    metadata: UserMetadata
   ) {
     let didMetadataUpdate = false
     if (profilePictureFile) {
@@ -440,8 +439,7 @@ export class Users extends Base {
     if (didMetadataUpdate) {
       await this.updateAndUploadMetadata({
         newMetadata: metadata,
-        userId: metadata.user_id,
-        useEntityManager
+        userId: metadata.user_id
       })
     }
 
@@ -541,8 +539,7 @@ export class Users extends Base {
       phase = phases.UPLOAD_METADATA_AND_UPDATE_ON_CHAIN
       await this.updateAndUploadMetadata({
         newMetadata,
-        userId,
-        useEntityManager: true
+        userId
       })
       console.log(
         `${logPrefix} [phase: ${phase}] updateAndUploadMetadata() completed in ${
@@ -667,17 +664,13 @@ export class Users extends Base {
   /**
    * Updates a creator (updates their data on the creator node)
    */
-  async updateCreator(
-    userId: number,
-    metadata: UserMetadata,
-    useEntityManager?: boolean
-  ) {
+  async updateCreator(userId: number, metadata: UserMetadata) {
     this.REQUIRES(Services.CREATOR_NODE, Services.DISCOVERY_PROVIDER)
     this.IS_OBJECT(metadata)
     const newMetadata = this.cleanUserMetadata(metadata)
     this._validateUserMetadata(newMetadata)
+    const logPrefix = `[User:updateCreator()] [userId: ${userId}]`
 
-    const logPrefix = `[User:updateCreator()] [userId: ${userId}] [useEntityManager: ${useEntityManager}]`
     const fnStartMs = Date.now()
     let startMs = fnStartMs
 
@@ -728,43 +721,16 @@ export class Users extends Base {
         updateEndpointTxBlockNumber
       )
 
-    let txReceipt
-    let latestBlockHash
-    let latestBlockNumber
-
-    if (!useEntityManager) {
-      // Write metadata multihash to chain
-
-      const updatedMultihashDecoded = Utils.decodeMultihash(metadataMultihash)
-      const updateMultiHashResp =
-        await this.contracts.UserFactoryClient.updateMultihash(
-          userId,
-          updatedMultihashDecoded.digest
-        )
-      txReceipt = updateMultiHashResp.txReceipt
-
-      // Write remaining metadata fields to chain
-      const updateUserResp = await this._updateUserOperations(
-        newMetadata,
-        oldMetadata,
-        userId
-      )
-      latestBlockHash = updateUserResp.latestBlockHash
-      latestBlockNumber = Math.max(
-        txReceipt.blockNumber,
-        updateUserResp.latestBlockNumber
-      )
-    } else {
-      const response = await this.contracts.EntityManagerClient!.manageEntity(
-        userId,
-        EntityManagerClient.EntityType.USER,
-        userId,
-        EntityManagerClient.Action.UPDATE,
-        metadataMultihash
-      )
-      txReceipt = response.txReceipt
-      latestBlockNumber = txReceipt.blockNumber
-    }
+    const response = await this.contracts.EntityManagerClient!.manageEntity(
+      userId,
+      EntityManagerClient.EntityType.USER,
+      userId,
+      EntityManagerClient.Action.UPDATE,
+      metadataMultihash
+    )
+    const txReceipt = response.txReceipt
+    const latestBlockNumber = txReceipt.blockNumber
+    const latestBlockHash = txReceipt.blockHash
 
     // Write to CN to associate blockchain user id with updated metadata and block number
     await this.creatorNode.associateCreator(
@@ -776,11 +742,6 @@ export class Users extends Base {
     // Update libs instance with new user metadata object
     this.userStateManager.setCurrentUser({ ...oldMetadata, ...newMetadata })
 
-    if (!latestBlockHash || !latestBlockNumber) {
-      latestBlockHash = txReceipt.blockHash
-      latestBlockNumber = txReceipt.blockNumber
-    }
-
     return {
       blockHash: latestBlockHash,
       blockNumber: latestBlockNumber,
@@ -791,28 +752,15 @@ export class Users extends Base {
   /**
    * Updates a user on whether they are verified on Audius
    */
-  async updateIsVerified(
-    userId: number,
-    isVerified: boolean,
-    privateKey: string,
-    useEntityManager?: boolean
-  ) {
-    if (useEntityManager) {
-      return await this.contracts.EntityManagerClient!.getManageEntityParams(
-        userId,
-        EntityManagerClient.EntityType.USER,
-        userId,
-        EntityManagerClient.Action.VERIFY,
-        '',
-        privateKey
-      )
-    } else {
-      return await this.contracts.UserFactoryClient.updateIsVerified(
-        userId,
-        isVerified,
-        privateKey
-      )
-    }
+  async updateIsVerified(userId: number, privateKey: string) {
+    return await this.contracts.EntityManagerClient!.getManageEntityParams(
+      userId,
+      EntityManagerClient.EntityType.USER,
+      userId,
+      EntityManagerClient.Action.VERIFY,
+      '',
+      privateKey
+    )
   }
 
   /**
@@ -893,12 +841,10 @@ export class Users extends Base {
    */
   async updateAndUploadMetadata({
     newMetadata,
-    userId,
-    useEntityManager
+    userId
   }: {
     newMetadata: UserMetadata
     userId: number
-    useEntityManager?: boolean
   }) {
     this.REQUIRES(Services.CREATOR_NODE, Services.DISCOVERY_PROVIDER)
     this.IS_OBJECT(newMetadata)
@@ -940,34 +886,20 @@ export class Users extends Base {
             Date.now() - startMs
           }ms`
         )
-        if (useEntityManager) {
-          startMs = Date.now()
-          await this.waitForReplicaSetDiscoveryIndexing(
-            userId,
-            replicaSetSPIDs,
-            txReceipt.blockNumber
-          )
-          // @ts-expect-error
-          newMetadata.primary_id = replicaSetSPIDs[0]
-          newMetadata.secondary_ids = replicaSetSPIDs.slice(1)
-          console.log(
-            `${logPrefix} [phase: ${phase}] waitForReplicaSetDiscoveryIndexing() completed in ${
-              Date.now() - startMs
-            }ms`
-          )
-        } else {
-          startMs = Date.now()
-
-          await this._waitForURSMCreatorNodeEndpointIndexing(
-            userId,
-            replicaSetSPIDs
-          )
-          console.log(
-            `${logPrefix} [phase: ${phase}] _waitForURSMCreatorNodeEndpointIndexing() completed in ${
-              Date.now() - startMs
-            }ms`
-          )
-        }
+        startMs = Date.now()
+        await this.waitForReplicaSetDiscoveryIndexing(
+          userId,
+          replicaSetSPIDs,
+          txReceipt.blockNumber
+        )
+        // @ts-expect-error
+        newMetadata.primary_id = replicaSetSPIDs[0]
+        newMetadata.secondary_ids = replicaSetSPIDs.slice(1)
+        console.log(
+          `${logPrefix} [phase: ${phase}] waitForReplicaSetDiscoveryIndexing() completed in ${
+            Date.now() - startMs
+          }ms`
+        )
       }
 
       // Upload new metadata object to CN
@@ -984,47 +916,15 @@ export class Users extends Base {
 
       // Write metadata multihash to chain
       phase = phases.UPDATE_METADATA_ON_CHAIN
-      let txReceipt
-      let blockNumber
-      if (useEntityManager) {
-        const response = await this.contracts.EntityManagerClient!.manageEntity(
-          userId,
-          EntityManagerClient.EntityType.USER,
-          userId,
-          EntityManagerClient.Action.UPDATE,
-          metadataMultihash
-        )
-        txReceipt = response.txReceipt
-        blockNumber = txReceipt.blockNumber
-      } else {
-        const updatedMultihashDecoded = Utils.decodeMultihash(metadataMultihash)
-        const res = await this.contracts.UserFactoryClient.updateMultihash(
-          userId,
-          updatedMultihashDecoded.digest
-        )
-        txReceipt = res.txReceipt
-        console.log(
-          `${logPrefix} [phase: ${phase}] UserFactoryClient.updateMultihash() completed in ${
-            Date.now() - startMs
-          }ms`
-        )
-        startMs = Date.now()
-
-        // Write remaining metadata fields to chain
-        phase = phases.UPDATE_USER_ON_CHAIN_OPS
-        const { latestBlockNumber } = await this._updateUserOperations(
-          newMetadata,
-          oldMetadata,
-          userId,
-          ['creator_node_endpoint']
-        )
-        console.log(
-          `${logPrefix} [phase: ${phase}] _updateUserOperations() completed in ${
-            Date.now() - startMs
-          }ms`
-        )
-        blockNumber = Math.max(txReceipt.blockNumber, latestBlockNumber)
-      }
+      const response = await this.contracts.EntityManagerClient!.manageEntity(
+        userId,
+        EntityManagerClient.EntityType.USER,
+        userId,
+        EntityManagerClient.Action.UPDATE,
+        metadataMultihash
+      )
+      const txReceipt = response.txReceipt
+      const blockNumber = txReceipt.blockNumber
 
       startMs = Date.now()
 
@@ -1366,65 +1266,47 @@ export class Users extends Base {
       this._retrieveSpIDFromEndpoint(secondaries[0]!),
       this._retrieveSpIDFromEndpoint(secondaries[1]!)
     ])
-    let txReceipt
     const currentUser = this.userStateManager.getCurrentUser()
     if (!currentUser) throw new Error('Current user missing')
 
     // First try to update with URSM
     // Fallback to EntityManager when relay errors
-    let updateEndpointTxBlockNumber
-    let replicaSetSPIDs
-    try {
-      txReceipt =
-        await this.contracts.UserReplicaSetManagerClient?.updateReplicaSet(
-          userId,
-          primarySpID,
-          [secondary1SpID, secondary2SpID]
-        )
-      replicaSetSPIDs = [primarySpID, secondary1SpID, secondary2SpID]
-      updateEndpointTxBlockNumber = txReceipt?.blockNumber
+    const currentPrimaryEndpoint = CreatorNode.getPrimary(
+      currentUser.creator_node_endpoint
+    )
+    const currentSecondaries = CreatorNode.getSecondaries(
+      currentUser.creator_node_endpoint
+    )
 
-      await this._waitForURSMCreatorNodeEndpointIndexing(
-        userId,
-        replicaSetSPIDs
-      )
-    } catch {
-      const currentPrimaryEndpoint = CreatorNode.getPrimary(
-        currentUser.creator_node_endpoint
-      )
-      const currentSecondaries = CreatorNode.getSecondaries(
-        currentUser.creator_node_endpoint
+    if (currentSecondaries.length < 2) {
+      throw new Error(
+        `Invalid number of secondaries found - received ${currentSecondaries}`
       )
+    }
 
-      if (currentSecondaries.length < 2) {
-        throw new Error(
-          `Invalid number of secondaries found - received ${currentSecondaries}`
-        )
-      }
+    const [oldPrimary, oldSecondary1SpID, oldSecondary2SpID] =
+      await Promise.all([
+        this._retrieveSpIDFromEndpoint(currentPrimaryEndpoint!),
+        this._retrieveSpIDFromEndpoint(currentSecondaries[0]!),
+        this._retrieveSpIDFromEndpoint(currentSecondaries[1]!)
+      ])
 
-      const [oldPrimary, oldSecondary1SpID, oldSecondary2SpID] =
-        await Promise.all([
-          this._retrieveSpIDFromEndpoint(currentPrimaryEndpoint!),
-          this._retrieveSpIDFromEndpoint(currentSecondaries[0]!),
-          this._retrieveSpIDFromEndpoint(currentSecondaries[1]!)
-        ])
+    const txReceipt = await this.updateEntityManagerReplicaSet({
+      userId,
+      primary: primarySpID,
+      secondaries: [secondary1SpID, secondary2SpID],
+      oldPrimary: oldPrimary,
+      oldSecondaries: [oldSecondary1SpID, oldSecondary2SpID]
+    })
+    const replicaSetSPIDs = [primarySpID, secondary1SpID, secondary2SpID]
+    const updateEndpointTxBlockNumber = txReceipt?.blockNumber
 
-      txReceipt = await this.updateEntityManagerReplicaSet({
-        userId,
-        primary: primarySpID,
-        secondaries: [secondary1SpID, secondary2SpID],
-        oldPrimary: oldPrimary,
-        oldSecondaries: [oldSecondary1SpID, oldSecondary2SpID]
-      })
-      replicaSetSPIDs = [primarySpID, secondary1SpID, secondary2SpID]
-      updateEndpointTxBlockNumber = txReceipt?.blockNumber
+    await this.waitForReplicaSetDiscoveryIndexing(
+      userId,
+      replicaSetSPIDs,
+      updateEndpointTxBlockNumber
+    )
 
-      await this.waitForReplicaSetDiscoveryIndexing(
-        userId,
-        replicaSetSPIDs,
-        updateEndpointTxBlockNumber
-      )
-    }
     if (!txReceipt) {
       throw new Error('Unable to update replica set on chain')
     }

package/src/sanityChecks/rolloverNodes.ts

@@ -97,11 +97,7 @@ export const rolloverNodes = async (
     console.debug(
       `Sanity Check - rolloverNodes - new nodes ${newMetadata.creator_node_endpoint}`
     )
-    await libs.User?.updateCreator(
-      user.user_id,
-      newMetadata,
-      true /* useEntityManager */
-    )
+    await libs.User?.updateCreator(user.user_id, newMetadata)
   } catch (e) {
     console.error(e)
   }