@story-protocol/core-sdk 0.0.1-beta-rc.5 → 0.0.1-beta-rc.6

package/dist/story-protocol-core-sdk.esm.js

@@ -1,4 +1,4 @@
-import { getAddress, decodeEventLog, encodeAbiParameters, parseAbiParameters, encodeFunctionData, zeroAddress, stringToHex, createPublicClient, createWalletClient } from 'viem';
+import { getAddress, encodeAbiParameters, parseAbiParameters, decodeEventLog, encodeFunctionData, zeroAddress, stringToHex, createPublicClient, createWalletClient } from 'viem';
 import * as dotenv from 'dotenv';
 import { polygonMumbai, sepolia as sepolia$1, mainnet } from 'viem/chains';
 import axios from 'axios';
@@ -422,6 +422,7 @@ function handleError(error, msg) {
 
 var AddressZero = "0x0000000000000000000000000000000000000000";
 var HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var SepoliaChainId = "11155111";
 
 function _arrayLikeToArray(arr, len) {
   if (len == null || len > arr.length) len = arr.length;
@@ -794,6 +795,42 @@ var IPAssetRegistryABI = [{
   }],
   name: "IPRegistered",
   type: "event"
+}, {
+  inputs: [{
+    internalType: "uint256",
+    name: "chainId",
+    type: "uint256"
+  }, {
+    internalType: "address",
+    name: "tokenContract",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "tokenId",
+    type: "uint256"
+  }],
+  name: "ipId",
+  outputs: [{
+    internalType: "address",
+    name: "",
+    type: "address"
+  }],
+  stateMutability: "view",
+  type: "function"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "id",
+    type: "address"
+  }],
+  name: "isRegistered",
+  outputs: [{
+    internalType: "bool",
+    name: "",
+    type: "bool"
+  }],
+  stateMutability: "view",
+  type: "function"
 }];
 
 var LicensingModuleABI = [{
@@ -904,6 +941,49 @@ var LicensingModuleABI = [{
   }],
   stateMutability: "nonpayable",
   type: "function"
+}, {
+  inputs: [{
+    components: [{
+      internalType: "bool",
+      name: "isLicenseTransferable",
+      type: "bool"
+    }, {
+      internalType: "address",
+      name: "policyFramework",
+      type: "address"
+    }, {
+      internalType: "bytes",
+      name: "frameworkData",
+      type: "bytes"
+    }, {
+      internalType: "address",
+      name: "royaltyPolicy",
+      type: "address"
+    }, {
+      internalType: "bytes",
+      name: "royaltyData",
+      type: "bytes"
+    }, {
+      internalType: "uint256",
+      name: "mintingFee",
+      type: "uint256"
+    }, {
+      internalType: "address",
+      name: "mintingFeeToken",
+      type: "address"
+    }],
+    internalType: "struct Licensing.Policy",
+    name: "pol",
+    type: "tuple"
+  }],
+  name: "getPolicyId",
+  outputs: [{
+    internalType: "uint256",
+    name: "policyId",
+    type: "uint256"
+  }],
+  stateMutability: "view",
+  type: "function"
 }, {
   inputs: [{
     internalType: "uint256[]",
@@ -1805,50 +1885,31 @@ var ErrorsABI = [{
   inputs: [],
   name: "RoyaltyPolicyLAP__ZeroRoyaltyModule",
   type: "error"
-}, {
-  inputs: [],
-  name: "TaggingModule__DstIpIdDoesNotHaveDstTag",
-  type: "error"
-}, {
-  inputs: [],
-  name: "TaggingModule__InvalidRelationTypeName",
-  type: "error"
-}, {
-  inputs: [],
-  name: "TaggingModule__RelationTypeAlreadyExists",
-  type: "error"
-}, {
-  inputs: [],
-  name: "TaggingModule__RelationTypeDoesNotExist",
-  type: "error"
-}, {
-  inputs: [],
-  name: "TaggingModule__SrcIpIdDoesNotHaveSrcTag",
-  type: "error"
 }];
 
 var sepolia = {
-  AccessController: "0x31dd83a3FebB5fAD7F7bc8D4E05B623461B74a02",
-  AncestorsVaultLAP: "0x9Faa4E491a211bFa415d44554120B1b31b6f4e59",
-  ArbitrationPolicySP: "0x75e181d5eb307eCccf8d3b4724109eca14719A75",
-  DisputeModule: "0x11dAA3F573C4d6673BBE7f2D96B4C91073A0d55d",
-  Governance: "0xa18252Aa11Ff1B20b89C10109050CC46A4067b22",
-  IPAccountImpl: "0x7BBaB2BD68fd3990c8dA2c26334a6DF8Acc7E96E",
-  IPAccountRegistry: "0x7184bAdAdf24dc261C7C27BceFF53d7A25a06846",
-  IPAssetRegistry: "0xF59adB67B7CC87436A7CC41040A7dB24AE90aDB8",
-  IPAssetRenderer: "0x986d8E96b30b688FCD84e9A5A757C3d4304B47b6",
-  IPMetadataProvider: "0xfcD468A72F76e89F2Df517274063ef7210a32e2A",
-  IPResolver: "0xF0920314Fb4C375cdEB5b15c4e77277aCf36E3D7",
-  LicenseRegistry: "0x4D6a54B467332dF675cFa689cb294A4cB9122866",
-  LicensingModule: "0x0C72b24067a15994f91D92Fd9bA23eB5ebcF8378",
-  MockERC20: "0xd53C2A80D24F6B3Ff009E48CF88D3b482E8E1457",
-  MockERC721: "0xD3719824a768c139AAa7C5eFc8BDb5D1d13A1564",
-  MockTokenGatedHook: "0x2d3ED4354eD09B0E6aa252938aEF41920aB6FC40",
-  ModuleRegistry: "0x17Ad1cD06d44ae5F5480A675A4D8BD8DAED40410",
-  PILPolicyFrameworkManager: "0x49cF5C5523011F8B4A0489969096Eb68C571C197",
-  RegistrationModule: "0x248c8CbF469ec7CB22Dc9914E569920b93d717a3",
-  RoyaltyModule: "0x512bbF310452cC96E0E9818B0870EcA557b86d4D",
-  RoyaltyPolicyLAP: "0x8404061350BA0CA85c4E733B0be78c5519679003"
+  AccessController: "0x8eB53745795E2107E3568c647A77a7294C89Ef31",
+  AncestorsVaultLAP: "0x7FD793C4914da052022524BA17508976733B09AA",
+  ArbitrationPolicySP: "0xFfE389378AFa13D91485182D72700d226Cb0db16",
+  DisputeModule: "0xe94d7198EF5657C15be755aC3D9cb386F2Db50Bd",
+  Governance: "0x14Ac96796aadef6053e993aBDc3C1e7830ede901",
+  IPAccountImpl: "0xec3F947902fac41e59aa25669Fe39997BFA1357c",
+  IPAccountRegistry: "0xfe3ef84acECAd1F91583CB09E62953669C1c2bb5",
+  IPAssetRegistry: "0xA3a77482C64e91d4C89114D83Bd51457132ea947",
+  IPAssetRenderer: "0xF36c279a61b32D39e5Bc25e317f779362Be07E1d",
+  IPMetadataProvider: "0x40D52438C3852A872c71eB3a8b81d6274C5b6274",
+  IPResolver: "0x8BcE3019dBe94402A0276A2630373CDDB67fe271",
+  LicenseRegistry: "0x176d33Cc80ed3390256033bbf7Fd651c9C5A364F",
+  LicensingModule: "0x9CDDD88Dd34429a0F39eaDf91a56D1bf0533E72B",
+  MockERC20: "0x1219A0E87e617E6560104fA11cfd4f01FeB47362",
+  MockERC721: "0x9d790FF5B6A7469f32f18E677E15D48b86C6839b",
+  MockTokenGatedHook: "0x25018B7521E7607A7101302401bE81eDCA2E9730",
+  ModuleRegistry: "0x6E09516f10a4094b9B9A8C2b7Aa611A2D7827d3F",
+  PILPolicyFrameworkManager: "0x50c3bCAA67D4eC3f285E4328451315Ab0D9e539f",
+  RegistrationModule: "0x8b3f6b736b520F69c37a575293D3c1ff6383D495",
+  RoyaltyModule: "0x833774B42357939B4c96e1bCF5cE26e815AE3Ae6",
+  RoyaltyPolicyLAP: "0xda483fd6e6ecA1C2D913802F9a6B57a83b73029f",
+  TokenWithdrawalModule: "0x01469702E71F5C8199A15a97e8147D002C60a0B9"
 };
 
 var IPAccountABI = [].concat(_toConsumableArray(IPAccountImplABI), _toConsumableArray(ErrorsABI));
@@ -1880,6 +1941,9 @@ var PILPolicyFrameworkManagerConfig = {
   abi: [].concat(_toConsumableArray(PILPolicyFrameworkManagerABI), _toConsumableArray(ErrorsABI)),
   address: getAddress(sepolia.PILPolicyFrameworkManager)
 };
+var RoyaltyPolicyLAPConfig = {
+  address: getAddress(sepolia.RoyaltyPolicyLAP)
+};
 
 function _createForOfIteratorHelper(o, allowArrayLike) {
   var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
@@ -2148,12 +2212,24 @@ var IPAssetClient = /*#__PURE__*/function () {
     key: "registerRootIp",
     value: function () {
       var _registerRootIp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$txOptions, _yield$this$rpcClient, call, txHash, targetLog;
+        var _request$txOptions, ipId, _yield$this$rpcClient, call, txHash, targetLog;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               _context.prev = 0;
               _context.next = 3;
+              return this.isNFTRegistered(SepoliaChainId, request.tokenContractAddress, request.tokenId);
+            case 3:
+              ipId = _context.sent;
+              if (!ipId) {
+                _context.next = 6;
+                break;
+              }
+              return _context.abrupt("return", {
+                ipId: ipId
+              });
+            case 6:
+              _context.next = 8;
               return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.registrationModuleConfig), {}, {
                 functionName: "registerRootIp",
                 args: [parseToBigInt(request.policyId || "0"), getAddress(request.tokenContractAddress),
@@ -2161,43 +2237,43 @@ var IPAssetClient = /*#__PURE__*/function () {
                 parseToBigInt(request.tokenId), request.ipName || "", request.contentHash || HashZero, request.uri || ""],
                 account: this.wallet.account
               }));
-            case 3:
+            case 8:
               _yield$this$rpcClient = _context.sent;
               call = _yield$this$rpcClient.request;
-              _context.next = 7;
+              _context.next = 12;
               return this.wallet.writeContract(call);
-            case 7:
+            case 12:
               txHash = _context.sent;
               if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 15;
+                _context.next = 20;
                 break;
               }
-              _context.next = 11;
+              _context.next = 16;
               return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.ipAssetRegistryConfig), {}, {
                 eventName: "IPRegistered"
               }));
-            case 11:
+            case 16:
               targetLog = _context.sent;
               return _context.abrupt("return", {
                 txHash: txHash,
                 ipId: targetLog.args.ipId
               });
-            case 15:
+            case 20:
               return _context.abrupt("return", {
                 txHash: txHash
               });
-            case 16:
-              _context.next = 21;
+            case 21:
+              _context.next = 26;
               break;
-            case 18:
-              _context.prev = 18;
+            case 23:
+              _context.prev = 23;
               _context.t0 = _context["catch"](0);
               handleError(_context.t0, "Failed to register root IP");
-            case 21:
+            case 26:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 18]]);
+        }, _callee, this, [[0, 23]]);
       }));
       function registerRootIp(_x) {
         return _registerRootIp.apply(this, arguments);
@@ -2223,20 +2299,32 @@ var IPAssetClient = /*#__PURE__*/function () {
     key: "registerDerivativeIp",
     value: function () {
       var _registerDerivativeIp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, licenseIds, royaltyContext, _yield$this$rpcClient2, call, txHash, targetLog;
+        var _request$txOptions2, ipId, licenseIds, royaltyContext, _yield$this$rpcClient2, call, txHash, targetLog;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
               _context2.prev = 0;
+              _context2.next = 3;
+              return this.isNFTRegistered(SepoliaChainId, request.tokenContractAddress, request.tokenId);
+            case 3:
+              ipId = _context2.sent;
+              if (!(ipId !== "0x")) {
+                _context2.next = 6;
+                break;
+              }
+              return _context2.abrupt("return", {
+                ipId: ipId
+              });
+            case 6:
               licenseIds = [];
               request.licenseIds.forEach(function (licenseId) {
                 licenseIds.push(parseToBigInt(licenseId));
               });
-              _context2.next = 5;
+              _context2.next = 10;
               return computeRoyaltyContext(request.licenseIds, this.storyClient);
-            case 5:
+            case 10:
               royaltyContext = _context2.sent;
-              _context2.next = 8;
+              _context2.next = 13;
               return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.registrationModuleConfig), {}, {
                 functionName: "registerDerivativeIp",
                 args: [licenseIds, getAddress(request.tokenContractAddress),
@@ -2244,49 +2332,83 @@ var IPAssetClient = /*#__PURE__*/function () {
                 parseToBigInt(request.tokenId), request.ipName || "", request.contentHash || HashZero, request.uri || "", encodeRoyaltyContext(royaltyContext)],
                 account: this.wallet.account
               }));
-            case 8:
+            case 13:
               _yield$this$rpcClient2 = _context2.sent;
               call = _yield$this$rpcClient2.request;
-              _context2.next = 12;
+              _context2.next = 17;
               return this.wallet.writeContract(call);
-            case 12:
+            case 17:
               txHash = _context2.sent;
               if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context2.next = 20;
+                _context2.next = 25;
                 break;
               }
