Merge branch 'main' into bp/add-remove-ip-integration-tests

Author: bpolania

packages/core-sdk/src/abi/generated.ts

@@ -5,7 +5,9 @@ import {
   CoreMetadataModuleClient,
   groupingModuleAbi,
   GroupingModuleAddIpRequest,
+  GroupingModuleClaimRewardRequest,
   GroupingModuleClient,
+  GroupingModuleCollectRoyaltiesRequest,
   GroupingModuleEventClient,
   GroupingModuleRegisterGroupRequest,
   GroupingModuleRemoveIpRequest,
@@ -45,7 +47,12 @@ import {
   CollectAndDistributeGroupRoyaltiesRequest,
   CollectAndDistributeGroupRoyaltiesResponse,
   AddIpRequest,
+  ClaimRewardRequest,
+  ClaimRewardResponse,
+  GetClaimableRewardRequest,
   RemoveIpsFromGroupRequest,
+  CollectRoyaltiesRequest,
+  CollectRoyaltiesResponse,
 } from "../types/resources/group";
 import { getFunctionSignature } from "../utils/getFunctionSignature";
 import { validateLicenseConfig } from "../utils/validateLicenseConfig";
@@ -503,6 +510,27 @@ export class GroupClient {
       handleError(error, "Failed to add IP to group");
     }
   }
