revert: license registration methods (#639)

* feat: add new PIL registration methods and update types

* Implemented methods for registering non-commercial social remixing, commercial use, commercial remix, and creative commons attribution PILs in the LicenseClient.
* Added corresponding request types for each new method to enhance type safety and clarity.
* Updated integration and unit tests to cover the new PIL registration functionalities, ensuring proper handling of license terms and error scenarios.
* Marked old methods as deprecated, guiding users to the new implementations for better consistency.

* fix: update deprecation messages in LicenseClient

Author: bonnie57

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

@@ -34,6 +34,10 @@ import {
   MintLicenseTokensRequest,
   MintLicenseTokensResponse,
   PredictMintingLicenseFeeRequest,
+  RegisterCommercialRemixPILRequest,
+  RegisterCommercialUsePILRequest,
+  RegisterCreativeCommonsAttributionPILRequest,
+  RegisterNonComSocialRemixingPILRequest,
   RegisterPILResponse,
   RegisterPilTermsAndAttachRequest,
   RegisterPilTermsAndAttachResponse,
@@ -530,6 +534,110 @@ export class LicenseClient {
     }
   }
 
+  /**
+   * @deprecated Use {@link PILFlavor.nonCommercialSocialRemixing} with {@link LicenseClient.registerPILTerms} instead.
+   *  This method will be removed soon.
+   *
+   * Convenient function to register a PIL non commercial social remix license to the registry
+   *
+   * For more details, see {@link https://docs.story.foundation/concepts/programmable-ip-license/pil-flavors#flavor-%231%3A-non-commercial-social-remixing | Non Commercial Social Remixing}.
+   *
+   * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicenseTemplate.sol#L19 | `LicenseTermsRegistered`} event.
+   */
+  public async registerNonComSocialRemixingPIL(
+    request?: RegisterNonComSocialRemixingPILRequest,
+  ): Promise<RegisterPILResponse> {
+    try {
+      const licenseTerms = PILFlavor.nonCommercialSocialRemixing();
+      return await this.registerPILTermsHelper(licenseTerms, request?.txOptions);
+    } catch (error) {
+      return handleError(error, "Failed to register non commercial social remixing PIL");
+    }
+  }
+
+  /**
+   * @deprecated Use {@link PILFlavor.commercialUse} with {@link LicenseClient.registerPILTerms} instead.
+   *  This method will be removed soon.
+   *
+   * Convenient function to register a PIL commercial use license to the registry.
+   *
+   * For more details, see {@link https://docs.story.foundation/concepts/programmable-ip-license/pil-flavors#flavor-%232%3A-commercial-use | Commercial Use}.
+   *
+   * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicenseTemplate.sol#L19 | `LicenseTermsRegistered`} event.
+   */
+  public async registerCommercialUsePIL(
+    request: RegisterCommercialUsePILRequest,
+  ): Promise<RegisterPILResponse> {
+    try {
+      const licenseTerms = PILFlavor.commercialUse({
+        defaultMintingFee: Number(request.defaultMintingFee),
+        currency: request.currency,
+        royaltyPolicy: request.royaltyPolicyAddress,
+      });
+      return await this.registerPILTermsHelper(licenseTerms, request.txOptions);
+    } catch (error) {
+      return handleError(error, "Failed to register commercial use PIL");
+    }
+  }
+
+  /**
+   * @deprecated Use {@link PILFlavor.commercialRemix} with {@link LicenseClient.registerPILTerms} instead.
+   *  This method will be removed soon.
+   *
+   * Convenient function to register a PIL commercial Remix license to the registry.
+   *
+   * For more details, see {@link https://docs.story.foundation/concepts/programmable-ip-license/pil-flavors#flavor-%233%3A-commercial-remix | Commercial Remix }.
+   *
+   * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicenseTemplate.sol#L19 | `LicenseTermsRegistered`} event.
+   */
+  public async registerCommercialRemixPIL({
+    defaultMintingFee,
+    currency,
+    royaltyPolicyAddress,
+    commercialRevShare,
+    txOptions,
+  }: RegisterCommercialRemixPILRequest): Promise<RegisterPILResponse> {
+    try {
+      const licenseTerms = PILFlavor.commercialRemix({
+        defaultMintingFee: Number(defaultMintingFee),
+        currency,
+        royaltyPolicy: royaltyPolicyAddress,
+        commercialRevShare,
+      });
+      return await this.registerPILTermsHelper(licenseTerms, txOptions);
+    } catch (error) {
+      return handleError(error, "Failed to register commercial remix PIL");
+    }
+  }
+
+  /**
+   * @deprecated Use {@link PILFlavor.creativeCommonsAttribution} with {@link LicenseClient.registerPILTerms} instead.
+   *  This method will be removed soon.
+   *
+   * Convenient function to register a PIL creative commons attribution license to the registry.
+   * Creates a Creative Commons Attribution (CC-BY) license terms flavor.
+   *
+   * For more details, see {@link https://docs.story.foundation/concepts/programmable-ip-license/pil-flavors#flavor-%234%3A-creative-commons-attribution | Creative Commons Attribution}.
+   *
+   * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicenseTemplate.sol#L19 | `LicenseTermsRegistered`} event.
+   */
+  public async registerCreativeCommonsAttributionPIL({
+    currency,
+    royaltyPolicyAddress,
+    txOptions,
+  }: RegisterCreativeCommonsAttributionPILRequest): Promise<RegisterPILResponse> {
+    try {
+      return await this.registerPILTermsHelper(
+        PILFlavor.creativeCommonsAttribution({
+          currency,
+          royaltyPolicy: royaltyPolicyAddress,
+        }),
+        txOptions,
+      );
+    } catch (error) {
+      return handleError(error, "Failed to register creative commons attribution PIL");
+    }
+  }
   private async getLicenseTermsId(licenseTerms: LicenseTerms): Promise<LicenseTermsIdResponse> {
     const licenseRes = await this.licenseTemplateClient.getLicenseTermsId({
       terms: licenseTerms,

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

@@ -223,3 +223,58 @@ export type LicenseTermsDataInput<T = LicenseTermsInput, C = LicensingConfigInpu
    */
   maxLicenseTokens?: TokenAmountInput;
 };
+
+export type RegisterNonComSocialRemixingPILRequest = {
+  txOptions?: TxOptions;
+};
+export type RegisterCommercialUsePILRequest = {
+  /** The fee to be paid when minting a license. */
+  defaultMintingFee: string | number | bigint;
+  /** The ERC20 token to be used to pay the minting fee */
+  currency: Address;
+  /**
+   * The address of the royalty policy contract.
+   * Defaults to {@link https://docs.story.foundation/docs/liquid-absolute-percentage | LAP} policy address if not provided.
+   */
+  royaltyPolicyAddress?: Address;
+  txOptions?: TxOptions;
+};
+
+export type RegisterCommercialRemixPILRequest = {
+  /** The fee to be paid when minting a license. */
+  defaultMintingFee: string | number | bigint;
+  /**
+   * Percentage of revenue that must be shared with the licensor.
+   * Must be between 0 and 100 (where 100% represents 100_000_000).
+   */
+  commercialRevShare: number;
+  /** The ERC20 token to be used to pay the minting fee */
+  currency: Address;
+  /**
+   * The address of the royalty policy contract.
+   * Defaults to {@link https://docs.story.foundation/docs/liquid-absolute-percentage | LAP} policy address if not provided.
+   */
+  royaltyPolicyAddress?: Address;
+  txOptions?: TxOptions;
+};
+
+export type RegisterCreativeCommonsAttributionPILRequest = WithTxOptions & {
+  /** The ERC20 or WIP token to be used to pay the minting fee. */
+  currency: Address;
+  /**
+   * The address of the royalty policy contract.
+   * Defaults to {@link https://docs.story.foundation/docs/liquid-absolute-percentage | LAP} policy address if not provided.
+   */
+  royaltyPolicyAddress?: Address;
+};
+/**
+ * @deprecated Use `PILFlavor.nonCommercialSocialRemixing`, `PILFlavor.commercialUse`, `PILFlavor.commercialRemix`, or `PILFlavor.creativeCommonsAttribution` instead.
+ *
+ * The type of PIL.
+ */
+export enum PIL_TYPE {
+  NON_COMMERCIAL_REMIX,
+  COMMERCIAL_USE,
+  COMMERCIAL_REMIX,
+  CREATIVE_COMMONS_ATTRIBUTION,
+}

packages/core-sdk/test/integration/license.test.ts

@@ -17,6 +17,7 @@ import {
   erc20Address,
   LicenseRegistryReadOnlyClient,
   licensingModuleAddress,
+  royaltyPolicyLapAddress,
 } from "../../src/abi/generated";
 import { WIP_TOKEN_ADDRESS } from "../../src/constants/common";
 import { ERC20Client } from "../../src/utils/token";
@@ -54,6 +55,35 @@ describe("License Functions", () => {
       });
       expect(result.licenseTermsId).to.be.a("bigint");
     });
+
+    it("should register license with non commercial social remixing PIL", async () => {
+      const result = await client.license.registerNonComSocialRemixingPIL();
+      expect(result.licenseTermsId).to.be.a("bigint");
+    });
+    it("should register license with commercial use", async () => {
+      const result = await client.license.registerCommercialUsePIL({
+        defaultMintingFee: "1",
+        currency: WIP_TOKEN_ADDRESS,
+      });
+      expect(result.licenseTermsId).to.be.a("bigint");
+    });
+
+    it("should register license with commercial Remix use", async () => {
+      const result = await client.license.registerCommercialRemixPIL({
+        defaultMintingFee: "1",
+        commercialRevShare: 100,
+        currency: WIP_TOKEN_ADDRESS,
+      });
+      expect(result.licenseTermsId).to.be.a("bigint");
+    });
+
+    it("should register license with creative commons attribution PIL", async () => {
+      const result = await client.license.registerCreativeCommonsAttributionPIL({
+        currency: WIP_TOKEN_ADDRESS,
+        royaltyPolicyAddress: royaltyPolicyLapAddress[aeneid],
+      });
+      expect(result.licenseTermsId).to.be.a("bigint");
+    });
   });
 
   describe("attach License Terms and mint license tokens", () => {
@@ -343,4 +373,100 @@ describe("License Functions", () => {
       expect(result.maxLicenseTokensTxHashes?.length).to.be.equal(2);
     });
   });
