@audius/sdk 2.0.3-beta.6 → 2.0.3-beta.7

package/src/api/Users.ts

@@ -68,6 +68,12 @@ export class Users extends Base {
     this.getUserSubscribers = this.getUserSubscribers.bind(this)
     this.bulkGetUserSubscribers = this.bulkGetUserSubscribers.bind(this)
 
+    this.updateMetadataV2 = this.updateMetadataV2.bind(this)
+    this.uploadProfileImagesV2 = this.uploadProfileImagesV2.bind(this)
+    this.createEntityManagerUserV2 = this.createEntityManagerUserV2.bind(this)
+    this._waitForDiscoveryToIndexUser =
+      this._waitForDiscoveryToIndexUser.bind(this)
+
     // For adding replica set to users on sign up
     this.assignReplicaSet = this.assignReplicaSet.bind(this)
 
@@ -440,6 +446,35 @@ export class Users extends Base {
     return metadata
   }
 
+  async uploadProfileImagesV2(
+    profilePictureFile: File,
+    coverPhotoFile: File,
+    metadata: UserMetadata
+  ) {
+    let didMetadataUpdate = false
+    if (profilePictureFile) {
+      const resp = await this.creatorNode.uploadProfilePictureV2(
+        profilePictureFile
+      )
+      metadata.profile_picture_sizes = resp.id
+      didMetadataUpdate = true
+    }
+    if (coverPhotoFile) {
+      const resp = await this.creatorNode.uploadCoverPhotoV2(coverPhotoFile)
+      metadata.cover_photo_sizes = resp.id
+      didMetadataUpdate = true
+    }
+
+    if (didMetadataUpdate) {
+      await this.updateMetadataV2({
+        newMetadata: metadata,
+        userId: metadata.user_id
+      })
+    }
+
+    return metadata
+  }
+
   async createEntityManagerUser({ metadata }: { metadata: UserMetadata }) {
     this.REQUIRES(Services.CREATOR_NODE)
     const phases = {
@@ -555,6 +590,59 @@ export class Users extends Base {
     }
   }
 
+  async createEntityManagerUserV2({ metadata }: { metadata: UserMetadata }) {
+    this.REQUIRES(Services.DISCOVERY_PROVIDER)
+
+    try {
+      // Create the user with EntityMananer
+      const userId = await this._generateUserId()
+      const manageEntityResponse =
+        await this.contracts.EntityManagerClient!.manageEntity(
+          userId,
+          EntityManagerClient.EntityType.USER,
+          userId,
+          EntityManagerClient.Action.CREATE,
+          'v2'
+        )
+      await this._waitForDiscoveryToIndexUser(
+        userId,
+        manageEntityResponse.txReceipt.blockNumber
+      )
+
+      // Ensure metadata has expected properties
+      const newMetadata = this.cleanUserMetadata({ ...metadata })
+      this._validateUserMetadata(newMetadata)
+
+      newMetadata.is_storage_v2 = true
+      newMetadata.wallet = this.web3Manager.getWalletAddress()
+      newMetadata.user_id = userId
+      this.userStateManager.setCurrentUser({
+        ...newMetadata,
+        // Initialize counts to be 0. We don't want to write this data to backends ever really
+        // (hence the cleanUserMetadata above), but we do want to make sure clients
+        // can properly "do math" on these numbers.
+        followee_count: 0,
+        follower_count: 0,
+        repost_count: 0
+      })
+
+      // Update metadata on chain to include wallet
+      const { blockHash, blockNumber } = await this.updateMetadataV2({
+        newMetadata,
+        userId
+      })
+
+      return { newMetadata, blockHash, blockNumber }
+    } catch (e) {
+      const errorMsg = `createEntityManagerUserV2() error: ${e}`
+      if (e instanceof Error) {
+        e.message = errorMsg
+        throw e
+      }
+      throw new Error(errorMsg)
+    }
+  }
+
   async updateEntityManagerReplicaSet({
     userId,
     primary,
@@ -756,7 +844,6 @@ export class Users extends Base {
         'UPDATE_CONTENT_NODE_ENDPOINT_ON_CHAIN',
       UPLOAD_METADATA: 'UPLOAD_METADATA',
       UPDATE_METADATA_ON_CHAIN: 'UPDATE_METADATA_ON_CHAIN',
-      UPDATE_USER_ON_CHAIN_OPS: 'UPDATE_USER_ON_CHAIN_OPS',
       ASSOCIATE_USER: 'ASSOCIATE_USER'
     }
     let phase = ''
@@ -865,6 +952,59 @@ export class Users extends Base {
     }
   }
 
+  /**
+   * Storage V2 version of updateAndUploadMetadata. Only posts to chain and not Content Node.
+   */
+  async updateMetadataV2({
+    newMetadata,
+    userId
+  }: {
+    newMetadata: UserMetadata
+    userId: number
+  }) {
+    this.REQUIRES(Services.DISCOVERY_PROVIDER)
+    this.IS_OBJECT(newMetadata)
+
+    const oldMetadata = this.userStateManager.getCurrentUser()
+    if (!oldMetadata) {
+      throw new Error('No current user.')
+    }
+
+    newMetadata = this.cleanUserMetadata(newMetadata)
+    this._validateUserMetadata(newMetadata)
+
+    try {
+      // Write metadata to chain
+      const cid = await Utils.fileHasher.generateMetadataCidV1(newMetadata)
+      const { txReceipt } =
+        await this.contracts.EntityManagerClient!.manageEntity(
+          userId,
+          EntityManagerClient.EntityType.USER,
+          userId,
+          EntityManagerClient.Action.UPDATE,
+          JSON.stringify({
+            cid: cid.toString(),
+            data: newMetadata
+          })
+        )
+      const blockNumber = txReceipt.blockNumber
+
+      // Update libs instance with new user metadata object
+      this.userStateManager.setCurrentUser({ ...oldMetadata, ...newMetadata })
+      return {
+        blockHash: txReceipt.blockHash,
+        blockNumber
+      }
+    } catch (e) {
+      const errorMsg = `updateMetadataV2() error: ${e}`
+      if (e instanceof Error) {
+        e.message = errorMsg
+        throw e
+      }
+      throw new Error(errorMsg)
+    }
+  }
+
   /**
    * If a user's creator_node_endpoint is null, assign a replica set.
    * Used during the sanity check and in uploadImage() in files.js
@@ -921,12 +1061,12 @@ export class Users extends Base {
     timeoutMs = 60000
   ): Promise<void> {
     const asyncFn = async () => {
+      const encodedUserId = Utils.encodeHashId(userId)
       while (true) {
-        const encodedUserId = Utils.encodeHashId(userId)
         let replicaSet
         try {
           // If the discovery node has not yet indexed the blocknumber,
-          // this method will throw an error
+          // this method will throw an error (which we catch and ignore)
           // If the user replica set does not exist, it will return an empty object
           // which should lead to the method throwing an error
           replicaSet = await this.discoveryProvider.getUserReplicaSet({
@@ -959,6 +1099,44 @@ export class Users extends Base {
     )
   }
 
+  async _waitForDiscoveryToIndexUser(
+    userId: number,
+    blockNumber: number,
+    timeoutMs = 60000
+  ): Promise<void> {
+    const asyncFn = async () => {
+      while (true) {
+        // Try to get user. Catch+ignore error if the block number isn't yet indexed
+        let user
+        try {
+          user = (
+            await this.discoveryProvider.getUsers(
+              1, // limit
+              0, // offset
+              [userId], // userIds
+              null, // walletAddress
+              null, // handle
+              blockNumber, // minBlockNumber
+              true // includeIncomplete
+            )
+          )?.[0]
+        } catch (err) {}
+
+        // All done (success) if the user was indexed and ID matches
+        if (user?.user_id === userId) {
+          break
+        }
+
+        await Utils.wait(500)
+      }
+    }
+    await Utils.racePromiseWithTimeout(
+      asyncFn(),
+      timeoutMs,
+      `[User:_waitForDiscoveryToIndexUser()] Timeout error after ${timeoutMs}ms`
+    )
+  }
+
   _validateUserMetadata(metadata: UserMetadata) {
     this.OBJECT_HAS_PROPS(metadata, USER_PROPS, USER_REQUIRED_PROPS)
   }

package/src/eth-contracts/ABIs/Wormhole.json

@@ -1,12 +1,71 @@
 {
   "contractName": "Wormhole",
   "abi": [
+    {
+      "constant": true,
+      "inputs": [],
+      "name": "DOMAIN_SEPARATOR",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "constant": true,
+      "inputs": [],
+      "name": "LOCK_ASSETS_TYPEHASH",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "constant": false,
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "_tokenAddress",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "_wormholeAddress",
+          "type": "address"
+        }
+      ],
+      "name": "initialize",
+      "outputs": [],
+      "payable": false,
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "constant": false,
+      "inputs": [],
+      "name": "initialize",
+      "outputs": [],
+      "payable": false,
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "constant": false,
       "inputs": [
         {
           "internalType": "address",
-          "name": "token",
+          "name": "from",
           "type": "address"
         },
         {
@@ -14,32 +73,83 @@
           "name": "amount",
           "type": "uint256"
         },
-        {
-          "internalType": "uint16",
-          "name": "recipientChain",
-          "type": "uint16"
-        },
         {
           "internalType": "bytes32",
           "name": "recipient",
           "type": "bytes32"
         },
+        {
+          "internalType": "uint8",
+          "name": "targetChain",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bool",
+          "name": "refundDust",
+          "type": "bool"
+        },
         {
           "internalType": "uint256",
-          "name": "arbiterFee",
+          "name": "deadline",
           "type": "uint256"
         },
         {
-          "internalType": "uint32",
-          "name": "nonce",
-          "type": "uint32"
+          "internalType": "uint8",
+          "name": "v",
+          "type": "uint8"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "r",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "s",
+          "type": "bytes32"
         }
       ],
-      "name": "transferTokens",
+      "name": "lockAssets",
       "outputs": [],
       "payable": false,
       "stateMutability": "nonpayable",
       "type": "function"
+    },
+    {
+      "constant": true,
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "nonces",
+      "outputs": [
+        {
+          "internalType": "uint32",
+          "name": "",
+          "type": "uint32"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "constant": true,
+      "inputs": [],
+      "name": "token",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "payable": false,
+      "stateMutability": "view",
+      "type": "function"
     }
   ]
 }

package/src/services/creatorNode/CreatorNode.ts

@@ -418,6 +418,7 @@ export class CreatorNode {
     ])
 
     // Update metadata to include uploaded CIDs
+    updatedMetadata.track_segments = []
     updatedMetadata.track_cid = audioResp.results['320']
     if (updatedMetadata.download?.is_downloadable) {
       updatedMetadata.download.cid = updatedMetadata.track_cid
@@ -435,6 +436,14 @@ export class CreatorNode {
     return await this.uploadFileV2(file, onProgress, 'img_square')
   }
 
+  async uploadProfilePictureV2(file: File, onProgress: ProgressCB = () => {}) {
+    return await this.uploadFileV2(file, onProgress, 'img_square')
+  }
+
+  async uploadCoverPhotoV2(file: File, onProgress: ProgressCB = () => {}) {
+    return await this.uploadFileV2(file, onProgress, 'img_backdrop')
+  }
+
   async uploadFileV2(
     file: File,
     onProgress: ProgressCB,

package/src/services/discoveryProvider/DiscoveryProvider.ts

@@ -248,7 +248,8 @@ export class DiscoveryProvider {
     idsArray: Nullable<number[]>,
     walletAddress?: Nullable<string>,
     handle?: Nullable<string>,
-    minBlockNumber?: Nullable<number>
+    minBlockNumber?: Nullable<number>,
+    includeIncomplete?: Nullable<boolean>
   ) {
     const req = Requests.getUsers(
       limit,
@@ -256,7 +257,8 @@ export class DiscoveryProvider {
       idsArray,
       walletAddress,
       handle,
-      minBlockNumber
+      minBlockNumber,
+      includeIncomplete
     )
     return await this._makeRequest<Nullable<User[]>>(req)
   }

package/src/services/discoveryProvider/requests.ts

@@ -9,7 +9,8 @@ export const getUsers = (
   idsArray: Nullable<number[]>,
   walletAddress?: Nullable<string>,
   handle?: Nullable<string>,
-  minBlockNumber?: Nullable<number>
+  minBlockNumber?: Nullable<number>,
+  includeIncomplete?: Nullable<boolean>
 ) => {
   type QueryParams = {
     limit: number
@@ -18,6 +19,7 @@ export const getUsers = (
     wallet?: string
     min_block_number?: number
     id?: string[]
+    include_incomplete?: boolean
   }
 
   const queryParams: QueryParams = { limit: limit, offset: offset }
@@ -36,6 +38,9 @@ export const getUsers = (
     }
     queryParams.id = idsArray as unknown as string[]
   }
+  if (includeIncomplete != null) {
+    queryParams.include_incomplete = includeIncomplete
+  }
 
   const req = { endpoint: 'users', queryParams }
 

package/src/services/solana/rewardsAttester.ts

@@ -4,6 +4,27 @@ import { Utils } from '../../utils/utils'
 
 const { decodeHashId } = Utils
 
+const errors = {
+  ...SubmitAndEvaluateError,
+  USERBANK_CREATION: 'USERBANK_CREATION'
+}
+const AAO_ERRORS = new Set<string>([
+  errors.AAO_ATTESTATION_REJECTION,
+  errors.AAO_ATTESTATION_UNKNOWN_RESPONSE
+])
+// Account for errors from DN aggregation + Solana program
+// CHALLENGE_INCOMPLETE and MISSING_CHALLENGES are already handled in the `submitAndEvaluate` flow -
+// safe to assume those won't work if we see them at this point.
+const NEEDS_RESELECT_ERRORS = new Set<string>([
+  errors.INSUFFICIENT_DISCOVERY_NODE_COUNT,
+  errors.CHALLENGE_INCOMPLETE,
+  errors.MISSING_CHALLENGES
+])
+const ALREADY_COMPLETE_ERRORS = new Set<string>([
+  errors.ALREADY_DISBURSED,
+  errors.ALREADY_SENT
+])
+
 // `BaseRewardsReporter` is intended to be subclassed, and provides
 // "reporting" functionality to RewardsAttester (i.e. posts to Slack if something notable happens)
 class BaseRewardsReporter {
@@ -698,6 +719,31 @@ export class RewardsAttester {
       )}], challengeId: [${challengeId}], quorum size: [${this.quorumSize}]}`
     )
 
+    const feePayerOverride = this._getFeePayer()
+    const { error: userbankCreationError } =
+      await this.libs.solanaWeb3Manager.createUserBankIfNeeded(
+        feePayerOverride,
+        wallet
+      )
+
+    if (userbankCreationError) {
+      this.logger.error(
+        `Failed to create user bank for user [${decodeHashId(userId)}]`,
+        userbankCreationError
+      )
+
+      return {
+        challengeId,
+        userId,
+        specifier,
+        amount,
+        handle,
+        wallet,
+        completedBlocknumber,
+        error: errors.USERBANK_CREATION
+      }
+    }
+
     const { success, error, aaoErrorCode, phase, nodesToReselect } =
       await this.libs.Rewards.submitAndEvaluate({
         challengeId,
@@ -711,7 +757,7 @@ export class RewardsAttester {
         AAOEndpoint: this.aaoEndpoint,
         endpoints: this.endpoints,
         logger: this.logger,
-        feePayerOverride: this._getFeePayer(),
+        feePayerOverride,
         maxAggregationAttempts: this.maxAggregationAttempts
       })
 
@@ -890,26 +936,6 @@ export class RewardsAttester {
     shouldReselect: boolean
     failingNodes: string[]
   }> {
-    const errors = SubmitAndEvaluateError
-    const AAO_ERRORS = new Set([
-      errors.HCAPTCHA,
-      errors.COGNITO_FLOW,
-      errors.AAO_ATTESTATION_REJECTION,
-      errors.AAO_ATTESTATION_UNKNOWN_RESPONSE
-    ])
-    // Account for errors from DN aggregation + Solana program
-    // CHALLENGE_INCOMPLETE and MISSING_CHALLENGES are already handled in the `submitAndEvaluate` flow -
-    // safe to assume those won't work if we see them at this point.
-    const NEEDS_RESELECT_ERRORS = new Set([
-      errors.INSUFFICIENT_DISCOVERY_NODE_COUNT,
-      errors.CHALLENGE_INCOMPLETE,
-      errors.MISSING_CHALLENGES
-    ])
-    const ALREADY_COMPLETE_ERRORS = new Set([
-      errors.ALREADY_DISBURSED,
-      errors.ALREADY_SENT
-    ])
-
     const noRetry: AttestationResult[] = []
     const successful: AttestationResult[] = []
     // Filter our successful responses

package/src/utils/fileHasher.ts

@@ -14,7 +14,9 @@ import type {
   Query,
   KeyQuery
 } from 'interface-store'
-import type { CID } from 'multiformats/cid'
+import { CID } from 'multiformats/cid'
+import * as json from 'multiformats/codecs/json'
+import { sha256 } from 'multiformats/hashes/sha2'
 
 // Base functionality for only hash logic taken from https://github.com/alanshaw/ipfs-only-hash/blob/master/index.js
 
@@ -154,7 +156,7 @@ export const fileHasher = {
    * Custom fn to generate the content-hashing logic
    * @param content a buffer of the content
    * @param options options for importer
-   * @returns the CID from content addressing logic
+   * @returns the V0 CID from content addressing logic
    */
   async hashNonImages(
     content: Uint8Array,
@@ -227,7 +229,7 @@ export const fileHasher = {
   },
 
   /**
-   * Generates CID for a non-image file (track segment, track transcode, metadata)
+   * Generates CID V0 (46-char string starting with "Qm") for a non-image file (track segment, track transcode, metadata)
    * @param {Buffer|ReadStream|string} content a single Buffer, a ReadStream, or path to an existing file
    * @param {Object?} logger
    * @returns {string} only hash response cid
@@ -240,6 +242,19 @@ export const fileHasher = {
     return await fileHasher.hashNonImages(buffer)
   },
 
+  /**
+   * Generates CID V1 for a JSON metadata object (NOT the string of the metadata - must be an object).
+   * CID<T, 512, SHA_256, 1> represents CID with json codec (512) and sha256 hash using CID V1.
+   * Call toString() on the result to get the CID V1 string.
+   */
+  async generateMetadataCidV1(
+    metadata: {}
+  ): Promise<CID> {
+    const bytes = json.encode(metadata)
+    const hash = await sha256.digest(bytes)
+    return CID.create(1, json.code, hash)
+  },
+
   /**
    * Wrapper that generates multihashes for image files
    * @param {Object[]} content an Object[] with the structure [{ path: string, content: buffer }, ...]

package/src/utils/types.ts

@@ -44,6 +44,7 @@ export type UserMetadata = {
   handle_lc: string
   is_deactivated: boolean
   is_verified: boolean
+  is_storage_v2: boolean
   location: Nullable<string>
   // this should be removed
   is_creator: boolean