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

package/dist/declarations/src/resources/ipAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipAccount.d.ts","sourceRoot":"../../../../src/resources","sources":["ipAccount.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAc,MAAM,MAAM,CAAC;AAE9D,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,8BAA8B,EAC9B,+BAA+B,EAChC,wCAAqC;AAKtC,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAe;IAClC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAAgB;gBAEvB,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY;IAKzD;;;;;;OAMG;IACU,OAAO,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAwBzF;;;;;;;;;OASG;IACU,cAAc,CACzB,OAAO,EAAE,8BAA8B,GACtC,OAAO,CAAC,+BAA+B,CAAC;CA8B5C"}

package/dist/declarations/src/resources/ipAsset.d.ts

@@ -257,21 +257,7 @@ export declare class IPAssetClient {
         } | {
             readonly inputs: readonly [];
             readonly name: "DisputeModule__NotWhitelistedArbitrationRelayer";
-            readonly type: "error"; /**
-             *  Registers derivative IPs into the protocol. Derivative IPs are IP assets that inherit policies from
-             *  parent IPs by burning acquired license NFTs.
-             * @param request The request object that contains all data needed to register a root IP.
-             *   @param request.licenseIds The policy that identifies the licensing terms of the IP.
-             *   @param request.tokenContract The address of the NFT bound to the derivative IP.
-             *   @param request.tokenId The token id of the NFT bound to the derivative IP.
-             *   @param request.ipName [Optional] The name assigned to the new IP.
-             *   @param request.contentHash [Optional] The content hash of the IP being registered.
-             *   @param request.uri [Optional] An external URI to link to the IP.
-             *   @param request.minRoyalty [Optional] The minimum royalty percentage that the IP owner will receive.
-             *   @param request.txOptions [Optional] The transaction options.
-             * @returns A Promise that resolves to an object containing the transaction hash and optional IP ID if waitForTxn is set to true.
-             * @emits RootIPRegistered (msg.sender, ipId, policyId)
-             */
+            readonly type: "error";
         } | {
             readonly inputs: readonly [];
             readonly name: "DisputeModule__NotWhitelistedDisputeTag";

package/dist/declarations/src/resources/ipAsset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ipAsset.d.ts","sourceRoot":"../../../../src/resources","sources":["ipAsset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAc,MAAM,MAAM,CAAC;AAK9D,OAAO,EAAE,cAAc,EAAE,+BAA4B;AACrD,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC5B,qBAAqB,EACrB,sBAAsB,EACvB,sCAAmC;AAKpC,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAe;IACzC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiB;IACtC,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAyB;IAC9C,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAsD/B;;;;;;;;;;;;;;eAcG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MApEwD;gBAE/C,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,cAAc;IAMtF;;;;;;;;;;;;;;OAcG;IACU,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IA+B5F;;;;;;;;;;;;;;OAcG;IACU,oBAAoB,CAC/B,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,4BAA4B,CAAC;CAwCzC"}
+{"version":3,"file":"ipAsset.d.ts","sourceRoot":"../../../../src/resources","sources":["ipAsset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAc,MAAM,MAAM,CAAC;AAK9D,OAAO,EAAE,cAAc,EAAE,+BAA4B;AACrD,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC5B,qBAAqB,EACrB,sBAAsB,EACvB,sCAAmC;AAKpC,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAe;IACzC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiB;IACtC,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAyB;IAC9C,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAA4B;gBAE/C,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,cAAc;IAMtF;;;;;;;;;;;;;;OAcG;IACU,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IA+B5F;;;;;;;;;;;;;;OAcG;IACU,oBAAoB,CAC/B,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,4BAA4B,CAAC;CAwCzC"}

package/dist/declarations/src/resources/license.d.ts

@@ -1676,7 +1676,7 @@ export declare class LicenseClient {
      *   @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).
      */
     mintLicense(request: MintLicenseRequest): Promise<MintLicenseResponse>;
     linkIpToParent(request: LinkIpToParentRequest): Promise<LinkIpToParentResponse>;

package/dist/declarations/src/resources/permission.d.ts

@@ -1,5 +1,5 @@
 import { PublicClient, WalletClient } from "viem";
-import { setPermissionsRequest, setPermissionsResponse } from "../types/resources/permission.js";
+import { SetPermissionsRequest, SetPermissionsResponse } from "../types/resources/permission.js";
 export declare class PermissionClient {
     private readonly wallet;
     private readonly rpcClient;
@@ -1481,6 +1481,6 @@ export declare class PermissionClient {
      * @returns A Promise that resolves to an object containing the transaction hash
      * @emits PermissionSet (ipAccountOwner, ipAccount, signer, to, func, permission)
      */
-    setPermission(request: setPermissionsRequest): Promise<setPermissionsResponse>;
+    setPermission(request: SetPermissionsRequest): Promise<SetPermissionsResponse>;
 }
 //# sourceMappingURL=permission.d.ts.map

package/dist/declarations/src/types/resources/ipAccount.d.ts

@@ -0,0 +1,25 @@
+import { TxOptions } from "../options.js";
+export type IPAccountExecuteRequest = {
+    accountAddress: `0x${string}`;
+    to: `0x${string}`;
+    value: number;
+    data: `0x${string}`;
+    txOptions?: TxOptions;
+};
+export type IPAccountExecuteResponse = {
+    txHash: string;
+};
+export type IPAccountExecuteWithSigRequest = {
+    accountAddress: `0x${string}`;
+    to: `0x${string}`;
+    value: number;
+    data: `0x${string}`;
+    signer: `0x${string}`;
+    deadline: number;
+    signature: `0x${string}`;
+    txOptions?: TxOptions;
+};
+export type IPAccountExecuteWithSigResponse = {
+    txHash: string;
+};
+//# sourceMappingURL=ipAccount.d.ts.map

package/dist/declarations/src/types/resources/ipAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipAccount.d.ts","sourceRoot":"../../../../../src/types/resources","sources":["ipAccount.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,sBAAmB;AAEvC,MAAM,MAAM,uBAAuB,GAAG;IACpC,cAAc,EAAE,KAAK,MAAM,EAAE,CAAC;IAC9B,EAAE,EAAE,KAAK,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,KAAK,MAAM,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG;IAC3C,cAAc,EAAE,KAAK,MAAM,EAAE,CAAC;IAC9B,EAAE,EAAE,KAAK,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,KAAK,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,KAAK,MAAM,EAAE,CAAC;IACzB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC"}

package/dist/declarations/src/types/resources/ipAsset.d.ts

@@ -1,8 +1,8 @@
 import { TxOptions } from "../options.js";
 export type RegisterRootIpRequest = {
-    policyId: string;
     tokenContractAddress: string;
     tokenId: string;
+    policyId?: string;
     ipName?: string;
     contentHash?: `0x${string}`;
     uri?: string;

package/dist/declarations/src/types/resources/ipAsset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ipAsset.d.ts","sourceRoot":"../../../../../src/types/resources","sources":["ipAsset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,sBAAmB;AAEvC,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC"}
+{"version":3,"file":"ipAsset.d.ts","sourceRoot":"../../../../../src/types/resources","sources":["ipAsset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,sBAAmB;AAEvC,MAAM,MAAM,qBAAqB,GAAG;IAClC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC"}

package/dist/declarations/src/types/resources/permission.d.ts

@@ -1,5 +1,5 @@
 import { TxOptions } from "../options.js";
-export type setPermissionsRequest = {
+export type SetPermissionsRequest = {
     ipId: `0x${string}`;
     signer: `0x${string}`;
     to: `0x${string}`;
@@ -7,7 +7,7 @@ export type setPermissionsRequest = {
     permission: number;
     txOptions?: TxOptions;
 };
-export type setPermissionsResponse = {
+export type SetPermissionsResponse = {
     txHash: string;
     success?: boolean;
 };

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

@@ -447,6 +447,9 @@ function handleError(error, msg) {
   throw new Error("".concat(msg, ": Unknown error type"));
 }
 
+var AddressZero = "0x0000000000000000000000000000000000000000";
+var HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
+
 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];
@@ -1181,44 +1184,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",
@@ -1910,8 +1875,7 @@ var sepolia = {
   PILPolicyFrameworkManager: "0x49cF5C5523011F8B4A0489969096Eb68C571C197",
   RegistrationModule: "0x248c8CbF469ec7CB22Dc9914E569920b93d717a3",
   RoyaltyModule: "0x512bbF310452cC96E0E9818B0870EcA557b86d4D",
-  RoyaltyPolicyLAP: "0x8404061350BA0CA85c4E733B0be78c5519679003",
-  TaggingModule: "0xED445f1DeE74Cf470Aab47F4b63734653C4C9537"
+  RoyaltyPolicyLAP: "0x8404061350BA0CA85c4E733B0be78c5519679003"
 };
 
 var IPAccountABI = [].concat(_toConsumableArray(IPAccountImplABI), _toConsumableArray(ErrorsABI));
@@ -1939,10 +1903,6 @@ 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)
@@ -2105,112 +2065,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);
 }
@@ -2329,7 +2183,7 @@ var IPAssetClient = /*#__PURE__*/function () {
               _context.next = 3;
               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
@@ -2592,7 +2446,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",
@@ -3132,6 +2986,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 +3137,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 +3216,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 +3248,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 +3276,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 +3291,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 +3308,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 +3353,3 @@ exports.LicenseClient = LicenseClient;
 exports.PermissionClient = PermissionClient;
 exports.PolicyClient = PolicyClient;
 exports.StoryClient = StoryClient;
-exports.TaggingClient = TaggingClient;