+
+  describe("Creative Commons Attribution License Tests", () => {
+    let ipId: Hex;
+    let ccLicenseTermsId: bigint;
+    let tokenId: number | undefined;
+
+    before(async () => {
+      tokenId = await getTokenId();
+
+      // Register an IP asset
+      const registerResult = await client.ipAsset.register({
+        nftContract: mockERC721,
+        tokenId: tokenId!,
+      });
+      ipId = registerResult.ipId!;
+
+      // Create a Creative Commons Attribution license
+      const ccLicenseResult = await client.license.registerCreativeCommonsAttributionPIL({
+        currency: WIP_TOKEN_ADDRESS,
+        royaltyPolicyAddress: royaltyPolicyLapAddress[aeneid],
+      });
+      ccLicenseTermsId = ccLicenseResult.licenseTermsId!;
+    });
+
+    it("should verify the license terms match Creative Commons Attribution specifications", async () => {
+      const licenseTerms = await client.license.getLicenseTerms(ccLicenseTermsId);
+
+      expect(licenseTerms.terms.transferable).to.equal(true);
+      expect(licenseTerms.terms.commercialUse).to.equal(true);
+      expect(licenseTerms.terms.derivativesAllowed).to.equal(true);
+      expect(licenseTerms.terms.derivativesAttribution).to.equal(true);
+      expect(licenseTerms.terms.derivativesReciprocal).to.equal(true);
+      expect(licenseTerms.terms.derivativesApproval).to.equal(false);
+      expect(licenseTerms.terms.commercialAttribution).to.equal(true);
+      expect(licenseTerms.terms.commercialRevShare).to.equal(0);
+      expect(licenseTerms.terms.defaultMintingFee).to.equal(0n);
+
+      expect(licenseTerms.terms.royaltyPolicy).to.equal(royaltyPolicyLapAddress[aeneid]);
+      expect(licenseTerms.terms.expiration).to.equal(0n);
+    });
+
+    it("should attach Creative Commons Attribution license to an IP", async () => {
+      const attachResult = await client.license.attachLicenseTerms({
+        ipId: ipId,
+        licenseTermsId: ccLicenseTermsId,
+      });
+
+      expect(attachResult.txHash).to.be.a("string");
+      expect(attachResult.success).to.equal(true);
+
+      const licenseRegistryReadOnlyClient = new LicenseRegistryReadOnlyClient(publicClient);
+      const hasLicense = await licenseRegistryReadOnlyClient.hasIpAttachedLicenseTerms({
+        ipId: ipId,
+        licenseTemplate: client.ipAsset.licenseTemplateClient.address,
+        licenseTermsId: ccLicenseTermsId,
+      });
+      expect(hasLicense).to.equal(true);
+    });
+
+    it("should mint CC-BY license tokens with no minting fee", async () => {
+      // Get wallet balance before minting
+      const balanceBefore = await client.getWalletBalance();
+
+      // Predict the minting fee (should be zero for CC-BY)
+      const feePredict = await client.license.predictMintingLicenseFee({
+        licenseTermsId: ccLicenseTermsId,
+        licensorIpId: ipId,
+        amount: 1,
+      });
+
+      // CC-BY licenses should have zero minting fee
+      expect(feePredict.tokenAmount).to.equal(0n);
+
+      const mintResult = await client.license.mintLicenseTokens({
+        licenseTermsId: ccLicenseTermsId,
+        licensorIpId: ipId,
+        maxMintingFee: 0n,
+        maxRevenueShare: 0,
+      });
+
+      expect(mintResult.txHash).to.be.a("string");
+      expect(mintResult.licenseTokenIds).to.be.a("array");
+
+      const balanceAfter = await client.getWalletBalance();
+
+      // Verify no fee was charged just gas
+      // This checks that any difference is very small (just gas costs)
+      const balanceDiff = balanceBefore - balanceAfter;
+      const gasUsed = mintResult.receipt!.gasUsed;
+      const effectiveGasPrice = mintResult.receipt!.effectiveGasPrice;
+      const totalGas = gasUsed * effectiveGasPrice;
+
+      // Confirms the balance diff only reflects gas cost, since license fee is zero.
+      expect(balanceDiff).to.equal(totalGas); // Small amount for gas
+    });
+  });
 });