@audius/sdk 0.0.35 → 0.0.38

package/src/api/entityManager.ts

@@ -1,6 +1,6 @@
 import { Base, Services } from './base'
 import type { PlaylistMetadata } from '../services/creatorNode'
-import { Nullable, Utils } from '../utils'
+import type { Nullable } from '../utils'
 
 export enum Action {
   CREATE = 'Create',
@@ -21,17 +21,23 @@ export interface PlaylistOperationResponse {
    * Block number of playlist transaction
    */
   blockNumber: Nullable<number>
-  /**
-   * ID of playlist being modified
-   */
-  playlistId: Nullable<number>
   /**
    * String error message returned
    */
   error: Nullable<string>
 }
-
-const { encodeHashId, decodeHashId } = Utils
+type PlaylistTrack = { time: number; metadata_time?: number; track: number }
+
+type PlaylistParam = {
+  playlist_id: number
+  playlist_name: string
+  artwork?: { file?: File; url?: string }
+  playlist_contents: { track_ids: PlaylistTrack[] } // number[] for playlist upload flow
+  cover_art_sizes: string
+  description: string
+  is_private: boolean
+  is_album: boolean
+}
 
 /*
   API surface for updated data contract interactions.
@@ -48,30 +54,11 @@ export class EntityManager extends Base {
     return Math.floor(Math.random() * (max - min) + min)
   }
 
-  async getFullPlaylist(playlistId: number, userId: number) {
-    const encodedPlaylistId = encodeHashId(playlistId) as string
-    const encodedUserId = encodeHashId(userId) as string
-
-    const playlist: any = (
-      await this.discoveryProvider.getFullPlaylist(
-        encodedPlaylistId,
-        encodedUserId
-      )
-    )[0]
-    return playlist
-  }
-
-  mapAddedTimestamps(addedTimestamps: any) {
-    const trackIds = addedTimestamps.map(
-      (trackObj: {
-        track_id: string
-        metadata_timestamp?: number
-        timestamp: number
-      }) => ({
-        track: decodeHashId(trackObj.track_id),
-        time: trackObj.metadata_timestamp ?? trackObj.timestamp
-      })
-    )
+  mapTimestamps(addedTimestamps: PlaylistTrack[]) {
+    const trackIds = addedTimestamps.map((trackObj) => ({
+      track: trackObj.track,
+      time: trackObj.metadata_time ?? trackObj.time // default to time for legacy playlists
+    }))
 
     return trackIds
   }
@@ -83,7 +70,6 @@ export class EntityManager extends Base {
     return {
       blockHash: null,
       blockNumber: null,
-      playlistId: null,
       error: null
     }
   }
@@ -91,72 +77,52 @@ export class EntityManager extends Base {
   /**
    * Create a playlist using updated data contracts flow
    */
-  async createPlaylist({
-    playlistId,
-    playlistName,
-    trackIds,
-    description,
-    isAlbum,
-    isPrivate,
-    coverArt,
-    logger = console
-  }: {
-    playlistId: number
-    playlistName: string
-    trackIds: number[]
-    description: string
-    isAlbum: boolean
-    isPrivate: boolean
-    coverArt: string
-    logger: Console
-  }): Promise<PlaylistOperationResponse> {
+  async createPlaylist(
+    playlist: PlaylistParam
+  ): Promise<PlaylistOperationResponse> {
     const responseValues: PlaylistOperationResponse =
       this.getDefaultPlaylistReponseValues()
     try {
-      const currentUserId: string | null =
-        this.userStateManager.getCurrentUserId()
-      if (!currentUserId) {
+      const userId: number | null = this.userStateManager.getCurrentUserId()
+      if (!userId) {
         responseValues.error = 'Missing current user ID'
         return responseValues
       }
-      const userId: number = parseInt(currentUserId)
       const createAction = Action.CREATE
       const entityType = EntityType.PLAYLIST
       this.REQUIRES(Services.CREATOR_NODE)
-      const updatedPlaylistImage = await this.creatorNode.uploadImage(
-        coverArt,
-        true // square
-      )
-      const web3 = this.web3Manager.getWeb3()
-      const currentBlockNumber = await web3.eth.getBlockNumber()
-      const currentBlock = await web3.eth.getBlock(currentBlockNumber)
-      const tracks = trackIds.map((trackId) => ({
-        track: trackId,
-        time: currentBlock.timestamp as number
-      }))
-      const dirCID = updatedPlaylistImage.dirCID
+      let dirCID
+      if (playlist?.artwork?.file) {
+        const updatedPlaylistImage = await this.creatorNode.uploadImage(
+          playlist.artwork.file,
+          true // square
+        )
+        dirCID = updatedPlaylistImage.dirCID
+      }
+      const tracks = this.mapTimestamps(playlist.playlist_contents.track_ids)
+
       const metadata: PlaylistMetadata = {
-        playlist_id: playlistId,
+        playlist_id: playlist.playlist_id,
         playlist_contents: { track_ids: tracks },
-        playlist_name: playlistName,
-        playlist_image_sizes_multihash: dirCID,
-        description,
-        is_album: isAlbum,
-        is_private: isPrivate
+        playlist_name: playlist.playlist_name,
+        playlist_image_sizes_multihash: dirCID ?? playlist.cover_art_sizes, // default to cover_art_sizes for new playlists from tracks
+        description: playlist.description,
+        is_album: playlist.is_album,
+        is_private: playlist.is_private
       }
+
       const { metadataMultihash } =
         await this.creatorNode.uploadPlaylistMetadata(metadata)
       const manageEntityResponse = await this.manageEntity({
         userId: userId,
         entityType,
-        entityId: playlistId,
+        entityId: playlist.playlist_id,
         action: createAction,
         metadataMultihash
       })
       const txReceipt = manageEntityResponse.txReceipt
       responseValues.blockHash = txReceipt.blockHash
       responseValues.blockNumber = txReceipt.blockNumber
-      responseValues.playlistId = playlistId
       return responseValues
     } catch (e) {
       const error = (e as Error).message
@@ -168,22 +134,14 @@ export class EntityManager extends Base {
   /**
    * Delete a playlist using updated data contracts flow
    */
-  async deletePlaylist({
-    playlistId,
-    logger = console
-  }: {
-    playlistId: number
-    logger: any
-  }): Promise<{ blockHash: any; blockNumber: any }> {
+  async deletePlaylist(playlistId: number): Promise<PlaylistOperationResponse> {
     const responseValues: PlaylistOperationResponse =
       this.getDefaultPlaylistReponseValues()
-    const currentUserId: string | null =
-      this.userStateManager.getCurrentUserId()
-    if (!currentUserId) {
+    const userId: number | null = this.userStateManager.getCurrentUserId()
+    if (!userId) {
       responseValues.error = 'Missing current user ID'
       return responseValues
     }
-    const userId: number = parseInt(currentUserId)
     try {
       const resp = await this.manageEntity({
         userId,
@@ -195,7 +153,6 @@ export class EntityManager extends Base {
       const txReceipt = resp.txReceipt
       responseValues.blockHash = txReceipt.blockHash
       responseValues.blockNumber = txReceipt.blockNumber
-      responseValues.playlistId = playlistId
       return responseValues
     } catch (e) {
       const error = (e as Error).message
@@ -206,306 +163,59 @@ export class EntityManager extends Base {
 
   /**
    * Update a playlist using updated data contracts flow
-   **/
-  async editPlaylist({
-    playlistId,
-    playlistName,
-    description,
-    isAlbum,
-    isPrivate,
-    coverArt,
-    logger = console
-  }: {
-    playlistId: number
-    playlistName: Nullable<string>
-    description: Nullable<string>
-    isAlbum: Nullable<boolean>
-    isPrivate: Nullable<boolean>
-    coverArt: Nullable<string>
-    logger: Console
-  }): Promise<PlaylistOperationResponse> {
+   */
+  async updatePlaylist(
+    playlist: PlaylistParam
+  ): Promise<PlaylistOperationResponse> {
     const responseValues: PlaylistOperationResponse =
       this.getDefaultPlaylistReponseValues()
 
     try {
-      const currentUserId: string | null =
-        this.userStateManager.getCurrentUserId()
-      if (!playlistId || playlistId === undefined) {
-        responseValues.error = 'Missing current playlistId'
+      const userId: number | null = this.userStateManager.getCurrentUserId()
+
+      if (!playlist || playlist === undefined) {
+        responseValues.error = 'Missing current playlist'
         return responseValues
       }
-      if (!currentUserId) {
+      if (!userId) {
         responseValues.error = 'Missing current user ID'
         return responseValues
       }
-      const userId: number = parseInt(currentUserId)
       const updateAction = Action.UPDATE
       const entityType = EntityType.PLAYLIST
       this.REQUIRES(Services.CREATOR_NODE)
       let dirCID
-      if (coverArt) {
-        // @ts-expect-error
+      if (playlist?.artwork?.file) {
         const updatedPlaylistImage = await this.creatorNode.uploadImage(
-          coverArt,
+          playlist.artwork.file,
           true // square
         )
         dirCID = updatedPlaylistImage.dirCID
       }
-      const playlist = await this.getFullPlaylist(playlistId, userId)
-      const existingPlaylistTracks = this.mapAddedTimestamps(
-        playlist.added_timestamps
-      )
-      const metadata: PlaylistMetadata = {
-        playlist_id: playlistId,
-        playlist_contents: { track_ids: existingPlaylistTracks },
-        playlist_name: playlistName ?? playlist.playlist_name,
-        playlist_image_sizes_multihash: dirCID ?? playlist.cover_art,
-        description: description ?? playlist.description,
-        is_album: isAlbum ?? playlist.is_album,
-        is_private: isPrivate ?? playlist.is_private
-      }
-      const { metadataMultihash } =
-        await this.creatorNode.uploadPlaylistMetadata(metadata)
-      const resp = await this.manageEntity({
-        userId,
-        entityType,
-        entityId: playlistId,
-        action: updateAction,
-        metadataMultihash
-      })
-      const txReceipt = resp.txReceipt
-      responseValues.blockHash = txReceipt.blockHash
-      responseValues.blockNumber = txReceipt.blockNumber
-      responseValues.playlistId = playlistId
-      return responseValues
-    } catch (e) {
-      const error = (e as Error).message
-      responseValues.error = error
-      return responseValues
-    }
-  }
-
-  async addPlaylistTrack({
-    playlistId,
-    trackId,
-    timestamp,
-    logger = console
-  }: {
-    playlistId: number
-    trackId: number
-    timestamp: number
-    logger: Console
-  }): Promise<PlaylistOperationResponse> {
-    const responseValues: PlaylistOperationResponse =
-      this.getDefaultPlaylistReponseValues()
-
-    try {
-      const currentUserId: string | null =
-        this.userStateManager.getCurrentUserId()
-      if (!playlistId || playlistId === undefined) {
-        responseValues.error = 'Missing current playlistId'
-        return responseValues
-      }
-      if (!currentUserId) {
-        responseValues.error = 'Missing current user ID'
-        return responseValues
-      }
-      const userId: number = parseInt(currentUserId)
-      const updateAction = Action.UPDATE
-      const entityType = EntityType.PLAYLIST
-      this.REQUIRES(Services.CREATOR_NODE)
-
-      const playlist = await this.getFullPlaylist(playlistId, userId)
-
-      const updatedPlaylistTracks = this.mapAddedTimestamps(
-        playlist.added_timestamps
-      )
-
-      updatedPlaylistTracks.push({
-        track: trackId,
-        time: timestamp
-      })
-
-      const metadata: PlaylistMetadata = {
-        playlist_id: playlistId,
-        playlist_contents: { track_ids: updatedPlaylistTracks },
-        playlist_name: playlist.playlist_name,
-        playlist_image_sizes_multihash: playlist.cover_art,
-        description: playlist.description,
-        is_album: playlist.is_album,
-        is_private: playlist.is_private
-      }
-      const { metadataMultihash } =
-        await this.creatorNode.uploadPlaylistMetadata(metadata)
-      const resp = await this.manageEntity({
-        userId,
-        entityType,
-        entityId: playlistId,
-        action: updateAction,
-        metadataMultihash
-      })
-      const txReceipt = resp.txReceipt
-      responseValues.blockHash = txReceipt.blockHash
-      responseValues.blockNumber = txReceipt.blockNumber
-      responseValues.playlistId = playlistId
-      return responseValues
-    } catch (e) {
-      const error = (e as Error).message
-      responseValues.error = error
-      return responseValues
-    }
-  }
-
-  async deletePlaylistTrack({
-    playlistId,
-    trackId,
-    timestamp,
-    logger = console
-  }: {
-    playlistId: number
-    trackId: number
-    timestamp: number
-    logger: Console
-  }): Promise<PlaylistOperationResponse> {
-    const responseValues: PlaylistOperationResponse =
-      this.getDefaultPlaylistReponseValues()
-
-    try {
-      const currentUserId: string | null =
-        this.userStateManager.getCurrentUserId()
-      if (!playlistId || playlistId === undefined) {
-        responseValues.error = 'Missing current playlistId'
-        return responseValues
-      }
-      if (!currentUserId) {
-        responseValues.error = 'Missing current user ID'
-        return responseValues
-      }
-      const userId: number = parseInt(currentUserId)
-      const updateAction = Action.UPDATE
-      const entityType = EntityType.PLAYLIST
-      this.REQUIRES(Services.CREATOR_NODE)
-      const playlist = await this.getFullPlaylist(playlistId, userId)
-
-      const existingPlaylistTracks = this.mapAddedTimestamps(
-        playlist.added_timestamps
-      )
-
-      const updatedTrackIds = existingPlaylistTracks.filter(
-        (trackObj: { track: number; metadata_time?: number; time: number }) =>
-          (trackObj.track !== trackId &&
-            timestamp !== trackObj.metadata_time) ??
-          trackObj.time
-      )
-
-      const metadata: PlaylistMetadata = {
-        playlist_id: playlistId,
-        playlist_contents: { track_ids: updatedTrackIds },
-        playlist_name: playlist.playlist_name,
-        playlist_image_sizes_multihash: playlist.cover_art,
-        description: playlist.description,
-        is_album: playlist.is_album,
-        is_private: playlist.is_private
-      }
-      const { metadataMultihash } =
-        await this.creatorNode.uploadPlaylistMetadata(metadata)
-      const resp = await this.manageEntity({
-        userId,
-        entityType,
-        entityId: playlistId,
-        action: updateAction,
-        metadataMultihash
-      })
-      const txReceipt = resp.txReceipt
-      responseValues.blockHash = txReceipt.blockHash
-      responseValues.blockNumber = txReceipt.blockNumber
-      responseValues.playlistId = playlistId
-      return responseValues
-    } catch (e) {
-      const error = (e as Error).message
-      responseValues.error = error
-      return responseValues
-    }
-  }
-
-  /**
-   * Update a playlist using updated data contracts flow
-   **/
-  async orderPlaylist({
-    playlistId,
-    trackIds,
-    logger = console
-  }: {
-    playlistId: number
-    trackIds: number[]
-    logger: Console
-  }): Promise<PlaylistOperationResponse> {
-    const responseValues: PlaylistOperationResponse =
-      this.getDefaultPlaylistReponseValues()
-
-    try {
-      const currentUserId: string | null =
-        this.userStateManager.getCurrentUserId()
-      if (!playlistId || playlistId === undefined) {
-        responseValues.error = 'Missing current playlistId'
-        return responseValues
-      }
-      if (!currentUserId) {
-        responseValues.error = 'Missing current user ID'
-        return responseValues
-      }
-      const userId: number = parseInt(currentUserId)
-      const updateAction = Action.UPDATE
-      const entityType = EntityType.PLAYLIST
-      this.REQUIRES(Services.CREATOR_NODE)
-      const playlist = await this.getFullPlaylist(playlistId, userId)
 
-      const existingPlaylistTracks = this.mapAddedTimestamps(
-        playlist.added_timestamps
-      )
-
-      let trackIdsWithTimes = []
-      const trackIdTimes = {}
-      existingPlaylistTracks.forEach(
-        (trackObj: { track: number; metadata_time?: number; time: number }) => {
-          const trackId = trackObj.track
-          const timestamp = trackObj.metadata_time ?? trackObj.time
-          if (trackId in trackIdTimes) {
-            trackIdTimes[trackId].push(timestamp)
-          } else {
-            trackIdTimes[trackId] = [timestamp]
-          }
-        }
-      )
+      const trackIds = this.mapTimestamps(playlist.playlist_contents.track_ids)
 
-      // new tracks default to currentBlock timestamp
-      trackIdsWithTimes = trackIds.map((trackId: number) => ({
-        track: trackId,
-        time: trackIdTimes[trackId].pop()
-      }))
       const metadata: PlaylistMetadata = {
-        playlist_id: playlistId,
-        playlist_contents: { track_ids: trackIdsWithTimes },
+        playlist_id: playlist.playlist_id,
+        playlist_contents: { track_ids: trackIds },
         playlist_name: playlist.playlist_name,
-        playlist_image_sizes_multihash: playlist.cover_art,
+        playlist_image_sizes_multihash: dirCID ?? playlist.cover_art_sizes,
         description: playlist.description,
         is_album: playlist.is_album,
         is_private: playlist.is_private
       }
       const { metadataMultihash } =
         await this.creatorNode.uploadPlaylistMetadata(metadata)
-
       const resp = await this.manageEntity({
         userId,
         entityType,
-        entityId: playlistId,
+        entityId: playlist.playlist_id,
         action: updateAction,
         metadataMultihash
       })
       const txReceipt = resp.txReceipt
       responseValues.blockHash = txReceipt.blockHash
       responseValues.blockNumber = txReceipt.blockNumber
-      responseValues.playlistId = playlistId
       return responseValues
     } catch (e) {
       const error = (e as Error).message

package/src/sdk/api/generated/default/models/Track.ts

@@ -134,5 +134,11 @@ export interface Track {
      * @memberof Track
      */
     permalink?: string;
+    /**
+     * 
+     * @type {boolean}
+     * @memberof Track
+     */
+    is_streamable?: boolean;
 }
 

package/src/sdk/api/generated/full/models/TrackFull.ts

@@ -170,6 +170,12 @@ export interface TrackFull {
      * @memberof TrackFull
      */
     permalink?: string;
+    /**
+     * 
+     * @type {boolean}
+     * @memberof TrackFull
+     */
+    is_streamable?: boolean;
     /**
      * 
      * @type {number}

package/src/services/solana/SolanaWeb3Manager.ts

@@ -1,7 +1,7 @@
 import solanaWeb3, { Connection, Keypair, PublicKey } from '@solana/web3.js'
 import type BN from 'bn.js'
 import splToken from '@solana/spl-token'
-import anchor, { Address, Idl, Program } from '@project-serum/anchor'
+import anchor, { Address, Idl, Program, Wallet } from '@project-serum/anchor'
 import { idl } from '@audius/anchor-audius-data'
 
 import { transferWAudioBalance } from './transfer'
@@ -166,7 +166,7 @@ export class SolanaWeb3Manager {
     } = this.solanaWeb3Config
 
     this.solanaClusterEndpoint = solanaClusterEndpoint
-    this.connection = new solanaWeb3.Connection(this.solanaClusterEndpoint, {
+    this.connection = new Connection(this.solanaClusterEndpoint, {
       confirmTransactionInitialTimeout:
         confirmationTimeout || DEFAULT_CONNECTION_CONFIRMATION_TIMEOUT_MS
     })
@@ -230,14 +230,13 @@ export class SolanaWeb3Manager {
       this.audiusDataAdminStorageKeypairPublicKey &&
       this.audiusDataIdl
     ) {
-      const connection = new solanaWeb3.Connection(
+      const connection = new Connection(
         this.solanaClusterEndpoint,
         anchor.AnchorProvider.defaultOptions()
       )
       const anchorProvider = new anchor.AnchorProvider(
         connection,
-        // @ts-expect-error weirdness with 3rd party types
-        solanaWeb3.Keypair.generate(),
+        Keypair.generate() as unknown as Wallet,
         anchor.AnchorProvider.defaultOptions()
       )
       this.anchorProgram = new anchor.Program(

package/src/services/web3Manager/Web3Config.ts

@@ -3,6 +3,7 @@ import type Wallet from 'ethereumjs-wallet'
 
 export type Web3Config = {
   registryAddress: string
+  entityManagerAddress: string
   useExternalWeb3: boolean
   internalWeb3Config: {
     web3ProviderEndpoints: string[]