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

package/dist/story-protocol-core-sdk.cjs.prod.js

@@ -447,6 +447,10 @@ function handleError(error, msg) {
   throw new Error("".concat(msg, ": Unknown error type"));
 }
 
+var AddressZero = "0x0000000000000000000000000000000000000000";
+var HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var SepoliaChainId = "11155111";
+
 function _arrayLikeToArray(arr, len) {
   if (len == null || len > arr.length) len = arr.length;
   for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
@@ -818,6 +822,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 = [{
@@ -928,6 +968,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[]",
@@ -1181,44 +1264,6 @@ var RegistrationModuleABI = [{
   type: "function"
 }];
 
-var TaggingModuleABI = [{
-  inputs: [{
-    internalType: "string",
-    name: "tag",
-    type: "string"
-  }, {
-    internalType: "address",
-    name: "ipId",
-    type: "address"
-  }],
-  name: "removeTag",
-  outputs: [{
-    internalType: "bool",
-    name: "removed",
-    type: "bool"
-  }],
-  stateMutability: "nonpayable",
-  type: "function"
-}, {
-  inputs: [{
-    internalType: "string",
-    name: "tag",
-    type: "string"
-  }, {
-    internalType: "address",
-    name: "ipId",
-    type: "address"
-  }],
-  name: "setTag",
-  outputs: [{
-    internalType: "bool",
-    name: "added",
-    type: "bool"
-  }],
-  stateMutability: "nonpayable",
-  type: "function"
-}];
-
 var ErrorsABI = [{
   inputs: [{
     internalType: "address",
@@ -1867,51 +1912,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",
-  TaggingModule: "0xED445f1DeE74Cf470Aab47F4b63734653C4C9537"
+  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));
@@ -1939,14 +1964,13 @@ var RegistrationModuleConfig = {
   abi: [].concat(_toConsumableArray(RegistrationModuleABI), _toConsumableArray(ErrorsABI)),
   address: viem.getAddress(sepolia.RegistrationModule)
 };
-var TaggingModuleConfig = {
-  abi: [].concat(_toConsumableArray(TaggingModuleABI), _toConsumableArray(ErrorsABI)),
-  address: viem.getAddress(sepolia.TaggingModule)
-};
 var PILPolicyFrameworkManagerConfig = {
   abi: [].concat(_toConsumableArray(PILPolicyFrameworkManagerABI), _toConsumableArray(ErrorsABI)),
   address: viem.getAddress(sepolia.PILPolicyFrameworkManager)
 };
+var RoyaltyPolicyLAPConfig = {
+  address: viem.getAddress(sepolia.RoyaltyPolicyLAP)
+};
 
 function _createForOfIteratorHelper(o, allowArrayLike) {
   var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
@@ -2105,112 +2129,6 @@ function chainStringToViemChain(chainId) {
   }
 }
 
-var TaggingClient = /*#__PURE__*/function () {
-  function TaggingClient(rpcClient, wallet) {
-    _classCallCheck(this, TaggingClient);
-    _defineProperty(this, "taggingModuleConfig", TaggingModuleConfig);
-    this.rpcClient = rpcClient;
-    this.wallet = wallet;
-  }
-  _createClass(TaggingClient, [{
-    key: "setTag",
-    value: function () {
-      var _setTag = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$txOptions, _yield$this$rpcClient, call, txHash;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              _context.prev = 0;
-              _context.next = 3;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.taggingModuleConfig), {}, {
-                functionName: "setTag",
-                args: [request.tag, request.ipId]
-              }));
-            case 3:
-              _yield$this$rpcClient = _context.sent;
-              call = _yield$this$rpcClient.request;
-              _context.next = 7;
-              return this.wallet.writeContract(call);
-            case 7:
-              txHash = _context.sent;
-              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 11;
-                break;
-              }
-              _context.next = 11;
-              return waitTx(this.rpcClient, txHash);
-            case 11:
-              return _context.abrupt("return", {
-                txHash: txHash
-              });
-            case 14:
-              _context.prev = 14;
-              _context.t0 = _context["catch"](0);
-              handleError(_context.t0, "Failed to set tag");
-            case 17:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this, [[0, 14]]);
-      }));
-      function setTag(_x) {
-        return _setTag.apply(this, arguments);
-      }
-      return setTag;
-    }()
-  }, {
-    key: "removeTag",
-    value: function () {
-      var _removeTag = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, _yield$this$rpcClient2, call, txHash;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              _context2.prev = 0;
-              _context2.next = 3;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.taggingModuleConfig), {}, {
-                functionName: "removeTag",
-                args: [request.tag, request.ipId]
-              }));
-            case 3:
-              _yield$this$rpcClient2 = _context2.sent;
-              call = _yield$this$rpcClient2.request;
-              _context2.next = 7;
-              return this.wallet.writeContract(call);
-            case 7:
-              txHash = _context2.sent;
-              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context2.next = 11;
-                break;
-              }
-              _context2.next = 11;
-              return waitTx(this.rpcClient, txHash);
-            case 11:
-              return _context2.abrupt("return", {
-                txHash: txHash
-              });
-            case 14:
-              _context2.prev = 14;
-              _context2.t0 = _context2["catch"](0);
-              handleError(_context2.t0, "Failed to remove tag");
-            case 17:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this, [[0, 14]]);
-      }));
-      function removeTag(_x2) {
-        return _removeTag.apply(this, arguments);
-      }
-      return removeTag;
-    }()
-  }]);
-  return TaggingClient;
-}();
-
-var AddressZero = "0x0000000000000000000000000000000000000000";
-var HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
-
 function computeRoyaltyContext(_x, _x2) {
   return _computeRoyaltyContext.apply(this, arguments);
 }