+  /**
+   * Returns the available reward for each IP in the group.
+   */
+  public async getClaimableReward({
+    groupIpId,
+    currencyToken,
+    memberIpIds,
+  }: GetClaimableRewardRequest): Promise<bigint[]> {
+    try {
+      const claimableReward = await this.groupingModuleClient.getClaimableReward({
+        groupId: validateAddress(groupIpId),
+        ipIds: validateAddresses(memberIpIds),
+        token: validateAddress(currencyToken),
+      });
+      // The result is cast as bigint[] because the `claimableReward` array is of type `readonly bigint[]`.
+      return claimableReward as bigint[];
+    } catch (error) {
+      handleError(error, "Failed to get claimable reward");
+    }
+  }
+
   /**
    * Removes IPs from group.
    * The function must be called by the Group IP owner or an authorized operator.
@@ -527,6 +555,72 @@ export class GroupClient {
       handleError(error, "Failed to remove IPs from group");
     }
   }
+
+  /**
+   * Claims reward.
+   *
+   * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/grouping/IGroupingModule.sol#L31 | `ClaimedReward`} event.
+   */
+  public async claimReward({
+    groupIpId,
+    currencyToken,
+    memberIpIds,
+    txOptions,
+  }: ClaimRewardRequest): Promise<ClaimRewardResponse> {
+    try {
+      const claimRewardParam: GroupingModuleClaimRewardRequest = {
+        groupId: validateAddress(groupIpId),
+        ipIds: validateAddresses(memberIpIds),
+        token: validateAddress(currencyToken),
+      };
+      const txHash = await this.groupingModuleClient.claimReward(claimRewardParam);
+      const { receipt } = await waitForTxReceipt({
+        txHash,
+        txOptions,
+        rpcClient: this.rpcClient,
+      });
+      if (!receipt) {
+        return { txHash };
+      }
+      const claimedReward = this.groupingModuleEventClient.parseTxClaimedRewardEvent(receipt);
+      return { txHash, claimedReward };
+    } catch (error) {
+      handleError(error, "Failed to claim reward");
+    }
+  }
+
+  /**
+   * Collects royalties into the pool, making them claimable by group member IPs.
+   *
+   * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/grouping/IGroupingModule.sol#L38 | `CollectedRoyaltiesToGroupPool`} event.
+   */
+  public async collectRoyalties({
+    groupIpId,
+    currencyToken,
+    txOptions,
+  }: CollectRoyaltiesRequest): Promise<CollectRoyaltiesResponse> {
+    try {
+      const collectRoyaltiesParam: GroupingModuleCollectRoyaltiesRequest = {
+        groupId: validateAddress(groupIpId),
+        token: validateAddress(currencyToken),
+      };
+      const txHash = await this.groupingModuleClient.collectRoyalties(collectRoyaltiesParam);
+      const { receipt } = await waitForTxReceipt({
+        txHash,
+        txOptions,
+        rpcClient: this.rpcClient,
+      });
+      if (!receipt) {
+        return { txHash };
+      }
+      const collectedRoyalties =
+        this.groupingModuleEventClient.parseTxCollectedRoyaltiesToGroupPoolEvent(receipt)[0].amount;
+      return { txHash, collectedRoyalties };
+    } catch (error) {
+      handleError(error, "Failed to collect royalties");
+    }
+  }
+
   private getLicenseData(licenseData: LicenseDataInput[] | LicenseDataInput): LicenseData[] {
     const isArray = Array.isArray(licenseData);
     if ((isArray && licenseData.length === 0) || !licenseData) {

packages/core-sdk/src/resources/group.ts

@@ -106,6 +106,7 @@ import { handleMulticall } from "../utils/registrationUtils/registerHelper";
 import {
   getCalculatedDeadline,
   getIpIdAddress,
+  getPublicMinting,
 } from "../utils/registrationUtils/registerValidation";
 import {
   getRoyaltyShares,
@@ -1530,12 +1531,25 @@ export class IPAssetClient {
   }: CommonRegistrationParams): Promise<CommonRegistrationTxResponse> {
     let totalFees = 0n;
     const wipSpenders: Erc20Spender[] = [];
+    let useMulticallWhenPossible = wipOptions?.useMulticallWhenPossible ?? true;
 
     // get spg minting fee
     if (spgNftContract) {
       const nftMintFee = await calculateSPGWipMintFee(
         new SpgnftImplReadOnlyClient(this.rpcClient, spgNftContract),
       );
+      const publicMinting = await getPublicMinting(spgNftContract, this.rpcClient);
+      /**
+       * If the SPG NFT contract's public minting is disabled, we need to check if the caller has the `minter role`.
+       * When public minting is disabled, we can't use multicall because we need to perform additional role checks
+       * that aren't compatible with batched transactions.
+       *
+       * This is because role-based access control requires the transaction's msg.sender to be verified directly,
+       * which is not preserved when using multicall (where the multicall contract becomes the sender).
+       */
+      if (!publicMinting) {
+        useMulticallWhenPossible = false;
+      }
       totalFees += nftMintFee;
       wipSpenders.push({
         address: spgNftContract,
@@ -1568,7 +1582,7 @@ export class IPAssetClient {
 
     const { txHash, receipt } = await contractCallWithFees({
       totalFees,
-      options: { wipOptions },
+      options: { wipOptions: { ...wipOptions, useMulticallWhenPossible } },
       multicall3Address: this.multicall3Client.address,
       rpcClient: this.rpcClient,
       tokenSpenders: wipSpenders,

packages/core-sdk/src/resources/ipAsset.ts

@@ -4,14 +4,19 @@ import {
   RegistrationWorkflowsClient,
   RegistrationWorkflowsCreateCollectionRequest,
   SimpleWalletClient,
+  SpgnftImplClient,
   SpgnftImplReadOnlyClient,
 } from "../abi/generated";
 import {
   CreateNFTCollectionRequest,
   CreateNFTCollectionResponse,
+  GetTokenURIRequest,
+  SetTokenURIRequest,
 } from "../types/resources/nftClient";
 import { handleError } from "../utils/errors";
 import { validateAddress } from "../utils/utils";
+import { TransactionResponse } from "../types/options";
+import { waitForTxReceipt } from "../utils/txOptions";
 
 export class NftClient {
   public registrationWorkflowsClient: RegistrationWorkflowsClient;
@@ -105,4 +110,35 @@ export class NftClient {
     );
     return spgNftClient.mintFee();
   }
+  /**
+   * Sets the token URI for a specific token id.
+   *
+   * @remarks
+   * Only callable by the owner of the token.
+   */
+  public async setTokenURI({
+    tokenId,
+    tokenURI,
+    spgNftContract,
+    txOptions,
+  }: SetTokenURIRequest): Promise<TransactionResponse> {
+    try {
+      const spgNftClient = new SpgnftImplClient(this.rpcClient, this.wallet, spgNftContract);
+      const txHash = await spgNftClient.setTokenUri({
+        tokenId: BigInt(tokenId),
+        tokenUri: tokenURI,
+      });
+      return waitForTxReceipt({ txHash, txOptions, rpcClient: this.rpcClient });
+    } catch (error) {
+      handleError(error, "Failed to set token URI");
+    }
+  }
+
+  /**
+   * Returns the token URI for a specific token id.
+   */
+  public async getTokenURI({ tokenId, spgNftContract }: GetTokenURIRequest): Promise<string> {
+    const spgNftClient = new SpgnftImplReadOnlyClient(this.rpcClient, spgNftContract);
+    return await spgNftClient.tokenUri({ tokenId: BigInt(tokenId) });
+  }
 }

packages/core-sdk/src/resources/nftClient.ts

@@ -3,6 +3,7 @@ import { Address, Hash, TransactionReceipt } from "viem";
 import { TxOptions } from "../options";
 import {
   EncodedTxData,
+  GroupingModuleClaimedRewardEvent,
   GroupingModuleCollectedRoyaltiesToGroupPoolEvent,
 } from "../../abi/generated";
 import { IpMetadataAndTxOptions, LicensingConfigInput, LicensingConfig } from "../common";
@@ -154,8 +155,39 @@ export type AddIpRequest = {
   txOptions?: Omit<TxOptions, "encodedTxDataOnly">;
 };
 
+export type ClaimRewardRequest = {
+  groupIpId: Address;
+  /** The address of the currency (revenue) token to claim. */
+  currencyToken: Address;
+  /** The IDs of the member IPs to distribute the rewards to. */
+  memberIpIds: Address[];
+  txOptions?: Omit<TxOptions, "encodedTxDataOnly">;
+};
+
+export type ClaimRewardResponse = {
+  txHash: Hash;
+  claimedReward?: GroupingModuleClaimedRewardEvent[];
+};
+export type GetClaimableRewardRequest = {
+  groupIpId: Address;
+  currencyToken: Address;
+  memberIpIds: Address[];
+};
+
 export type RemoveIpsFromGroupRequest = {
   groupIpId: Address;
   ipIds: Address[];
   txOptions?: Omit<TxOptions, "encodedTxDataOnly">;
 };
+
+export type CollectRoyaltiesRequest = {
+  groupIpId: Address;
+  currencyToken: Address;
+  txOptions?: Omit<TxOptions, "encodedTxDataOnly">;
+};
+
+export type CollectRoyaltiesResponse = {
+  txHash: Hash;
+  /** The amount of royalties collected. */
+  collectedRoyalties?: bigint;
+};

packages/core-sdk/src/types/resources/group.ts

@@ -31,3 +31,16 @@ export type CreateNFTCollectionResponse = {
   encodedTxData?: EncodedTxData;
   spgNftContract?: Address;
 };
+
+export type SetTokenURIRequest = {
+  tokenId: bigint | number;
+  /** The new metadata URI to associate with the token. */
+  tokenURI: string;
+  spgNftContract: Address;
+  txOptions?: Omit<TxOptions, "encodedTxDataOnly">;
+};
+
+export type GetTokenURIRequest = {
+  tokenId: bigint | number;
+  spgNftContract: Address;
+};