-              _context2.next = 16;
+              _context2.next = 21;
               return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.ipAssetRegistryConfig), {}, {
                 eventName: "IPRegistered"
               }));
-            case 16:
+            case 21:
               targetLog = _context2.sent;
               return _context2.abrupt("return", {
                 txHash: txHash,
                 ipId: targetLog.args.ipId
               });
-            case 20:
+            case 25:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 21:
-              _context2.next = 26;
+            case 26:
+              _context2.next = 31;
               break;
-            case 23:
-              _context2.prev = 23;
+            case 28:
+              _context2.prev = 28;
               _context2.t0 = _context2["catch"](0);
               handleError(_context2.t0, "Failed to register derivative IP");
-            case 26:
+            case 31:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this, [[0, 23]]);
+        }, _callee2, this, [[0, 28]]);
       }));
       function registerDerivativeIp(_x2) {
         return _registerDerivativeIp.apply(this, arguments);
       }
       return registerDerivativeIp;
     }()
+  }, {
+    key: "isNFTRegistered",
+    value: function () {
+      var _isNFTRegistered = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(chainId, tokenAddress, tokenId) {
+        var ipId, isRegistered;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return this.rpcClient.readContract(_objectSpread2(_objectSpread2({}, this.ipAssetRegistryConfig), {}, {
+                functionName: "ipId",
+                args: [parseToBigInt(chainId), tokenAddress, parseToBigInt(tokenId)]
+              }));
+            case 2:
+              ipId = _context3.sent;
+              _context3.next = 5;
+              return this.rpcClient.readContract(_objectSpread2(_objectSpread2({}, this.ipAssetRegistryConfig), {}, {
+                functionName: "isRegistered",
+                args: [ipId]
+              }));
+            case 5:
+              isRegistered = _context3.sent;
+              return _context3.abrupt("return", isRegistered ? ipId : "0x");
+            case 7:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function isNFTRegistered(_x3, _x4, _x5) {
+        return _isNFTRegistered.apply(this, arguments);
+      }
+      return isNFTRegistered;
+    }()
   }]);
   return IPAssetClient;
 }();