@@ -2321,56 +2239,68 @@ 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), viem.getAddress(request.tokenContractAddress),
+                args: [parseToBigInt(request.policyId || "0"), viem.getAddress(request.tokenContractAddress),
                 // 0x Address
                 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);
@@ -2396,20 +2326,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, viem.getAddress(request.tokenContractAddress),
@@ -2417,49 +2359,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;
 }();
@@ -2487,7 +2463,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)
@@ -2517,7 +2493,7 @@ var PermissionClient = /*#__PURE__*/function () {
                   // 0x Address
                   viem.getAddress(request.to),
                   // 0x Address
-                  request.func,
+                  request.func || "0x00000000",
                   // bytes4
                   request.permission // uint8
                   ]
@@ -2592,7 +2568,7 @@ var LicenseClient = /*#__PURE__*/function () {
    *   @param request.licensorIpId_ The ID of the IP granting the license (ie. licensor)
    *   @param request.mintAmount Number of licenses to mint. License NFT is fungible for same policy and same licensors
    *   @param request.receiver Receiver address of the minted license NFT(s).
-   * @return licenseId The ID of the minted license NFT(s).
+   * @returns licenseId The ID of the minted license NFT(s).
    */
   _createClass(LicenseClient, [{
     key: "mintLicense",
@@ -2754,6 +2730,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;
   }
@@ -2781,18 +2758,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 || viem.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 || viem.zeroAddress, request.royaltyPolicy || viem.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 || viem.zeroAddress,
-                  mintingFee: parseToBigInt(request.mintingFee || 0),
+                  mintingFee: parseToBigInt(request.mintingFee || "0"),
                   mintingFeeToken: request.mintingFeeToken || viem.zeroAddress,
                   policy: {
                     attribution: request.attribution || false,
@@ -2800,7 +2808,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 || viem.zeroAddress,
@@ -2812,49 +2820,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: viem.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", viem.zeroAddress, viem.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: viem.zeroAddress,
+                  mintingFee: parseToBigInt(0),
+                  mintingFeeToken: viem.zeroAddress,
+                  policy: {
+                    attribution: true,
+                    commercialUse: false,
+                    commercialAttribution: false,
+                    commercialRevShare: 0,
+                    derivativesAllowed: true,
+                    derivativesAttribution: true,
+                    derivativesApproval: false,
+                    derivativesReciprocal: true,
+                    commercializerChecker: viem.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: viem.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 || viem.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 || viem.zeroAddress,
+                  policy: {
+                    attribution: true,
+                    commercialUse: true,
+                    commercialAttribution: true,
+                    commercialRevShare: request.commercialRevShare,
+                    derivativesAllowed: true,
+                    derivativesAttribution: true,
+                    derivativesApproval: false,
+                    derivativesReciprocal: true,
+                    commercializerChecker: viem.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
@@ -2865,17 +3156,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: viem.getAddress(request.ipId)
               };
-              _context2.next = 4;
+              _context5.next = 4;
               return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, IPAccountConfig), {}, {
                 functionName: "execute",
                 args: [this.licensingModuleConfig.address, parseToBigInt(0), viem.encodeFunctionData({
@@ -2886,44 +3177,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;
@@ -3132,6 +3423,137 @@ var DisputeClient = /*#__PURE__*/function () {
   return DisputeClient;
 }();
 
+var IPAccountClient = /*#__PURE__*/function () {
+  function IPAccountClient(rpcClient, wallet) {
+    _classCallCheck(this, IPAccountClient);
+    _defineProperty(this, "ipAccountABI", IPAccountABI);
+    this.wallet = wallet;
+    this.rpcClient = rpcClient;
+  }
+
+  /** Executes a transaction from the IP Account.
+   * @param request The request object containing necessary data to execute IP Account a transaction.
+   *   @param request.to The recipient of the transaction.
+   *   @param request.value The amount of Ether to send.
+   *   @param request.data The data to send along with the transaction.
+   * @returns Tx hash for the transaction.
+   */
+  _createClass(IPAccountClient, [{
+    key: "execute",
+    value: function () {
+      var _execute = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
+        var _request$txOptions, IPAccountConfig, _yield$this$rpcClient, call, txHash;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              IPAccountConfig = {
+                abi: this.ipAccountABI,
+                address: viem.getAddress(request.accountAddress)
+              };
+              _context.next = 4;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, IPAccountConfig), {}, {
+                functionName: "execute",
+                args: [request.to, parseToBigInt(0), request.data],
+                account: this.wallet.account
+              }));
+            case 4:
+              _yield$this$rpcClient = _context.sent;
+              call = _yield$this$rpcClient.request;
+              _context.next = 8;
+              return this.wallet.writeContract(call);
+            case 8:
+              txHash = _context.sent;
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
+                _context.next = 12;
+                break;
+              }
+              _context.next = 12;
+              return waitTx(this.rpcClient, txHash);
+            case 12:
+              return _context.abrupt("return", {
+                txHash: txHash
+              });
+            case 15:
+              _context.prev = 15;
+              _context.t0 = _context["catch"](0);
+              handleError(_context.t0, "Failed to execute the IP Account transaction");
+            case 18:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[0, 15]]);
+      }));
+      function execute(_x) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+    /** Executes a transaction from the IP Account.
+     * @param request The request object containing necessary data to execute IP Account a transaction.
+     *   @param request.to The recipient of the transaction.
+     *   @param request.value The amount of Ether to send.
+     *   @param request.data The data to send along with the transaction.
+     *   @param request.signer The signer of the transaction.
+     *   @param request.deadline The deadline of the transaction signature.
+     *   @param request.signature The signature of the transaction, EIP-712 encoded.
+     * @returns Tx hash for the transaction.
+     */
+  }, {
+    key: "executeWithSig",
+    value: function () {
+      var _executeWithSig = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
+        var _request$txOptions2, IPAccountConfig, _yield$this$rpcClient2, call, txHash;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.prev = 0;
+              IPAccountConfig = {
+                abi: this.ipAccountABI,
+                address: viem.getAddress(request.accountAddress)
+              };
+              _context2.next = 4;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, IPAccountConfig), {}, {
+                functionName: "executeWithSig",
+                args: [request.to, parseToBigInt(0), request.data, request.signer, parseToBigInt(request.deadline), request.signature],
+                account: this.wallet.account
+              }));
+            case 4:
+              _yield$this$rpcClient2 = _context2.sent;
+              call = _yield$this$rpcClient2.request;
+              _context2.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 = 12;
+                break;
+              }
+              _context2.next = 12;
+              return waitTx(this.rpcClient, txHash);
+            case 12:
+              return _context2.abrupt("return", {
+                txHash: txHash
+              });
+            case 15:
+              _context2.prev = 15;
+              _context2.t0 = _context2["catch"](0);
+              handleError(_context2.t0, "Failed to execute with signature for the IP Account transaction");
+            case 18:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[0, 15]]);
+      }));
+      function executeWithSig(_x2) {
+        return _executeWithSig.apply(this, arguments);
+      }
+      return executeWithSig;
+    }()
+  }]);
+  return IPAccountClient;
+}();
+
 var StoryAPIClient = /*#__PURE__*/function () {
   function StoryAPIClient() {
     _classCallCheck(this, StoryAPIClient);
@@ -3152,7 +3574,7 @@ var StoryAPIClient = /*#__PURE__*/function () {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               _context.next = 2;
-              return this.httpClient.get("/api/v1/royaltypolicies/".concat(ipId));
+              return this.httpClient.get("/api/v1/royalties/policies/".concat(ipId));
             case 2:
               royaltyPolicyResp = _context.sent;
               return _context.abrupt("return", royaltyPolicyResp.data.data);
@@ -3231,12 +3653,12 @@ var StoryClient = /*#__PURE__*/function () {
    */
   function StoryClient(config) {
     _classCallCheck(this, StoryClient);
-    _defineProperty(this, "_ipAccount", null);
+    _defineProperty(this, "_ipAsset", null);
     _defineProperty(this, "_permission", null);
     _defineProperty(this, "_license", null);
     _defineProperty(this, "_policy", null);
-    _defineProperty(this, "_tagging", null);
     _defineProperty(this, "_dispute", null);
+    _defineProperty(this, "_ipAccount", null);
     this.config = config;
     if (!this.config.transport) {
       throw new Error("transport is null, please pass in a valid RPC Provider URL as the transport.");
@@ -3263,12 +3685,26 @@ var StoryClient = /*#__PURE__*/function () {
    */
   _createClass(StoryClient, [{
     key: "ipAsset",
-    get: function get() {
-      if (this._ipAccount === null) {
-        this._ipAccount = new IPAssetClient(this.rpcClient, this.wallet, this.storyClient);
+    get:
+    /**
+     * Getter for the ip asset client. The client is lazily created when
+     * this method is called.
+     *
+     * @returns the IPAssetClient instance
+     */
+    function get() {
+      if (this._ipAsset === null) {
+        this._ipAsset = new IPAssetClient(this.rpcClient, this.wallet, this.storyClient);
       }
-      return this._ipAccount;
+      return this._ipAsset;
     }
+
+    /**
+     * Getter for the permission client. The client is lazily created when
+     * this method is called.
+     *
+     * @returns the PermissionClient instance
+     */
   }, {
     key: "permission",
     get: function get() {
@@ -3277,6 +3713,13 @@ var StoryClient = /*#__PURE__*/function () {
       }
       return this._permission;
     }
+
+    /**
+     * Getter for the license client. The client is lazily created when
+     * this method is called.
+     *
+     * @returns the LicenseClient instance
+     */
   }, {
     key: "license",
     get: function get() {
@@ -3285,6 +3728,13 @@ var StoryClient = /*#__PURE__*/function () {
       }
       return this._license;
     }
+
+    /**
+     * Getter for the policy client. The client is lazily created when
+     * this method is called.
+     *
+     * @returns the PolicyClient instance
+     */
   }, {
     key: "policy",
     get: function get() {
@@ -3295,33 +3745,33 @@ var StoryClient = /*#__PURE__*/function () {
     }
 
     /**
-     * Getter for the tagging client. The client is lazily created when
+     * Getter for the dispute client. The client is lazily created when
      * this method is called.
      *
-     * @returns the TaggingClient instance
+     * @returns the DisputeClient instance
      */
   }, {
-    key: "tagging",
+    key: "dispute",
     get: function get() {
-      if (this._tagging === null) {
-        this._tagging = new TaggingClient(this.rpcClient, this.wallet);
+      if (this._dispute === null) {
+        this._dispute = new DisputeClient(this.rpcClient, this.wallet);
       }
-      return this._tagging;
+      return this._dispute;
     }
 
     /**
-     * Getter for the dispute client. The client is lazily created when
+     * Getter for the ip account client. The client is lazily created when
      * this method is called.
      *
-     * @returns the DisputeClient instance
+     * @returns the IPAccountClient instance
      */
   }, {
-    key: "dispute",
+    key: "ipAccount",
     get: function get() {
-      if (this._dispute === null) {
-        this._dispute = new DisputeClient(this.rpcClient, this.wallet);
+      if (this._ipAccount === null) {
+        this._ipAccount = new IPAccountClient(this.rpcClient, this.wallet);
       }
-      return this._dispute;
+      return this._ipAccount;
     }
   }], [{
     key: "newClient",
@@ -3340,4 +3790,3 @@ exports.LicenseClient = LicenseClient;
 exports.PermissionClient = PermissionClient;
 exports.PolicyClient = PolicyClient;
 exports.StoryClient = StoryClient;
-exports.TaggingClient = TaggingClient;