@@ -2314,7 +2436,7 @@ var PermissionClient = /*#__PURE__*/function () {
    *   @param request.ipAsset The address of the IP account that grants the permission for `signer`
    *   @param request.signer The address that can call `to` on behalf of the `ipAccount`
    *   @param request.to The address that can be called by the `signer` (currently only modules can be `to`)
-   *   @param request.func The function selector string of `to` that can be called by the `signer` on behalf of the `ipAccount`
+   *   @param request.func Optional. The function selector string of `to` that can be called by the `signer` on behalf of the `ipAccount`. Be default, it allows all functions.
    *   @param request.permission The new permission level
    * @returns A Promise that resolves to an object containing the transaction hash
    * @emits PermissionSet (ipAccountOwner, ipAccount, signer, to, func, permission)
@@ -2344,7 +2466,7 @@ var PermissionClient = /*#__PURE__*/function () {
                   // 0x Address
                   getAddress(request.to),
                   // 0x Address
-                  request.func,
+                  request.func || "0x00000000",
                   // bytes4
                   request.permission // uint8
                   ]
@@ -2581,6 +2703,7 @@ var PolicyClient = /*#__PURE__*/function () {
     _defineProperty(this, "ipAccountABI", IPAccountABI);
     _defineProperty(this, "licensingModuleConfig", LicensingModuleConfig);
     _defineProperty(this, "pilPolicyFrameworkManagerConfig", PILPolicyFrameworkManagerConfig);
+    _defineProperty(this, "royaltyPolicyLAPConfig", RoyaltyPolicyLAPConfig);
     this.wallet = wallet;
     this.rpcClient = rpcClient;
   }
@@ -2608,18 +2731,49 @@ var PolicyClient = /*#__PURE__*/function () {
     key: "registerPILPolicy",
     value: function () {
       var _registerPILPolicy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$txOptions, _yield$this$rpcClient, call, txHash, targetLog;
+        var _request$txOptions, frameworkData, policyId, _yield$this$rpcClient, call, txHash, targetLog;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               _context.prev = 0;
-              _context.next = 3;
+              // First check if the policy exists
+              frameworkData = {
+                attribution: request.attribution || false,
+                commercialUse: request.commercialUse || false,
+                commercialAttribution: request.commercialAttribution || false,
+                commercializerChecker: request.commercializerChecker || zeroAddress,
+                commercializerCheckerData: request.commercializerCheckerData || "0x",
+                commercialRevShare: request.commercialRevShare || 0,
+                derivativesAllowed: request.derivativesAllowed || false,
+                derivativesAttribution: request.derivativesAttribution || false,
+                derivativesApproval: request.derivativesApproval || false,
+                derivativesReciprocal: request.derivativesReciprocal || false,
+                territories: request.territories || [],
+                distributionChannels: request.distributionChannels || [],
+                contentRestrictions: request.contentRestrictions || []
+              };
+              _context.next = 4;
+              return this.getPolicyId(request.transferable, this.encodeFrameworkData(frameworkData), typedDataToBytes({
+                "interface": "uint32",
+                data: [request.commercialRevShare || 0]
+              }), request.mintingFee || "0", request.mintingFeeToken || zeroAddress, request.royaltyPolicy || zeroAddress);
+            case 4:
+              policyId = _context.sent;
+              if (!(policyId !== 0)) {
+                _context.next = 7;
+                break;
+              }
+              return _context.abrupt("return", {
+                policyId: policyId.toString()
+              });
+            case 7:
+              _context.next = 9;
               return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.pilPolicyFrameworkManagerConfig), {}, {
                 functionName: "registerPolicy",
                 args: [{
                   transferable: request.transferable,
                   royaltyPolicy: request.royaltyPolicy || zeroAddress,
-                  mintingFee: parseToBigInt(request.mintingFee || 0),
+                  mintingFee: parseToBigInt(request.mintingFee || "0"),
                   mintingFeeToken: request.mintingFeeToken || zeroAddress,
                   policy: {
                     attribution: request.attribution || false,
@@ -2627,7 +2781,7 @@ var PolicyClient = /*#__PURE__*/function () {
                     commercialAttribution: request.commercialAttribution || false,
                     commercialRevShare: request.commercialRevShare || 0,
                     derivativesAllowed: request.derivativesAllowed || false,
-                    derivativesAttribution: request.commercialAttribution || false,
+                    derivativesAttribution: request.derivativesAttribution || false,
                     derivativesApproval: request.derivativesApproval || false,
                     derivativesReciprocal: request.derivativesReciprocal || false,
                     commercializerChecker: request.commercializerChecker || zeroAddress,
@@ -2639,49 +2793,332 @@ var PolicyClient = /*#__PURE__*/function () {
                 }],
                 account: this.wallet.account
               }));
-            case 3:
+            case 9:
               _yield$this$rpcClient = _context.sent;
               call = _yield$this$rpcClient.request;
-              _context.next = 7;
+              _context.next = 13;
               return this.wallet.writeContract(call);
-            case 7:
+            case 13:
               txHash = _context.sent;
               if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 15;
+                _context.next = 21;
                 break;
               }
-              _context.next = 11;
+              _context.next = 17;
               return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
                 eventName: "PolicyRegistered"
               }));
-            case 11:
+            case 17:
               targetLog = _context.sent;
               return _context.abrupt("return", {
                 txHash: txHash,
                 policyId: targetLog === null || targetLog === void 0 ? void 0 : targetLog.args.policyId.toString()
               });
-            case 15:
+            case 21:
               return _context.abrupt("return", {
                 txHash: txHash
               });
-            case 16:
-              _context.next = 21;
+            case 22:
+              _context.next = 27;
               break;
-            case 18:
-              _context.prev = 18;
+            case 24:
+              _context.prev = 24;
               _context.t0 = _context["catch"](0);
               handleError(_context.t0, "Failed to register policy");
-            case 21:
+            case 27:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 18]]);
+        }, _callee, this, [[0, 24]]);
       }));
       function registerPILPolicy(_x) {
         return _registerPILPolicy.apply(this, arguments);
       }
       return registerPILPolicy;
     }()
+    /**
+     * Convenient function to register a PIL social remix policy to the registry
+     * Internally, this function must generate a Licensing.Policy struct and call registerPolicy.
+     * @param request - the licensing parameters for the Programmable IP License v1 (PIL) standard.
+     *   @param request.territories List of territories where the license is valid. If empty, global.
+     *   @param request.distributionChannels List of distribution channels where the license is valid. Empty if no restrictions.
+     *   @param request.contentRestrictions List of content restrictions where the license is valid. Empty if no restrictions.
+     * @returns the transaction hash and the policy ID if the txOptions.waitForTransaction is set to true
+     */
+  }, {
+    key: "registerPILSocialRemixPolicy",
+    value: function () {
+      var _registerPILSocialRemixPolicy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
+        var _request$txOptions2, frameworkData, policyId, _yield$this$rpcClient2, call, txHash, targetLog;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.prev = 0;
+              // First check if the policy exists
+              frameworkData = {
+                attribution: true,
+                commercialUse: false,
+                commercialAttribution: false,
+                commercializerChecker: zeroAddress,
+                commercializerCheckerData: "0x",
+                commercialRevShare: 0,
+                derivativesAllowed: true,
+                derivativesAttribution: true,
+                derivativesApproval: false,
+                derivativesReciprocal: true,
+                territories: request.territories || [],
+                distributionChannels: request.distributionChannels || [],
+                contentRestrictions: request.contentRestrictions || []
+              };
+              _context2.next = 4;
+              return this.getPolicyId(true, this.encodeFrameworkData(frameworkData), typedDataToBytes({
+                "interface": "uint32",
+                data: [0]
+              }), "0", zeroAddress, zeroAddress);
+            case 4:
+              policyId = _context2.sent;
+              if (!(policyId !== 0)) {
+                _context2.next = 7;
+                break;
+              }
+              return _context2.abrupt("return", {
+                policyId: policyId.toString()
+              });
+            case 7:
+              _context2.next = 9;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.pilPolicyFrameworkManagerConfig), {}, {
+                functionName: "registerPolicy",
+                args: [{
+                  transferable: true,
+                  royaltyPolicy: zeroAddress,
+                  mintingFee: parseToBigInt(0),
+                  mintingFeeToken: zeroAddress,
+                  policy: {
+                    attribution: true,
+                    commercialUse: false,
+                    commercialAttribution: false,
+                    commercialRevShare: 0,
+                    derivativesAllowed: true,
+                    derivativesAttribution: true,
+                    derivativesApproval: false,
+                    derivativesReciprocal: true,
+                    commercializerChecker: zeroAddress,
+                    commercializerCheckerData: "0x",
+                    territories: request.territories || [],
+                    distributionChannels: request.distributionChannels || [],
+                    contentRestrictions: request.contentRestrictions || []
+                  }
+                }],
+                account: this.wallet.account
+              }));
+            case 9:
+              _yield$this$rpcClient2 = _context2.sent;
+              call = _yield$this$rpcClient2.request;
+              _context2.next = 13;
+              return this.wallet.writeContract(call);
+            case 13:
+              txHash = _context2.sent;
+              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
+                _context2.next = 21;
+                break;
+              }
+              _context2.next = 17;
+              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
+                eventName: "PolicyRegistered"
+              }));
+            case 17:
+              targetLog = _context2.sent;
+              return _context2.abrupt("return", {
+                txHash: txHash,
+                policyId: targetLog === null || targetLog === void 0 ? void 0 : targetLog.args.policyId.toString()
+              });
+            case 21:
+              return _context2.abrupt("return", {
+                txHash: txHash
+              });
+            case 22:
+              _context2.next = 27;
+              break;
+            case 24:
+              _context2.prev = 24;
+              _context2.t0 = _context2["catch"](0);
+              handleError(_context2.t0, "Failed to register social remix policy");
+            case 27:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[0, 24]]);
+      }));
+      function registerPILSocialRemixPolicy(_x2) {
+        return _registerPILSocialRemixPolicy.apply(this, arguments);
+      }
+      return registerPILSocialRemixPolicy;
+    }()
+    /**
+     * Convenient function to register a PIL social remix policy to the registry
+     * Internally, this function must generate a Licensing.Policy struct and call registerPolicy.
+     * @param request - the licensing parameters for the Programmable IP License v1 (PIL) standard.
+     *   @param request.commercialRevShare Percentage of revenue that must be shared with the licensor
+     *   @param mintingFee Fee to be paid when minting a license
+     *   @param mintingFeeToken Token to be used to pay the minting fee
+     *   @param request.territories List of territories where the license is valid. If empty, global.
+     *   @param request.distributionChannels List of distribution channels where the license is valid. Empty if no restrictions.
+     *   @param request.contentRestrictions List of content restrictions where the license is valid. Empty if no restrictions.
+     * @returns the transaction hash and the policy ID if the txOptions.waitForTransaction is set to true
+     */
+  }, {
+    key: "registerPILCommercialUsePolicy",
+    value: function () {
+      var _registerPILCommercialUsePolicy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(request) {
+        var _request$txOptions3, frameworkData, policyId, _yield$this$rpcClient3, call, txHash, targetLog;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.prev = 0;
+              // First check if the policy exists
+              frameworkData = {
+                attribution: true,
+                commercialUse: true,
+                commercialAttribution: true,
+                commercializerChecker: zeroAddress,
+                commercializerCheckerData: "0x",
+                commercialRevShare: request.commercialRevShare,
+                derivativesAllowed: true,
+                derivativesAttribution: true,
+                derivativesApproval: false,
+                derivativesReciprocal: true,
+                territories: request.territories || [],
+                distributionChannels: request.distributionChannels || [],
+                contentRestrictions: request.contentRestrictions || []
+              };
+              _context3.next = 4;
+              return this.getPolicyId(true, this.encodeFrameworkData(frameworkData), typedDataToBytes({
+                "interface": "uint32",
+                data: [request.commercialRevShare]
+              }), request.mintingFee || "0", request.mintingFeeToken || zeroAddress, this.royaltyPolicyLAPConfig.address);
+            case 4:
+              policyId = _context3.sent;
+              if (!(policyId !== 0)) {
+                _context3.next = 7;
+                break;
+              }
+              return _context3.abrupt("return", {
+                policyId: policyId.toString()
+              });
+            case 7:
+              _context3.next = 9;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.pilPolicyFrameworkManagerConfig), {}, {
+                functionName: "registerPolicy",
+                args: [{
+                  transferable: true,
+                  royaltyPolicy: this.royaltyPolicyLAPConfig.address,
+                  mintingFee: parseToBigInt(request.mintingFee || "0"),
+                  mintingFeeToken: request.mintingFeeToken || zeroAddress,
+                  policy: {
+                    attribution: true,
+                    commercialUse: true,
+                    commercialAttribution: true,
+                    commercialRevShare: request.commercialRevShare,
+                    derivativesAllowed: true,
+                    derivativesAttribution: true,
+                    derivativesApproval: false,
+                    derivativesReciprocal: true,
+                    commercializerChecker: zeroAddress,
+                    commercializerCheckerData: "0x",
+                    territories: request.territories || [],
+                    distributionChannels: request.distributionChannels || [],
+                    contentRestrictions: request.contentRestrictions || []
+                  }
+                }],
+                account: this.wallet.account
+              }));
+            case 9:
+              _yield$this$rpcClient3 = _context3.sent;
+              call = _yield$this$rpcClient3.request;
+              _context3.next = 13;
+              return this.wallet.writeContract(call);
+            case 13:
+              txHash = _context3.sent;
+              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.waitForTransaction)) {
+                _context3.next = 21;
+                break;
+              }
+              _context3.next = 17;
+              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
+                eventName: "PolicyRegistered"
+              }));
+            case 17:
+              targetLog = _context3.sent;
+              return _context3.abrupt("return", {
+                txHash: txHash,
+                policyId: targetLog === null || targetLog === void 0 ? void 0 : targetLog.args.policyId.toString()
+              });
+            case 21:
+              return _context3.abrupt("return", {
+                txHash: txHash
+              });
+            case 22:
+              _context3.next = 27;
+              break;
+            case 24:
+              _context3.prev = 24;
+              _context3.t0 = _context3["catch"](0);
+              handleError(_context3.t0, "Failed to register commercial use policy");
+            case 27:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[0, 24]]);
+      }));
+      function registerPILCommercialUsePolicy(_x3) {
+        return _registerPILCommercialUsePolicy.apply(this, arguments);
+      }
+      return registerPILCommercialUsePolicy;
+    }()
+  }, {
+    key: "getPolicyId",
+    value: function () {
+      var _getPolicyId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(transferable, frameworkData, royaltyData, mintingFee, mintingFeeToken, royaltyPolicy, policyFramework) {
+        var data;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return this.rpcClient.readContract(_objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
+                functionName: "getPolicyId",
+                args: [{
+                  isLicenseTransferable: transferable,
+                  policyFramework: policyFramework || this.pilPolicyFrameworkManagerConfig.address,
+                  frameworkData: frameworkData,
+                  royaltyPolicy: royaltyPolicy,
+                  royaltyData: royaltyData,
+                  mintingFee: parseToBigInt(mintingFee),
+                  mintingFeeToken: mintingFeeToken
+                }]
+              }));
+            case 2:
+              data = _context4.sent;
+              return _context4.abrupt("return", Number(data));
+            case 4:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function getPolicyId(_x4, _x5, _x6, _x7, _x8, _x9, _x10) {
+        return _getPolicyId.apply(this, arguments);
+      }
+      return getPolicyId;
+    }()
+  }, {
+    key: "encodeFrameworkData",
+    value: function encodeFrameworkData(data) {
+      return typedDataToBytes({
+        "interface": "(bool, bool, bool, address, bytes, uint32, bool, bool, bool, bool, string[], string[], string[])",
+        data: [[data.attribution, data.commercialUse, data.commercialAttribution, data.commercializerChecker, data.commercializerCheckerData, data.commercialRevShare, data.derivativesAllowed, data.derivativesAttribution, data.derivativesApproval, data.derivativesReciprocal, data.territories, data.distributionChannels, data.contentRestrictions]]
+      });
+    }
+
     /**
      * Adds a policy to the set of policies of an IP
      * @param request The request object containing details to add a policy to an IP
@@ -2692,17 +3129,17 @@ var PolicyClient = /*#__PURE__*/function () {
   }, {
     key: "addPolicyToIp",
     value: function () {
-      var _addPolicyToIp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, IPAccountConfig, _yield$this$rpcClient2, call, txHash, targetLog;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
+      var _addPolicyToIp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(request) {
+        var _request$txOptions4, IPAccountConfig, _yield$this$rpcClient4, call, txHash, targetLog;
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
             case 0:
-              _context2.prev = 0;
+              _context5.prev = 0;
               IPAccountConfig = {
                 abi: this.ipAccountABI,
                 address: getAddress(request.ipId)
               };
-              _context2.next = 4;
+              _context5.next = 4;
               return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, IPAccountConfig), {}, {
                 functionName: "execute",
                 args: [this.licensingModuleConfig.address, parseToBigInt(0), encodeFunctionData({
@@ -2713,44 +3150,44 @@ var PolicyClient = /*#__PURE__*/function () {
                 account: this.wallet.account
               }));
             case 4:
-              _yield$this$rpcClient2 = _context2.sent;
-              call = _yield$this$rpcClient2.request;
-              _context2.next = 8;
+              _yield$this$rpcClient4 = _context5.sent;
+              call = _yield$this$rpcClient4.request;
+              _context5.next = 8;
               return this.wallet.writeContract(call);
             case 8:
-              txHash = _context2.sent;
-              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context2.next = 16;
+              txHash = _context5.sent;
+              if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.waitForTransaction)) {
+                _context5.next = 16;
                 break;
               }
-              _context2.next = 12;
+              _context5.next = 12;
               return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
                 eventName: "PolicyAddedToIpId"
               }));
             case 12:
-              targetLog = _context2.sent;
-              return _context2.abrupt("return", {
+              targetLog = _context5.sent;
+              return _context5.abrupt("return", {
                 txHash: txHash,
                 index: targetLog.args.index.toString()
               });
             case 16:
-              return _context2.abrupt("return", {
+              return _context5.abrupt("return", {
                 txHash: txHash
               });
             case 17:
-              _context2.next = 22;
+              _context5.next = 22;
               break;
             case 19:
-              _context2.prev = 19;
-              _context2.t0 = _context2["catch"](0);
-              handleError(_context2.t0, "Failed to add policy to IP");
+              _context5.prev = 19;
+              _context5.t0 = _context5["catch"](0);
+              handleError(_context5.t0, "Failed to add policy to IP");
             case 22:
             case "end":
-              return _context2.stop();
+              return _context5.stop();
           }
-        }, _callee2, this, [[0, 19]]);
+        }, _callee5, this, [[0, 19]]);
       }));
-      function addPolicyToIp(_x2) {
+      function addPolicyToIp(_x11) {
         return _addPolicyToIp.apply(this, arguments);
       }
       return addPolicyToIp;