@story-protocol/core-sdk 1.3.0-rc.3 → 1.3.0

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

@@ -1,4 +1,4 @@
-import { isAddress, checksumAddress, formatEther, encodeFunctionData, decodeEventLog, zeroAddress, toFunctionSelector, keccak256, encodeAbiParameters, zeroHash, maxUint256, toHex, stringToHex, erc20Abi as erc20Abi$1, maxUint32, createPublicClient, createWalletClient } from 'viem';
+import { isAddress, formatEther, encodeFunctionData, decodeEventLog, zeroAddress, toFunctionSelector, keccak256, encodeAbiParameters, zeroHash, maxUint256, toHex, stringToHex, erc20Abi as erc20Abi$1, maxUint32, createPublicClient, createWalletClient } from 'viem';
 import * as dotenv from 'dotenv';
 import { defineChain } from 'viem/utils';
 import { CID } from 'multiformats/cid';
@@ -561,16 +561,6 @@ function validateAddresses(addresses) {
     return validateAddress(address);
   });
 }
-
-/** @deprecated use {@link validateAddress} */
-var getAddress$1 = function getAddress(address, name, chainId) {
-  if (!isAddress(address, {
-    strict: false
-  })) {
-    throw Error("".concat(name, " address is invalid: ").concat(address, ", Address must be a hex value of 20 bytes (40 hex characters) and match its checksum counterpart."));
-  }
-  return checksumAddress(address, chainId);
-};
 function getTokenAmountDisplay(amount) {
   var unit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "IP";
   return "".concat(formatEther(amount)).concat(unit);
@@ -3543,8 +3533,8 @@ function getAddress(address,chainId){return address[chainId||0]||"0x";}// Contra
    */)},{key:"withdrawEncode",value:function withdrawEncode(request){return {to:this.address,data:encodeFunctionData({abi:wrappedIpAbi,functionName:"withdraw",args:[request.value]})};}}]);}(WrappedIpReadOnlyClient);
 
 /**
- * This structure defines the terms for a Programmable IP License (PIL). These terms can be attached to IP Assets. The legal document of the PIL can be found in this repository.
- * @type LicenseTerms
+ * This structure defines the terms for a Programmable IP License (PIL).
+ * These terms can be attached to IP Assets.
  **/
 
 var PIL_TYPE = /*#__PURE__*/function (PIL_TYPE) {
@@ -3554,14 +3544,16 @@ var PIL_TYPE = /*#__PURE__*/function (PIL_TYPE) {
   return PIL_TYPE;
 }({});
 
-var AddressZero = "0x0000000000000000000000000000000000000000";
-var HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
 var defaultFunctionSelector = "0x00000000";
 var royaltySharesTotalSupply = 100000000;
 var MAX_ROYALTY_TOKEN = 100000000;
+var WIP_TOKEN_ADDRESS = wrappedIpAddress[mainnet.id];
 
-/** Address for the WIP contract. This address is fixed */
-var WIP_TOKEN_ADDRESS = "0x1514000000000000000000000000000000000000";
+/**
+ * This data used IP owners to define the configuration
+ * when others are minting license tokens of their IP through the LicensingModule.
+ * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/lib/Licensing.sol#L27 | Licensing.sol}
+ */
 
 /**
  * Input for token amount, can be bigint or number.
@@ -3774,14 +3766,6 @@ var getRevenueShare = function getRevenueShare(revShare) {
 
 /**
  * Get the signature for setting permissions.
- * @param param - The parameter object containing necessary data to get the signature.
- * @param param.ipId - The IP ID.
- * @param param.deadline - The deadline.
- * @param param.nonce - The nonce.
- * @param param.wallet - The wallet client.
- * @param param.chainId - The chain ID.
- * @param param.permissionFunc - The permission function,default function is setPermission.
- * @returns A Promise that resolves to the signature.
  */
 var getPermissionSignature = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(param) {
@@ -3795,15 +3779,15 @@ var getPermissionSignature = /*#__PURE__*/function () {
           data = encodeFunctionData({
             abi: accessControllerAbi,
             functionName: isBatchPermissionFunction ? "setBatchTransientPermissions" : "setTransientPermission",
-            args: isBatchPermissionFunction ? [permissions.map(function (item, index) {
+            args: isBatchPermissionFunction ? [permissions.map(function (item) {
               return {
-                ipAccount: getAddress$1(item.ipId, "permissions[".concat(index, "].ipId")),
-                signer: getAddress$1(item.signer, "permissions[".concat(index, "].signer")),
-                to: getAddress$1(item.to, "permissions[".concat(index, "].to")),
+                ipAccount: validateAddress(item.ipId),
+                signer: validateAddress(item.signer),
+                to: validateAddress(item.to),
                 func: item.func ? toFunctionSelector(item.func) : defaultFunctionSelector,
                 permission: item.permission
               };
-            })] : [getAddress$1(permissions[0].ipId, "permissions[0].ipId"), getAddress$1(permissions[0].signer, "permissions[0].signer"), getAddress$1(permissions[0].to, "permissions[0].to"), permissions[0].func ? toFunctionSelector(permissions[0].func) : defaultFunctionSelector, permissions[0].permission]
+            })] : [validateAddress(permissions[0].ipId), validateAddress(permissions[0].signer), validateAddress(permissions[0].to), permissions[0].func ? toFunctionSelector(permissions[0].func) : defaultFunctionSelector, permissions[0].permission]
           });
           _context.next = 6;
           return getSignature({
@@ -3836,15 +3820,6 @@ var getDeadline = function getDeadline(unixTimestamp, deadline) {
 
 /**
  * Get the signature.
- * @param param - The parameter object containing necessary data to get the signature.
- * @param param.state - The IP Account's state.
- * @param param.to - The recipient address.
- * @param param.encodeData - The encoded data.
- * @param param.wallet - The wallet client.
- * @param param.verifyingContract - The verifying contract.
- * @param param.deadline - The deadline.
- * @param param.chainId - The chain ID.
- * @returns A Promise that resolves to the signature.
  */
 var getSignature = /*#__PURE__*/function () {
   var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref2) {
@@ -3931,14 +3906,16 @@ var getSignature = /*#__PURE__*/function () {
 
 /**
  * Permission level
- * @enum {number}
- **/
+ */
 var AccessPermission = /*#__PURE__*/function (AccessPermission) {
-  /* ABSTAIN means having not enough information to make decision at current level, deferred decision to up. */
+  /**
+   * ABSTAIN means having not enough information to make decision at
+   * current level, deferred decision to up.
+   */
   AccessPermission[AccessPermission["ABSTAIN"] = 0] = "ABSTAIN";
-  /* ALLOW means the permission is granted to transaction signer to call the function. */
+  /** ALLOW means the permission is granted to transaction signer to call the function. */
   AccessPermission[AccessPermission["ALLOW"] = 1] = "ALLOW";
-  /* DENY means the permission is denied to transaction signer to call the function. */
+  /** DENY means the permission is denied to transaction signer to call the function. */
   AccessPermission[AccessPermission["DENY"] = 2] = "DENY";
   return AccessPermission;
 }({});
@@ -3984,7 +3961,7 @@ var validateLicenseConfig = function validateLicenseConfig(licensingConfig) {
       isSet: false,
       mintingFee: 0n,
       licensingHook: zeroAddress,
-      hookData: zeroAddress,
+      hookData: zeroHash,
       commercialRevShare: 0,
       disabled: false,
       expectMinimumGroupRewardShare: 0,
@@ -4013,12 +3990,12 @@ var validateLicenseConfig = function validateLicenseConfig(licensingConfig) {
   return licenseConfig;
 };
 
-var getIpMetadataForWorkflow = function getIpMetadataForWorkflow(metadata) {
+var getIpMetadataForWorkflow = function getIpMetadataForWorkflow(ipMetadata) {
   return {
-    ipMetadataURI: (metadata === null || metadata === void 0 ? void 0 : metadata.ipMetadataURI) || "",
-    ipMetadataHash: (metadata === null || metadata === void 0 ? void 0 : metadata.ipMetadataHash) || zeroHash,
-    nftMetadataURI: (metadata === null || metadata === void 0 ? void 0 : metadata.nftMetadataURI) || "",
-    nftMetadataHash: (metadata === null || metadata === void 0 ? void 0 : metadata.nftMetadataHash) || zeroHash
+    ipMetadataURI: (ipMetadata === null || ipMetadata === void 0 ? void 0 : ipMetadata.ipMetadataURI) || "",
+    ipMetadataHash: (ipMetadata === null || ipMetadata === void 0 ? void 0 : ipMetadata.ipMetadataHash) || zeroHash,
+    nftMetadataURI: (ipMetadata === null || ipMetadata === void 0 ? void 0 : ipMetadata.nftMetadataURI) || "",
+    nftMetadataHash: (ipMetadata === null || ipMetadata === void 0 ? void 0 : ipMetadata.nftMetadataHash) || zeroHash
   };
 };
 
@@ -4328,6 +4305,45 @@ var WipTokenClient = /*#__PURE__*/function () {
   }]);
 }();
 
+/**
+ * Predict the minting license fee.
+ *
+ * @remarks
+ * The method passes `walletAddress` to the `readContract` function so the smart contract can verify
+ * if the wallet is the owner of the IP ID. The wallet address is required when using the default license terms ID.
+ */
+var predictMintingLicenseFee = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
+    var predictMintingFeeRequest, rpcClient, chainId, walletAddress, result;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          predictMintingFeeRequest = _ref.predictMintingFeeRequest, rpcClient = _ref.rpcClient, chainId = _ref.chainId, walletAddress = _ref.walletAddress;
+          _context.next = 3;
+          return rpcClient.readContract({
+            abi: licensingModuleAbi,
+            address: licensingModuleAddress[chainId],
+            functionName: "predictMintingLicenseFee",
+            args: [predictMintingFeeRequest.licensorIpId, predictMintingFeeRequest.licenseTemplate, predictMintingFeeRequest.licenseTermsId, predictMintingFeeRequest.amount, predictMintingFeeRequest.receiver, predictMintingFeeRequest.royaltyContext],
+            account: walletAddress
+          });
+        case 3:
+          result = _context.sent;
+          return _context.abrupt("return", {
+            currencyToken: result[0],
+            tokenAmount: result[1]
+          });
+        case 5:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function predictMintingLicenseFee(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
 /**
  * check the allowance of all spenders and call approval if any spender
  * allowance is lower than the amount they are expected to spend.
@@ -4450,41 +4466,40 @@ var approvalAllSpenders = /*#__PURE__*/function () {
   };
 }();
 var calculateLicenseWipMintFee = /*#__PURE__*/function () {
-  var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(params) {
-    var fee;
+  var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref4) {
+    var predictMintingFeeRequest, rpcClient, chainId, walletAddress, fee;
     return _regeneratorRuntime().wrap(function _callee3$(_context3) {
       while (1) switch (_context3.prev = _context3.next) {
         case 0:
-          _context3.next = 2;
-          return params.licensingModuleClient.predictMintingLicenseFee({
-            licensorIpId: params.parentIpId,
-            licenseTemplate: params.licenseTemplateClient.address,
-            licenseTermsId: params.licenseTermsId,
-            amount: params.amount,
-            receiver: params.receiver,
-            royaltyContext: zeroAddress
+          predictMintingFeeRequest = _ref4.predictMintingFeeRequest, rpcClient = _ref4.rpcClient, chainId = _ref4.chainId, walletAddress = _ref4.walletAddress;
+          _context3.next = 3;
+          return predictMintingLicenseFee({
+            predictMintingFeeRequest: predictMintingFeeRequest,
+            rpcClient: rpcClient,
+            chainId: chainId,
+            walletAddress: walletAddress
           });
-        case 2:
+        case 3:
           fee = _context3.sent;
           if (!(fee.currencyToken !== WIP_TOKEN_ADDRESS)) {
-            _context3.next = 5;
+            _context3.next = 6;
             break;
           }
           return _context3.abrupt("return", 0n);
-        case 5:
-          return _context3.abrupt("return", fee.tokenAmount);
         case 6:
+          return _context3.abrupt("return", fee.tokenAmount);
+        case 7:
         case "end":
           return _context3.stop();
       }
     }, _callee3);
   }));
   return function calculateLicenseWipMintFee(_x3) {
-    return _ref4.apply(this, arguments);
+    return _ref5.apply(this, arguments);
   };
 }();
 var calculateSPGWipMintFee = /*#__PURE__*/function () {
-  var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(spgNftClient) {
+  var _ref6 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(spgNftClient) {
     var token;
     return _regeneratorRuntime().wrap(function _callee4$(_context4) {
       while (1) switch (_context4.prev = _context4.next) {
@@ -4510,16 +4525,16 @@ var calculateSPGWipMintFee = /*#__PURE__*/function () {
     }, _callee4);
   }));
   return function calculateSPGWipMintFee(_x4) {
-    return _ref5.apply(this, arguments);
+    return _ref6.apply(this, arguments);
   };
 }();
 var multiCallWrapIp = /*#__PURE__*/function () {
-  var _ref7 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(_ref6) {
+  var _ref8 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(_ref7) {
     var ipAmountToWrap, wipClient, multicall3Address, wipSpenders, calls, rpcClient, wallet, contractCall, wipOptions, multiCalls, useMultiCall, deposit, autoApprove, approvalCalls, txHash;
     return _regeneratorRuntime().wrap(function _callee5$(_context5) {
       while (1) switch (_context5.prev = _context5.next) {
         case 0:
-          ipAmountToWrap = _ref6.ipAmountToWrap, wipClient = _ref6.wipClient, multicall3Address = _ref6.multicall3Address, wipSpenders = _ref6.wipSpenders, calls = _ref6.calls, rpcClient = _ref6.rpcClient, wallet = _ref6.wallet, contractCall = _ref6.contractCall, wipOptions = _ref6.wipOptions;
+          ipAmountToWrap = _ref7.ipAmountToWrap, wipClient = _ref7.wipClient, multicall3Address = _ref7.multicall3Address, wipSpenders = _ref7.wipSpenders, calls = _ref7.calls, rpcClient = _ref7.rpcClient, wallet = _ref7.wallet, contractCall = _ref7.contractCall, wipOptions = _ref7.wipOptions;
           if (!(ipAmountToWrap === 0n)) {
             _context5.next = 3;
             break;
@@ -4608,7 +4623,7 @@ var multiCallWrapIp = /*#__PURE__*/function () {
     }, _callee5);
   }));
   return function multiCallWrapIp(_x5) {
-    return _ref7.apply(this, arguments);
+    return _ref8.apply(this, arguments);
   };
 }();
 
@@ -4626,13 +4641,13 @@ var multiCallWrapIp = /*#__PURE__*/function () {
  * for each spender address and approve it, unless disabled via `disableAutoApprove`.
  */
 var contractCallWithFees = /*#__PURE__*/function () {
-  var _ref9 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(_ref8) {
+  var _ref10 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(_ref9) {
     var _options$wipOptions;
     var totalFees, options, multicall3Address, wallet, tokenSpenders, contractCall, sender, txOptions, encodedTxs, rpcClient, token, wipTokenClient, isWip, selectedOptions, tokenClient, _txHash, balance, autoApprove, _txHash2, autoWrapIp, startingBalance, calls, _yield$multiCallWrapI, txHash;
     return _regeneratorRuntime().wrap(function _callee6$(_context6) {
       while (1) switch (_context6.prev = _context6.next) {
         case 0:
-          totalFees = _ref8.totalFees, options = _ref8.options, multicall3Address = _ref8.multicall3Address, wallet = _ref8.wallet, tokenSpenders = _ref8.tokenSpenders, contractCall = _ref8.contractCall, sender = _ref8.sender, txOptions = _ref8.txOptions, encodedTxs = _ref8.encodedTxs, rpcClient = _ref8.rpcClient, token = _ref8.token;
+          totalFees = _ref9.totalFees, options = _ref9.options, multicall3Address = _ref9.multicall3Address, wallet = _ref9.wallet, tokenSpenders = _ref9.tokenSpenders, contractCall = _ref9.contractCall, sender = _ref9.sender, txOptions = _ref9.txOptions, encodedTxs = _ref9.encodedTxs, rpcClient = _ref9.rpcClient, token = _ref9.token;
           wipTokenClient = new WipTokenClient(rpcClient, wallet);
           isWip = token === wipTokenClient.address || token === undefined;
           selectedOptions = isWip ? options === null || options === void 0 ? void 0 : options.wipOptions : options.erc20Options;
@@ -4747,7 +4762,7 @@ var contractCallWithFees = /*#__PURE__*/function () {
     }, _callee6);
   }));
   return function contractCallWithFees(_x6) {
-    return _ref9.apply(this, arguments);
+    return _ref10.apply(this, arguments);
   };
 }();
 
@@ -4787,18 +4802,8 @@ var IPAssetClient = /*#__PURE__*/function () {
 
     /**
      * Registers an NFT as IP, creating a corresponding IP record.
-     * @param request - The request object that contains all data needed to register IP.
-     *   @param request.nftContract The address of the NFT.
-     *   @param request.tokenId The token identifier of the NFT.
-     *   @param {Object} request.ipMetadata - [Optional] The desired metadata for the newly minted NFT and newly registered IP.
-     *     @param request.ipMetadata.ipMetadataURI [Optional] The URI of the metadata for the IP.
-     *     @param request.ipMetadata.ipMetadataHash [Optional] The hash of the metadata for the IP.
-     *     @param request.ipMetadata.nftMetadataURI [Optional] The URI of the metadata for the NFT.
-     *     @param request.ipMetadata.nftMetadataHash [Optional] The hash of the metadata for the IP NFT.
-     *   @param request.deadline [Optional] The deadline for the signature in seconds, default is 1000s.
-     *   @param request.txOptions [Optional] This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to a transaction hash, and if encodedTxDataOnly is true, includes encoded transaction data, and if waitForTransaction is true, includes IP ID, token ID.
-     * @emits IPRegistered (ipId, chainId, tokenContract, tokenId, resolverAddr, metadataProviderAddress, metadata)
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} event.
      */
   }, {
     key: "register",
@@ -4828,7 +4833,7 @@ var IPAssetClient = /*#__PURE__*/function () {
             case 10:
               object = {
                 tokenId: tokenId,
-                nftContract: getAddress$1(request.nftContract, "request.nftContract"),
+                nftContract: validateAddress(request.nftContract),
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata),
                 sigMetadata: {
                   signer: zeroAddress,
@@ -4855,8 +4860,8 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: chain[this.chainId],
                 permissions: [{
                   ipId: ipIdAddress,
-                  signer: getAddress$1(this.registrationWorkflowsClient.address, "registrationWorkflowsClient"),
-                  to: getAddress$1(this.coreMetadataModuleClient.address, "coreMetadataModuleAddress"),
+                  signer: validateAddress(this.registrationWorkflowsClient.address),
+                  to: validateAddress(this.coreMetadataModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(coreMetadataModuleAbi, "setAll")
                 }]
@@ -4865,7 +4870,7 @@ var IPAssetClient = /*#__PURE__*/function () {
               _yield$getPermissionS = _context.sent;
               signature = _yield$getPermissionS.signature;
               object.sigMetadata = {
-                signer: getAddress$1(this.wallet.account.address, "wallet.account.address"),
+                signer: validateAddress(this.walletAddress),
                 deadline: calculatedDeadline,
                 signature: signature
               };
@@ -4951,18 +4956,8 @@ var IPAssetClient = /*#__PURE__*/function () {
     }()
     /**
      * Batch registers an NFT as IP, creating a corresponding IP record.
-     * @param request - The request object that contains all data needed to batch register IP.
-     *  @param {Array} request.args The array of objects containing the data needed to register IP.
-     *   @param request.args.nftContract The address of the NFT.
-     *   @param request.args.tokenId The token identifier of the NFT.
-     *   @param {Object} request.args.ipMetadata - [Optional] The desired metadata for the newly minted NFT and newly registered IP.
-     *    @param request.args.ipMetadata.ipMetadataURI [Optional] The URI of the metadata for the IP.
-     *    @param request.args.ipMetadata.ipMetadataHash [Optional] The hash of the metadata for the IP.
-     *    @param request.args.ipMetadata.nftMetadataURI [Optional] The URI of the metadata for the NFT.
-     *    @param request.args.ipMetadata.nftMetadataHash [Optional] The hash of the metadata for the IP NFT.
-     *   @param request.txOptions [Optional] This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property, without encodedTxDataOnly option.
-     * @returns A Promise that resolves to a transaction hash, if waitForTransaction is true, return an array of containing IP ID, Token ID, NFT Contract.
-     * @emits IPRegistered (ipId, chainId, tokenContract, tokenId, resolverAddr, metadataProviderAddress, metadata)
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} event.
      */
     )
   }, {
@@ -5172,7 +5167,7 @@ var IPAssetClient = /*#__PURE__*/function () {
                 contractCall: contractCall,
                 txOptions: request.txOptions,
                 encodedTxs: [encodedTxData],
-                spgSpenderAddress: this.royaltyTokenDistributionWorkflowsClient.address,
+                spgSpenderAddress: this.royaltyModuleEventClient.address,
                 wipOptions: _objectSpread2(_objectSpread2({}, request.wipOptions), {}, {
                   useMulticallWhenPossible: false
                 })
@@ -5197,17 +5192,6 @@ var IPAssetClient = /*#__PURE__*/function () {
     }()
     /**
      * Batch registers a derivative directly with parent IP's license terms.
-     * @param request - The request object that contains all data needed to batch register derivative IP.
-     *  @param {Array} request.args The array of objects containing the data needed to register derivative IP.
-     *    @param request.args.childIpId The derivative IP ID.
-     *    @param {Array} request.args.parentIpIds The parent IP IDs.
-     *    @param {Array} request.args.licenseTermsIds The IDs of the license terms that the parent IP supports.
-     *    @param request.args.maxMintingFee The maximum minting fee that the caller is willing to pay. if set to 0 then no limit.
-     *    @param request.args.maxRts The maximum number of royalty tokens that can be distributed to the external royalty policies (max: 100,000,000).
-     *    @param request.args.maxRevenueShare The maximum revenue share percentage allowed for minting the License Tokens. Must be between 0 and 100,000,000 (where 100,000,000 represents 100%).
-     *  @param request.deadline [Optional] The deadline for the signature in seconds, default is 1000s.
-     *  @param request.txOptions [Optional] This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property, without encodedTxDataOnly option.
-     * @returns A Promise that resolves to a transaction hash.
      */
     )
   }, {
@@ -5220,7 +5204,7 @@ var IPAssetClient = /*#__PURE__*/function () {
             case 0:
               _context5.prev = 0;
               contracts = [];
-              licenseModuleAddress = getAddress$1(this.licensingModuleClient.address, "licensingModuleAddress");
+              licenseModuleAddress = validateAddress(this.licensingModuleClient.address);
               _iterator2 = _createForOfIteratorHelper(request.args);
               _context5.prev = 4;
               _iterator2.s();
@@ -5249,7 +5233,7 @@ var IPAssetClient = /*#__PURE__*/function () {
               return this.getCalculatedDeadline(request.deadline);
             case 18:
               calculatedDeadline = _context5.sent;
-              ipAccount = new IpAccountImplClient(this.rpcClient, this.wallet, getAddress$1(arg.childIpId, "arg.childIpId"));
+              ipAccount = new IpAccountImplClient(this.rpcClient, this.wallet, validateAddress(arg.childIpId));
               data = encodeFunctionData({
                 abi: licensingModuleAbi,
                 functionName: "registerDerivative",
@@ -5343,12 +5327,6 @@ var IPAssetClient = /*#__PURE__*/function () {
      * Registers a derivative with license tokens. The derivative IP is registered with license tokens minted from the parent IP's license terms.
      * The license terms of the parent IPs issued with license tokens are attached to the derivative IP.
      * The caller must be the derivative IP owner or an authorized operator.
-     * @param request - The request object that contains all data needed to register derivative license tokens.
-     *   @param request.childIpId The derivative IP ID.
-     *   @param {Array} request.licenseTokenIds The IDs of the license tokens.
-     *    @param request.args.maxRts The maximum number of royalty tokens that can be distributed to the external royalty policies (max: 100,000,000).
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to an object containing the transaction hash.
      */
     )
   }, {
@@ -5361,7 +5339,7 @@ var IPAssetClient = /*#__PURE__*/function () {
             case 0:
               _context6.prev = 0;
               req = {
-                childIpId: getAddress$1(request.childIpId, "request.childIpId"),
+                childIpId: validateAddress(request.childIpId),
                 licenseTokenIds: request.licenseTokenIds.map(function (id) {
                   return BigInt(id);
                 }),
@@ -5437,10 +5415,8 @@ var IPAssetClient = /*#__PURE__*/function () {
     }()
     /**
      * Mint an NFT from a collection and register it as an IP.
-     * it emits IPRegistered (ipId, chainId, tokenContract, tokenId, name, uri, registrationDate).
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | IIPAssetRegistry}
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicensingModule.sol#L19 | ILicensingModule}
-     * for a list of on-chain events emitted when an IP is minted and registered, and license terms are attached to an IP.
+     *
+     * Emits on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} and {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicensingModule.sol#L19 | `LicenseTermsAttached`} events.
      */
     )
   }, {
@@ -5460,8 +5436,8 @@ var IPAssetClient = /*#__PURE__*/function () {
               licenseTerms = _yield$this$validateL.licenseTerms;
               licenseTermsData = _yield$this$validateL.licenseTermsData;
               _object = {
-                spgNftContract: getAddress$1(request.spgNftContract, "request.spgNftContract"),
-                recipient: request.recipient && getAddress$1(request.recipient, "request.recipient") || this.wallet.account.address,
+                spgNftContract: validateAddress(request.spgNftContract),
+                recipient: validateAddress(request.recipient || this.walletAddress),
                 licenseTermsData: licenseTermsData,
                 allowDuplicates: request.allowDuplicates || true,
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata)
@@ -5523,49 +5499,8 @@ var IPAssetClient = /*#__PURE__*/function () {
     }()
     /**
      * Batch mint an NFT from a collection and register it as an IP.
-     * @param request - The request object that contains all data needed to batch mint and register ip.
-     *   @param {Array} request.args The array of mint and register IP requests.
-     *     @param request.args.spgNftContract The address of the NFT collection.
-     *     @param request.allowDuplicates Indicates whether the license terms can be attached to the same IP ID or not.
-     *     @param {Array} request.args.licenseTermsData The PIL terms and licensing configuration data to be attached to the IP.
-     *       @param {Object} request.args.licenseTermsData.terms The PIL terms to be used for the licensing.
-     *         @param request.args.licenseTermsData.terms.transferable Indicates whether the license is transferable or not.
-     *         @param request.args.licenseTermsData.terms.royaltyPolicy The address of the royalty policy contract which required to StoryProtocol in advance.
-     *         @param request.args.licenseTermsData.terms.mintingFee The fee to be paid when minting a license.
-     *         @param request.args.licenseTermsData.terms.expiration The expiration period of the license.
-     *         @param request.args.licenseTermsData.terms.commercialUse Indicates whether the work can be used commercially or not, Commercial use is required to deploy a royalty vault.
-     *         @param request.args.licenseTermsData.terms.commercialAttribution Whether attribution is required when reproducing the work commercially or not.
-     *         @param request.args.licenseTermsData.terms.commercializerChecker Commercializers that are allowed to commercially exploit the work. If zero address, then no restrictions is enforced.
-     *         @param request.args.licenseTermsData.terms.commercializerCheckerData The data to be passed to the commercializer checker contract.
-     *         @param request.args.licenseTermsData.terms.commercialRevShare Percentage of revenue that must be shared with the licensor.
-     *         @param request.args.licenseTermsData.terms.commercialRevCeiling The maximum revenue that can be generated from the commercial use of the work.
-     *         @param request.args.licenseTermsData.terms.derivativesAllowed Indicates whether the licensee can create derivatives of his work or not.
-     *         @param request.args.licenseTermsData.terms.derivativesAttribution Indicates whether attribution is required for derivatives of the work or not.
-     *         @param request.args.licenseTermsData.terms.derivativesApproval Indicates whether the licensor must approve derivatives of the work before they can be linked to the licensor IP ID or not.
-     *         @param request.args.licenseTermsData.terms.derivativesReciprocal Indicates whether the licensee must license derivatives of the work under the same terms or not.
-     *         @param request.args.licenseTermsData.terms.derivativeRevCeiling The maximum revenue that can be generated from the derivative use of the work.
-     *         @param request.args.licenseTermsData.terms.currency The ERC20 token to be used to pay the minting fee. the token must be registered in story protocol.
-     *         @param request.args.licenseTermsData.terms.uri The URI of the license terms, which can be used to fetch the offchain license terms.
-     *       @param {Object} request.args.licenseTermsData.licensingConfig The PIL terms and licensing configuration data to attach to the IP.
-     *         @param request.args.licenseTermsData.licensingConfig.isSet Whether the configuration is set or not.
-     *         @param request.args.licenseTermsData.licensingConfig.mintingFee The minting fee to be paid when minting license tokens.
-     *         @param request.args.licenseTermsData.licensingConfig.licensingHook The hook contract address for the licensing module, or zero address if none
-     *         @param request.args.licenseTermsData.licensingConfig.hookData The data to be used by the licensing hook.
-     *         @param request.args.licenseTermsData.licensingConfig.commercialRevShare The commercial revenue share percentage.
-     *         @param request.args.licenseTermsData.licensingConfig.disabled Whether the licensing is disabled or not.
-     *         @param request.args.licenseTermsData.licensingConfig.expectMinimumGroupRewardShare The minimum percentage of the group's reward share (from 0 to 100%, represented as 100 * 10 ** 6) that can be allocated to the IP when it is added to the group.
-     *         If the remaining reward share in the group is less than the minimumGroupRewardShare,the IP cannot be added to the group.
-     *         @param request.args.licenseTermsData.licensingConfig.expectGroupRewardPool The address of the expected group reward pool. The IP can only be added to a group with this specified reward pool address, or zero address if the IP does not want to be added to any group.
-     *     @param {Object} request.args.ipMetadata - [Optional] The desired metadata for the newly minted NFT and newly registered IP.
-     *       @param request.args.ipMetadata.ipMetadataURI [Optional] The URI of the metadata for the IP.
-     *       @param request.args.ipMetadata.ipMetadataHash [Optional] The hash of the metadata for the IP.
-     *       @param request.args.ipMetadata.nftMetadataURI [Optional] The URI of the metadata for the NFT.
-     *       @param request.args.ipMetadata.nftMetadataHash [Optional] The hash of the metadata for the IP NFT.
-     *     @param request.args.recipient [Optional] The address of the recipient of the minted NFT,default value is your wallet address.
-     *    @param request.txOptions [Optional] This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property, without encodedTxData option.
-     * @returns A Promise that resolves to a transaction hash, if waitForTransaction is true, return an array containing IP ID, Token ID, License Terms Ids, SPG NFT Contract.
-     * @emits IPRegistered (ipId, chainId, tokenContract, tokenId, name, uri, registrationDate)
-     * @emits LicenseTermsAttached (caller, ipId, licenseTemplate, licenseTermsId)
+     *
+     * Emits on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} and {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicensingModule.sol#L19 | `LicenseTermsAttached`} events.
      */
     )
   }, {
@@ -5694,8 +5629,8 @@ var IPAssetClient = /*#__PURE__*/function () {
     }()
     /**
      * Register a given NFT as an IP and attach Programmable IP License Terms.
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicensingModule.sol#L19 | ILicensingModule}
-     * for a list of on-chain events emitted when an ip is registered and license terms are attached to it.
+     *
+     * Emits on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} and {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicensingModule.sol#L19 | `LicenseTermsAttached`} events.
      */
     )
   }, {
@@ -5743,14 +5678,14 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: chain[this.chainId],
                 permissions: [{
                   ipId: ipIdAddress,
-                  signer: getAddress$1(this.licenseAttachmentWorkflowsClient.address, "licenseAttachmentWorkflowsClient"),
-                  to: getAddress$1(this.coreMetadataModuleClient.address, "coreMetadataModuleAddress"),
+                  signer: validateAddress(this.licenseAttachmentWorkflowsClient.address),
+                  to: validateAddress(this.coreMetadataModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(coreMetadataModuleAbi, "setAll")
                 }, {
                   ipId: ipIdAddress,
-                  signer: getAddress$1(this.licenseAttachmentWorkflowsClient.address, "licenseAttachmentWorkflowsClient"),
-                  to: getAddress$1(this.licensingModuleClient.address, "licensingModuleClient"),
+                  signer: this.licenseAttachmentWorkflowsClient.address,
+                  to: validateAddress(this.licensingModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(licensingModuleAbi, "attachLicenseTerms")
                 }, {
@@ -5765,12 +5700,12 @@ var IPAssetClient = /*#__PURE__*/function () {
               _yield$getPermissionS2 = _context9.sent;
               signature = _yield$getPermissionS2.signature;
               _object2 = {
-                nftContract: getAddress$1(request.nftContract, "request.nftContract"),
+                nftContract: validateAddress(request.nftContract),
                 tokenId: request.tokenId,
                 licenseTermsData: licenseTermsData,
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata),
                 sigMetadataAndAttachAndConfig: {
-                  signer: getAddress$1(this.wallet.account.address, "wallet.account.address"),
+                  signer: validateAddress(this.walletAddress),
                   deadline: calculatedDeadline,
                   signature: signature
                 }
@@ -5834,8 +5769,8 @@ var IPAssetClient = /*#__PURE__*/function () {
     }()
     /**
      * Register the given NFT as a derivative IP with metadata without using license tokens.
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | IIPAssetRegistry}
-     * for a list of on-chain events emitted when a derivative IP is registered.
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} event.
      */
     )
   }, {
@@ -5878,14 +5813,14 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: chain[this.chainId],
                 permissions: [{
                   ipId: ipIdAddress,
-                  signer: getAddress$1(this.derivativeWorkflowsClient.address, "derivativeWorkflowsClient"),
-                  to: getAddress$1(this.coreMetadataModuleClient.address, "coreMetadataModuleAddress"),
+                  signer: validateAddress(this.derivativeWorkflowsClient.address),
+                  to: validateAddress(this.coreMetadataModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(coreMetadataModuleAbi, "setAll")
                 }, {
                   ipId: ipIdAddress,
                   signer: this.derivativeWorkflowsClient.address,
-                  to: getAddress$1(this.licensingModuleClient.address, "licensingModuleAddress"),
+                  to: validateAddress(this.licensingModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(licensingModuleAbi, "registerDerivative")
                 }]
@@ -5898,7 +5833,7 @@ var IPAssetClient = /*#__PURE__*/function () {
             case 19:
               derivData = _context10.sent;
               _object3 = {
-                nftContract: getAddress$1(request.nftContract, "request.nftContract"),
+                nftContract: validateAddress(request.nftContract),
                 tokenId: BigInt(request.tokenId),
                 derivData: derivData,
                 sigMetadataAndRegister: {
@@ -5948,8 +5883,8 @@ var IPAssetClient = /*#__PURE__*/function () {
     }()
     /**
      * Mint an NFT from a collection and register it as a derivative IP without license tokens.
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | IIPAssetRegistry}
-     * for a list of on-chain events emitted when a derivative IP is minted and registered.
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} event.
      */
     )
   }, {
@@ -5966,8 +5901,8 @@ var IPAssetClient = /*#__PURE__*/function () {
               return this.validateDerivativeData(request.derivData);
             case 3:
               derivData = _context11.sent;
-              recipient = request.recipient && getAddress$1(request.recipient, "request.recipient") || this.walletAddress;
-              spgNftContract = getAddress$1(request.spgNftContract, "spgNftContract");
+              recipient = validateAddress(request.recipient || this.walletAddress);
+              spgNftContract = validateAddress(request.spgNftContract);
               _object4 = _objectSpread2(_objectSpread2({}, request), {}, {
                 derivData: derivData,
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata),
@@ -6014,22 +5949,8 @@ var IPAssetClient = /*#__PURE__*/function () {
     }()
     /**
      * Batch mint an NFT from a collection and register it as a derivative IP without license tokens.
-     * @param request - The request object that contains all data needed to batch mint and register ip and make derivative.
-     *  @param {Array} request.args The array of mint and register IP requests.
-     *   @param request.args.spgNftContract The address of the NFT collection.
-     *   @param {Object} request.args.derivData The derivative data to be used for registerDerivative.
-     *     @param {Array} request.args.derivData.parentIpIds The IDs of the parent IPs to link the registered derivative IP.
-     *     @param {Array} request.args.derivData.licenseTermsIds The IDs of the license terms to be used for the linking.
-     *     @param request.args.derivData.licenseTemplate [Optional] The address of the license template to be used for the linking.
-     *   @param {Object} request.args.ipMetadata - [Optional] The desired metadata for the newly minted NFT and newly registered IP.
-     *     @param request.args.ipMetadata.ipMetadataURI [Optional] The URI of the metadata for the IP.
-     *     @param request.args.ipMetadata.ipMetadataHash [Optional] The hash of the metadata for the IP.
-     *     @param request.args.ipMetadata.nftMetadataURI [Optional] The URI of the metadata for the NFT.
-     *     @param request.args.ipMetadata.nftMetadataHash [Optional] The hash of the metadata for the IP NFT.
-     *   @param request.arg.recipient [Optional] The address of the recipient of the minted NFT,default value is your wallet address.
-     *  @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property, without encodedTxData option.
-     * @returns A Promise that resolves to a transaction hash, if waitForTransaction is true, return an array of containing IP ID and token ID, SPG NFT Contract.
-     * @emits IPRegistered (ipId, chainId, tokenContract, tokenId, name, uri, registrationDate)
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} event.
      */
     )
   }, {
@@ -6123,18 +6044,8 @@ var IPAssetClient = /*#__PURE__*/function () {
     }()
     /**
      * Mint an NFT from a SPGNFT collection and register it with metadata as an IP.
-     * @param request - The request object that contains all data needed to attach license terms.
-     *   @param request.spgNftContract The address of the SPGNFT collection.
-     *   @param request.recipient The address of the recipient of the minted NFT,default value is your wallet address.
-     *  @param request.allowDuplicates Set to true to allow minting an NFT with a duplicate metadata hash.
-     *   @param {Object} request.ipMetadata - [Optional] The desired metadata for the newly minted NFT and newly registered IP.
-     *     @param request.ipMetadata.ipMetadataURI [Optional] The URI of the metadata for the IP.
-     *     @param request.ipMetadata.ipMetadataHash [Optional] The hash of the metadata for the IP.
-     *     @param request.ipMetadata.nftMetadataURI [Optional] The URI of the metadata for the NFT.
-     *     @param request.ipMetadata.nftMetadataHash [Optional] The hash of the metadata for the IP NFT.
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to a transaction hash, and if encodedTxDataOnly is true, includes encoded transaction data, or if waitForTransaction is true, includes IP ID and Token ID.
-     * @emits IPRegistered (ipId, chainId, tokenContract, tokenId, name, uri, registrationDate)
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} event.
      */
     )
   }, {
@@ -6148,8 +6059,8 @@ var IPAssetClient = /*#__PURE__*/function () {
             case 0:
               _context13.prev = 0;
               _object5 = {
-                spgNftContract: getAddress$1(request.spgNftContract, "request.spgNftContract"),
-                recipient: request.recipient && getAddress$1(request.recipient, "request.recipient") || this.wallet.account.address,
+                spgNftContract: validateAddress(request.spgNftContract),
+                recipient: validateAddress(request.recipient || this.walletAddress),
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata),
                 allowDuplicates: request.allowDuplicates || true
               };
@@ -6192,8 +6103,8 @@ var IPAssetClient = /*#__PURE__*/function () {
     }()
     /**
      * Register Programmable IP License Terms (if unregistered) and attach it to IP.
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicensingModule.sol#L19 | ILicensingModule}
-     * for a list of on-chain events emitted when a license terms is attached to an IP.
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicensingModule.sol#L19 | `LicenseTermsAttached`} event.
      */
     )
   }, {
@@ -6241,14 +6152,14 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: chain[this.chainId],
                 permissions: [{
                   ipId: ipId,
-                  signer: getAddress$1(this.licenseAttachmentWorkflowsClient.address, "licenseAttachmentWorkflowsClient"),
-                  to: getAddress$1(this.licensingModuleClient.address, "licensingModuleAddress"),
+                  signer: validateAddress(this.licenseAttachmentWorkflowsClient.address),
+                  to: validateAddress(this.licensingModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(licensingModuleAbi, "attachLicenseTerms")
                 }, {
                   ipId: ipId,
-                  signer: getAddress$1(this.licenseAttachmentWorkflowsClient.address, "licenseAttachmentWorkflowsClient"),
-                  to: getAddress$1(this.licensingModuleClient.address, "licensingModuleAddress"),
+                  signer: this.licenseAttachmentWorkflowsClient.address,
+                  to: this.licensingModuleClient.address,
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(licensingModuleAbi, "setLicensingConfig")
                 }]
@@ -6260,7 +6171,7 @@ var IPAssetClient = /*#__PURE__*/function () {
                 ipId: ipId,
                 licenseTermsData: licenseTermsData,
                 sigAttachAndConfig: {
-                  signer: getAddress$1(this.wallet.account.address, "wallet.account.address"),
+                  signer: validateAddress(this.walletAddress),
                   deadline: calculatedDeadline,
                   signature: signature
                 }
@@ -6317,22 +6228,10 @@ var IPAssetClient = /*#__PURE__*/function () {
       return registerPilTermsAndAttach;
     }()
     /**
-     *  Mint an NFT from a collection and register it as a derivative IP using license tokens
+     * Mint an NFT from a collection and register it as a derivative IP using license tokens.
      * Requires caller to have the minter role or the SPG NFT to allow public minting. Caller must own the license tokens and have approved DerivativeWorkflows to transfer them.
-     * @param request - The request object that contains all data needed to mint and register ip and make derivative with license tokens.
-     *   @param request.spgNftContract The address of the NFT collection.
-     *   @param {Array} request.licenseTokenIds The IDs of the license tokens to be burned for linking the IP to parent IPs.
-     *   @param request.allowDuplicates Set to true to allow minting an NFT with a duplicate metadata hash.
-     *   @param request.maxRts The maximum number of royalty tokens that can be distributed to the external royalty policies (max: 100,000,000).
-     *   @param {Object} request.ipMetadata - [Optional] The desired metadata for the newly minted NFT and newly registered IP.
-     *     @param request.ipMetadata.ipMetadataURI [Optional] The URI of the metadata for the IP.
-     *     @param request.ipMetadata.ipMetadataHash [Optional] The hash of the metadata for the IP.
-     *     @param request.ipMetadata.nftMetadataURI [Optional] The URI of the metadata for the NFT.
-     *     @param request.ipMetadata.nftMetadataHash [Optional] The hash of the metadata for the IP NFT.
-     *   @param request.recipient - [Optional] The address to receive the minted NFT,default value is your wallet address.
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to a transaction hash, and if encodedTxDataOnly is true, includes encoded transaction data, or if waitForTransaction is true, includes IP ID and Token ID.
-     * @emits IPRegistered (ipId, chainId, tokenContract, tokenId, name, uri, registrationDate)
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} event.
      */
     )
   }, {
@@ -6350,8 +6249,8 @@ var IPAssetClient = /*#__PURE__*/function () {
             case 3:
               licenseTokenIds = _context16.sent;
               _object7 = {
-                spgNftContract: getAddress$1(request.spgNftContract, "request.spgNftContract"),
-                recipient: request.recipient && getAddress$1(request.recipient, "request.recipient") || this.walletAddress,
+                spgNftContract: validateAddress(request.spgNftContract),
+                recipient: validateAddress(request.recipient || this.walletAddress),
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata),
                 licenseTokenIds: licenseTokenIds,
                 royaltyContext: zeroAddress,
@@ -6414,18 +6313,8 @@ var IPAssetClient = /*#__PURE__*/function () {
     }()
     /**
      * Register the given NFT as a derivative IP using license tokens.
-     * @param request - The request object that contains all data needed to register ip and make derivative with license tokens.
-     *   @param request.nftContract The address of the NFT collection.
-     *   @param {Array} request.licenseTokenIds The IDs of the license tokens to be burned for linking the IP to parent IPs.
-     *   @param request.tokenId The ID of the NFT.
-     *   @param {Object} request.ipMetadata - [Optional] The desired metadata for the newly minted NFT and newly registered IP.
-     *     @param request.ipMetadata.ipMetadataURI [Optional] The URI of the metadata for the IP.
-     *     @param request.ipMetadata.ipMetadataHash [Optional] The hash of the metadata for the IP.
-     *     @param request.ipMetadata.nftMetadataURI [Optional] The URI of the metadata for the NFT.
-     *     @param request.ipMetadata.nftMetadataHash [Optional] The hash of the metadata for the IP NFT.
-     *   @param request.deadline [Optional] The deadline for the signature in seconds, default is 1000s.
-     *   @param request.txOptions [Optional] This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to a transaction hash, and if encodedTxDataOnly is true, includes encoded transaction data, or if waitForTransaction is true, includes IP ID, Token ID.
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} event.
      */
     )
   }, {
@@ -6471,14 +6360,14 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: chain[this.chainId],
                 permissions: [{
                   ipId: ipIdAddress,
-                  signer: getAddress$1(this.derivativeWorkflowsClient.address, "derivativeWorkflowsClient"),
-                  to: getAddress$1(this.coreMetadataModuleClient.address, "coreMetadataModuleAddress"),
+                  signer: validateAddress(this.derivativeWorkflowsClient.address),
+                  to: validateAddress(this.coreMetadataModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(coreMetadataModuleAbi, "setAll")
                 }, {
                   ipId: ipIdAddress,
                   signer: this.derivativeWorkflowsClient.address,
-                  to: getAddress$1(this.licensingModuleClient.address, "licensingModuleClient"),
+                  to: validateAddress(this.licensingModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(licensingModuleAbi, "registerDerivativeWithLicenseTokens")
                 }]
@@ -6492,7 +6381,7 @@ var IPAssetClient = /*#__PURE__*/function () {
                 royaltyContext: zeroAddress,
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata),
                 sigMetadataAndRegister: {
-                  signer: getAddress$1(this.wallet.account.address, "wallet.account.address"),
+                  signer: validateAddress(this.walletAddress),
                   deadline: calculatedDeadline,
                   signature: signature
                 },
@@ -6548,11 +6437,11 @@ var IPAssetClient = /*#__PURE__*/function () {
       return registerIpAndMakeDerivativeWithLicenseTokens;
     }()
     /**
-     * Register the given NFT and attach license terms and distribute royalty tokens. In order to successfully distribute royalty tokens, the first license terms attached to the IP must be
-     * a commercial license.
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | IIPAssetRegistry}
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/royalty/IRoyaltyModule.sol#L88 | IRoyaltyModule}
-     * for a list of on-chain events emitted when an IP is registered, license terms are attached to an IP, and royalty tokens are distributed.
+     * Register the given NFT and attach license terms and distribute royalty
+     * tokens. In order to successfully distribute royalty tokens, the first
+     * license terms attached to the IP must be a commercial license.
+     *
+     * Emits on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} and {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/royalty/IRoyaltyModule.sol#L88 | `IpRoyaltyVaultDeployed`} events.
      */
     )
   }, {
@@ -6576,7 +6465,7 @@ var IPAssetClient = /*#__PURE__*/function () {
             case 9:
               calculatedDeadline = _context18.sent;
               _context18.next = 12;
-              return this.getIpIdAddress(getAddress$1(request.nftContract, "request.nftContract"), request.tokenId);
+              return this.getIpIdAddress(validateAddress(request.nftContract), request.tokenId);
             case 12:
               ipIdAddress = _context18.sent;
               _context18.next = 15;
@@ -6600,14 +6489,14 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: chain[this.chainId],
                 permissions: [{
                   ipId: ipIdAddress,
-                  signer: getAddress$1(this.royaltyTokenDistributionWorkflowsClient.address, "royaltyTokenDistributionWorkflowsClient"),
-                  to: getAddress$1(this.coreMetadataModuleClient.address, "coreMetadataModuleAddress"),
+                  signer: validateAddress(this.royaltyTokenDistributionWorkflowsClient.address),
+                  to: validateAddress(this.coreMetadataModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(coreMetadataModuleAbi, "setAll")
                 }, {
                   ipId: ipIdAddress,
                   signer: this.royaltyTokenDistributionWorkflowsClient.address,
-                  to: getAddress$1(this.licensingModuleClient.address, "licensingModuleClient"),
+                  to: validateAddress(this.licensingModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(licensingModuleAbi, "attachLicenseTerms")
                 }, {
@@ -6628,7 +6517,7 @@ var IPAssetClient = /*#__PURE__*/function () {
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata),
                 licenseTermsData: licenseTermsData,
                 sigMetadataAndAttachAndConfig: {
-                  signer: getAddress$1(this.wallet.account.address, "wallet.account.address"),
+                  signer: validateAddress(this.walletAddress),
                   deadline: calculatedDeadline,
                   signature: signature
                 }
@@ -6692,9 +6581,8 @@ var IPAssetClient = /*#__PURE__*/function () {
     /**
      * Register the given NFT as a derivative IP and attach license terms and distribute royalty tokens.  In order to successfully distribute royalty tokens, the license terms attached to the IP must be
      * a commercial license.
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | IIPAssetRegistry}
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/royalty/IRoyaltyModule.sol#L88| IRoyaltyModule}
-     * for a list of on-chain events emitted when a derivative IP is registered, license terms are attached to an IP, and royalty tokens are distributed.
+     *
+     * Emits on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} and {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/royalty/IRoyaltyModule.sol#L88| `IpRoyaltyVaultDeployed`} events.
      */
     )
   }, {
@@ -6726,14 +6614,14 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: chain[this.chainId],
                 permissions: [{
                   ipId: ipIdAddress,
-                  signer: getAddress$1(this.royaltyTokenDistributionWorkflowsClient.address, "royaltyTokenDistributionWorkflowsClient"),
-                  to: getAddress$1(this.coreMetadataModuleClient.address, "coreMetadataModuleAddress"),
+                  signer: validateAddress(this.royaltyTokenDistributionWorkflowsClient.address),
+                  to: validateAddress(this.coreMetadataModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(coreMetadataModuleAbi, "setAll")
                 }, {
                   ipId: ipIdAddress,
                   signer: this.royaltyTokenDistributionWorkflowsClient.address,
-                  to: getAddress$1(this.licensingModuleClient.address, "licensingModuleAddress"),
+                  to: validateAddress(this.licensingModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(licensingModuleAbi, "registerDerivative")
                 }]
@@ -6844,9 +6732,8 @@ var IPAssetClient = /*#__PURE__*/function () {
     }()
     /**
      * Mint an NFT and register the IP, attach PIL terms, and distribute royalty tokens.
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | IIPAssetRegistry}
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/royalty/IRoyaltyModule.sol#L88| IRoyaltyModule}
-     * for a list of on-chain events emitted when an IP is minted and registered, PIL terms are attached to an IP, and royalty tokens are distributed.
+     *
+     * Emits on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} and {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/royalty/IRoyaltyModule.sol#L88| `IpRoyaltyVaultDeployed`} events.
      */
     )
   }, {
@@ -6867,8 +6754,8 @@ var IPAssetClient = /*#__PURE__*/function () {
               licenseTermsData = _yield$this$validateL5.licenseTermsData;
               _this$getRoyaltyShare3 = this.getRoyaltyShares(request.royaltyShares), royaltyShares = _this$getRoyaltyShare3.royaltyShares;
               _object10 = {
-                spgNftContract: getAddress$1(request.spgNftContract, "request.spgNftContract"),
-                recipient: request.recipient && getAddress$1(request.recipient, "request.recipient") || this.walletAddress,
+                spgNftContract: validateAddress(request.spgNftContract),
+                recipient: validateAddress(request.recipient || this.walletAddress),
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata),
                 licenseTermsData: licenseTermsData,
                 royaltyShares: royaltyShares,
@@ -6931,8 +6818,8 @@ var IPAssetClient = /*#__PURE__*/function () {
     }()
     /**
      * Mint an NFT and register the IP, make a derivative, and distribute royalty tokens.
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | IIPAssetRegistry}
-     * for a list of on-chain events emitted when an IP is minted and registered, a derivative IP is made, and royalty tokens are distributed.
+     *
+     * Emits on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} event.
      */
     )
   }, {
@@ -6945,14 +6832,14 @@ var IPAssetClient = /*#__PURE__*/function () {
           while (1) switch (_context21.prev = _context21.next) {
             case 0:
               _context21.prev = 0;
-              nftRecipient = request.recipient && getAddress$1(request.recipient, "request.recipient") || this.walletAddress;
+              nftRecipient = validateAddress(request.recipient || this.walletAddress);
               _this$getRoyaltyShare4 = this.getRoyaltyShares(request.royaltyShares), royaltyShares = _this$getRoyaltyShare4.royaltyShares;
               _context21.next = 5;
               return this.validateDerivativeData(request.derivData);
             case 5:
               derivData = _context21.sent;
               _object11 = {
-                spgNftContract: getAddress$1(request.spgNftContract, "request.spgNftContract"),
+                spgNftContract: validateAddress(request.spgNftContract),
                 recipient: nftRecipient,
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata),
                 derivData: derivData,
@@ -7038,7 +6925,7 @@ var IPAssetClient = /*#__PURE__*/function () {
               }
               throw new Error("The balance of the IP account in the IP Royalty Vault is insufficient to distribute the royalty tokens.");
             case 7:
-              ipAccount = new IpAccountImplClient(this.rpcClient, this.wallet, getAddress$1(ipId, "arg.childIpId"));
+              ipAccount = new IpAccountImplClient(this.rpcClient, this.wallet, validateAddress(ipId));
               _context22.next = 10;
               return ipAccount.state();
             case 10:
@@ -7107,7 +6994,7 @@ var IPAssetClient = /*#__PURE__*/function () {
               _context23.next = 2;
               return this.ipAssetRegistryClient.ipId({
                 chainId: BigInt(chain[this.chainId]),
-                tokenContract: getAddress$1(nftContract, "nftContract"),
+                tokenContract: validateAddress(nftContract),
                 tokenId: BigInt(tokenId)
               });
             case 2:
@@ -7133,7 +7020,7 @@ var IPAssetClient = /*#__PURE__*/function () {
             case 0:
               _context24.next = 2;
               return this.ipAssetRegistryClient.isRegistered({
-                id: getAddress$1(ipId, "ipId")
+                id: validateAddress(ipId)
               });
             case 2:
               return _context24.abrupt("return", _context24.sent);
@@ -7316,54 +7203,54 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "validateDerivativeData",
     value: function () {
-      var _validateDerivativeData = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee28(derivativeData) {
-        var internalDerivativeData, i, parentId, isParentIpRegistered, isAttachedLicenseTerms, _yield$this$licenseRe, royaltyPercent;
+      var _validateDerivativeData = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee28(derivativeDataInput) {
+        var derivativeData, i, parentId, isParentIpRegistered, isAttachedLicenseTerms, _yield$this$licenseRe, royaltyPercent;
         return _regeneratorRuntime().wrap(function _callee28$(_context28) {
           while (1) switch (_context28.prev = _context28.next) {
             case 0:
-              internalDerivativeData = {
-                parentIpIds: derivativeData.parentIpIds,
-                licenseTermsIds: derivativeData.licenseTermsIds.map(function (id) {
+              derivativeData = {
+                parentIpIds: derivativeDataInput.parentIpIds,
+                licenseTermsIds: derivativeDataInput.licenseTermsIds.map(function (id) {
                   return BigInt(id);
                 }),
-                licenseTemplate: derivativeData.licenseTemplate && getAddress$1(derivativeData.licenseTemplate, "derivativeData.licenseTemplate") || this.licenseTemplateClient.address,
+                licenseTemplate: validateAddress(derivativeDataInput.licenseTemplate || this.licenseTemplateClient.address),
                 royaltyContext: zeroAddress,
-                maxMintingFee: BigInt(derivativeData.maxMintingFee || 0),
-                maxRts: Number(derivativeData.maxRts || MAX_ROYALTY_TOKEN),
-                maxRevenueShare: getRevenueShare(derivativeData.maxRevenueShare || 100, RevShareType.MAX_REVENUE_SHARE)
+                maxMintingFee: BigInt(derivativeDataInput.maxMintingFee || 0),
+                maxRts: Number(derivativeDataInput.maxRts || MAX_ROYALTY_TOKEN),
+                maxRevenueShare: getRevenueShare(derivativeDataInput.maxRevenueShare || 100, RevShareType.MAX_REVENUE_SHARE)
               };
-              if (!(internalDerivativeData.parentIpIds.length === 0)) {
+              if (!(derivativeData.parentIpIds.length === 0)) {
                 _context28.next = 3;
                 break;
               }
               throw new Error("The parent IP IDs must be provided.");
             case 3:
-              if (!(internalDerivativeData.licenseTermsIds.length === 0)) {
+              if (!(derivativeData.licenseTermsIds.length === 0)) {
                 _context28.next = 5;
                 break;
               }
               throw new Error("The license terms IDs must be provided.");
             case 5:
-              if (!(internalDerivativeData.parentIpIds.length !== internalDerivativeData.licenseTermsIds.length)) {
+              if (!(derivativeData.parentIpIds.length !== derivativeData.licenseTermsIds.length)) {
                 _context28.next = 7;
                 break;
               }
               throw new Error("The number of parent IP IDs must match the number of license terms IDs.");
             case 7:
-              if (!(internalDerivativeData.maxMintingFee < 0)) {
+              if (!(derivativeData.maxMintingFee < 0)) {
                 _context28.next = 9;
                 break;
               }
               throw new Error("The maxMintingFee must be greater than 0.");
             case 9:
-              this.validateMaxRts(internalDerivativeData.maxRts);
+              this.validateMaxRts(derivativeData.maxRts);
               i = 0;
             case 11:
-              if (!(i < internalDerivativeData.parentIpIds.length)) {
+              if (!(i < derivativeData.parentIpIds.length)) {
                 _context28.next = 32;
                 break;
               }
-              parentId = internalDerivativeData.parentIpIds[i];
+              parentId = derivativeData.parentIpIds[i];
               _context28.next = 15;
               return this.isRegistered(parentId);
             case 15:
@@ -7377,8 +7264,8 @@ var IPAssetClient = /*#__PURE__*/function () {
               _context28.next = 20;
               return this.licenseRegistryReadOnlyClient.hasIpAttachedLicenseTerms({
                 ipId: parentId,
-                licenseTemplate: internalDerivativeData.licenseTemplate,
-                licenseTermsId: internalDerivativeData.licenseTermsIds[i]
+                licenseTemplate: derivativeData.licenseTemplate,
+                licenseTermsId: derivativeData.licenseTermsIds[i]
               });
             case 20:
               isAttachedLicenseTerms = _context28.sent;
@@ -7386,28 +7273,28 @@ var IPAssetClient = /*#__PURE__*/function () {
                 _context28.next = 23;
                 break;
               }
-              throw new Error("License terms id ".concat(internalDerivativeData.licenseTermsIds[i], " must be attached to the parent ipId ").concat(internalDerivativeData.parentIpIds[i], " before registering derivative."));
+              throw new Error("License terms id ".concat(derivativeData.licenseTermsIds[i], " must be attached to the parent ipId ").concat(derivativeData.parentIpIds[i], " before registering derivative."));
             case 23:
               _context28.next = 25;
               return this.licenseRegistryReadOnlyClient.getRoyaltyPercent({
                 ipId: parentId,
-                licenseTemplate: internalDerivativeData.licenseTemplate,
-                licenseTermsId: internalDerivativeData.licenseTermsIds[i]
+                licenseTemplate: derivativeData.licenseTemplate,
+                licenseTermsId: derivativeData.licenseTermsIds[i]
               });
             case 25:
               _yield$this$licenseRe = _context28.sent;
               royaltyPercent = _yield$this$licenseRe.royaltyPercent;
-              if (!(internalDerivativeData.maxRevenueShare !== 0 && royaltyPercent > internalDerivativeData.maxRevenueShare)) {
+              if (!(derivativeData.maxRevenueShare !== 0 && royaltyPercent > derivativeData.maxRevenueShare)) {
                 _context28.next = 29;
                 break;
               }
-              throw new Error("The royalty percent for the parent IP with id ".concat(parentId, " is greater than the maximum revenue share ").concat(internalDerivativeData.maxRevenueShare, "."));
+              throw new Error("The royalty percent for the parent IP with id ".concat(parentId, " is greater than the maximum revenue share ").concat(derivativeData.maxRevenueShare, "."));
             case 29:
               i++;
               _context28.next = 11;
               break;
             case 32:
-              return _context28.abrupt("return", internalDerivativeData);
+              return _context28.abrupt("return", derivativeData);
             case 33:
             case "end":
               return _context28.stop();
@@ -7509,13 +7396,17 @@ var IPAssetClient = /*#__PURE__*/function () {
               }
               _context30.next = 15;
               return calculateLicenseWipMintFee({
-                multicall3Client: this.multicall3Client,
-                licenseTemplateClient: this.licenseTemplateClient,
-                licensingModuleClient: this.licensingModuleClient,
-                parentIpId: derivData.parentIpIds[i],
-                licenseTermsId: derivData.licenseTermsIds[i],
-                receiver: sender,
-                amount: 1n
+                predictMintingFeeRequest: {
+                  licensorIpId: derivData.parentIpIds[i],
+                  licenseTemplate: derivData.licenseTemplate,
+                  licenseTermsId: derivData.licenseTermsIds[i],
+                  receiver: sender,
+                  amount: 1n,
+                  royaltyContext: zeroAddress
+                },
+                rpcClient: this.rpcClient,
+                chainId: this.chainId,
+                walletAddress: this.walletAddress
               });
             case 15:
               derivativeMintingFee = _context30.sent;
@@ -7600,24 +7491,13 @@ var PermissionClient = /*#__PURE__*/function () {
   }
 
   /**
-   * Sets the permission for a specific function call
+   * Sets the permission for a specific function call.
    * Each policy is represented as a mapping from an IP account address to a signer address to a recipient
-   * address to a function selector to a permission level. The permission level can be 0 (ABSTAIN), 1 (ALLOW), or
-   * 2 (DENY).
-   * By default, all policies are set to 0 (ABSTAIN), which means that the permission is not set.
+   * address to a function selector to a permission level. The permission level is an enum of `AccessPermission`.
+   * By default, all policies are set to ABSTAIN, which means that the permission is not set.
    * The owner of ipAccount by default has all permission.
-   * address(0) => wildcard
-   * bytes4(0) => wildcard
-   * Specific permission overrides wildcard permission.
-   * @param request - The request object containing necessary data to set `permission`.
-   *   @param request.ipId The IP ID 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.permission The new permission level.
-   *   @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.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-   * @returns A Promise that resolves to an object containing the transaction hash.
-   * @emits PermissionSet (ipAccountOwner, ipAccount, signer, to, func, permission)
+   *
+   * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/access/IAccessController.sol#L13 | `PermissionSet`} event.
    */
   return _createClass(PermissionClient, [{
     key: "setPermission",
@@ -7687,16 +7567,8 @@ var PermissionClient = /*#__PURE__*/function () {
     }()
     /**
      * Specific permission overrides wildcard permission with signature.
-     * @param request - The request object containing necessary data to set permissions.
-     *   @param request.ipId The IP ID 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.permission The new permission level.
-     *   @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.deadline [Optional] The deadline for the signature in seconds, default is 1000s.
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to an object containing the transaction hash.
-     * @emits PermissionSet (ipAccountOwner, ipAccount, signer, to, func, permission)
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/access/IAccessController.sol#L13 | `PermissionSet`} event.
      */
     )
   }, {
@@ -7716,7 +7588,7 @@ var PermissionClient = /*#__PURE__*/function () {
               data = encodeFunctionData({
                 abi: accessControllerAbi,
                 functionName: "setTransientPermission",
-                args: [ipId, getAddress$1(signer, "request.signer"), getAddress$1(to, "request.to"), func ? toFunctionSelector(func) : defaultFunctionSelector, permission]
+                args: [ipId, validateAddress(signer), validateAddress(to), func ? toFunctionSelector(func) : defaultFunctionSelector, permission]
               });
               _context2.next = 8;
               return ipAccountClient.state();
@@ -7747,7 +7619,7 @@ var PermissionClient = /*#__PURE__*/function () {
               _yield$getPermissionS = _context2.sent;
               signature = _yield$getPermissionS.signature;
               req = {
-                to: getAddress$1(this.accessControllerClient.address, "accessControllerClientAddress"),
+                to: validateAddress(this.accessControllerClient.address),
                 value: BigInt(0),
                 data: data,
                 signer: signer,
@@ -7803,13 +7675,8 @@ var PermissionClient = /*#__PURE__*/function () {
     }()
     /**
      * Sets permission to a signer for all functions across all modules.
-     * @param request - The request object containing necessary data to set all permissions.
-     *   @param request.ipId The IP ID that grants the permission for `signer`
-     *   @param request.signer The address of the signer receiving the permissions.
-     *   @param request.permission The new permission.
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to an object containing the transaction hash
-     * @emits PermissionSet (ipAccountOwner, ipAccount, signer, to, func, permission)
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/access/IAccessController.sol#L13 | `PermissionSet`} event.
      */
     )
   }, {
@@ -7878,17 +7745,8 @@ var PermissionClient = /*#__PURE__*/function () {
     }()
     /**
      * Sets a batch of permissions in a single transaction.
-     * @param request - The request object containing necessary data to set all permissions.
-     * @param {Array} request.permissions - An array of `Permission` structure, each representing the permission to be set.
-     *   @param request.permissions[].ipId The IP ID that grants the permission for `signer`.
-     *   @param request.permissions[].signer The address that can call `to` on behalf of the `ipAccount`.
-     *   @param request.permissions[].to The address that can be called by the `signer` (currently only modules can be `to`).
-     *   @param request.permissions[].permission The new permission level.
-     *   @param request.permissions[].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.deadline [Optional] The deadline for the signature in milliseconds, default is 1000ms.
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to an object containing the transaction hash
-     * @emits PermissionSet (ipAccountOwner, ipAccount, signer, to, func, permission)
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/access/IAccessController.sol#L13 | `PermissionSet`} event.
      */
     )
   }, {
@@ -7987,18 +7845,8 @@ var PermissionClient = /*#__PURE__*/function () {
     }()
     /**
      * Sets a batch of permissions in a single transaction with signature.
-     * @param request - The request object containing necessary data to set permissions.
-     *   @param request.ipId The IP ID that grants the permission for `signer`
-     *   @param {Array} request.permissions - An array of `Permission` structure, each representing the permission to be set.
-     *   @param request.permissions[].ipId The IP ID that grants the permission for `signer`.
-     *   @param request.permissions[].signer The address that can call `to` on behalf of the `ipAccount`.
-     *   @param request.permissions[].to The address that can be called by the `signer` (currently only modules can be `to`).
-     *   @param request.permissions[].permission The new permission level.
-     *   @param request.permissions[].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.deadline [Optional] The deadline for the signature in seconds, default is 1000s.
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to an object containing the transaction hash.
-     * @emits PermissionSet (ipAccountOwner, ipAccount, signer, to, func, permission)
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/access/IAccessController.sol#L13 | `PermissionSet`} event.
      */
     )
   }, {
@@ -8074,10 +7922,10 @@ var PermissionClient = /*#__PURE__*/function () {
               _yield$getPermissionS2 = _context5.sent;
               signature = _yield$getPermissionS2.signature;
               req = {
-                to: getAddress$1(this.accessControllerClient.address, "accessControllerAddress"),
+                to: validateAddress(this.accessControllerClient.address),
                 value: BigInt(0),
                 data: data,
-                signer: getAddress$1(this.wallet.account.address, "walletAccountAddress"),
+                signer: validateAddress(this.wallet.account.address),
                 deadline: calculatedDeadline,
                 signature: signature
               };
@@ -8138,7 +7986,7 @@ var PermissionClient = /*#__PURE__*/function () {
             case 0:
               _context6.next = 2;
               return this.ipAssetRegistryClient.isRegistered({
-                id: getAddress$1(ipId, "ipId")
+                id: validateAddress(ipId)
               });
             case 2:
               isRegistered = _context6.sent;
@@ -8180,27 +8028,8 @@ var LicenseClient = /*#__PURE__*/function () {
   }
   /**
    * Registers new license terms and return the ID of the newly registered license terms.
-   * @param request - The request object that contains all data needed to register a license term.
-   *   @param request.transferable Indicates whether the license is transferable or not.
-   *   @param request.royaltyPolicy The address of the royalty policy contract which required to StoryProtocol in advance.
-   *   @param request.mintingFee The fee to be paid when minting a license.
-   *   @param request.expiration The expiration period of the license.
-   *   @param request.commercialUse Indicates whether the work can be used commercially or not.
-   *   @param request.commercialAttribution Whether attribution is required when reproducing the work commercially or not.
-   *   @param request.commercializerChecker Commercializers that are allowed to commercially exploit the work. If zero address, then no restrictions is enforced.
-   *   @param request.commercializerCheckerData The data to be passed to the commercializer checker contract.
-   *   @param request.commercialRevShare Percentage of revenue that must be shared with the licensor.
-   *   @param request.commercialRevCeiling The maximum revenue that can be generated from the commercial use of the work.
-   *   @param request.derivativesAllowed Indicates whether the licensee can create derivatives of his work or not.
-   *   @param request.derivativesAttribution Indicates whether attribution is required for derivatives of the work or not.
-   *   @param request.derivativesApproval Indicates whether the licensor must approve derivatives of the work before they can be linked to the licensor IP ID or not.
-   *   @param request.derivativesReciprocal Indicates whether the licensee must license derivatives of the work under the same terms or not.
-   *   @param request.derivativeRevCeiling The maximum revenue that can be generated from the derivative use of the work.
-   *   @param request.currency The ERC20 token to be used to pay the minting fee. the token must be registered in story protocol.
-   *   @param request.uri The URI of the license terms, which can be used to fetch the offchain license terms.
-   *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-   * @returns A Promise that resolves to a transaction hash, and if encodedTxDataOnly is true, includes encoded transaction data, and if waitForTransaction is true, includes license terms Id.
-   * @emits LicenseTermsRegistered (licenseTermsId, licenseTemplate, licenseTerms);
+   *
+   * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicenseTemplate.sol#L19 | `LicenseTermsRegistered`} event.
    */
   return _createClass(LicenseClient, [{
     key: "registerPILTerms",
@@ -8282,10 +8111,8 @@ var LicenseClient = /*#__PURE__*/function () {
     }()
     /**
      * Convenient function to register a PIL non commercial social remix license to the registry
-     * @param request - [Optional] The request object that contains all data needed to register a PIL non commercial social remix license.
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to a transaction hash, and if encodedTxDataOnly is true, includes encoded transaction data, and if waitForTransaction is true, includes license terms Id.
-     * @emits LicenseTermsRegistered (licenseTermsId, licenseTemplate, licenseTerms);
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicenseTemplate.sol#L19 | `LicenseTermsRegistered`} event.
      */
     )
   }, {
@@ -8365,13 +8192,8 @@ var LicenseClient = /*#__PURE__*/function () {
     }()
     /**
      * Convenient function to register a PIL commercial use license to the registry.
-     * @param request - The request object that contains all data needed to register a PIL commercial use license.
-     *   @param request.defaultMintingFee The fee to be paid when minting a license.
-     *   @param request.currency The ERC20 token to be used to pay the minting fee and the token must be registered in story protocol.
-     *   @param request.royaltyPolicyAddress [Optional] The address of the royalty policy contract, default value is LAP.
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to a transaction hash, and if encodedTxDataOnly is true, includes encoded transaction data, and if waitForTransaction is true, includes license terms Id.
-     * @emits LicenseTermsRegistered (licenseTermsId, licenseTemplate, licenseTerms);
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicenseTemplate.sol#L19 | `LicenseTermsRegistered`} event.
      */
     )
   }, {
@@ -8386,7 +8208,7 @@ var LicenseClient = /*#__PURE__*/function () {
               licenseTerms = getLicenseTermByType(PIL_TYPE.COMMERCIAL_USE, {
                 defaultMintingFee: request.defaultMintingFee,
                 currency: request.currency,
-                royaltyPolicyAddress: request.royaltyPolicyAddress && getAddress$1(request.royaltyPolicyAddress, "request.royaltyPolicyAddress") || royaltyPolicyLapAddress[chain[this.chainId]]
+                royaltyPolicyAddress: validateAddress(request.royaltyPolicyAddress || royaltyPolicyLapAddress[chain[this.chainId]])
               });
               _context3.next = 4;
               return this.getLicenseTermsId(licenseTerms);
@@ -8455,14 +8277,8 @@ var LicenseClient = /*#__PURE__*/function () {
     }()
     /**
      * Convenient function to register a PIL commercial Remix license to the registry.
-     * @param request - The request object that contains all data needed to register license.
-     *   @param request.defaultMintingFee The fee to be paid when minting a license.
-     *   @param request.commercialRevShare Percentage of revenue that must be shared with the licensor.
-     *   @param request.currency The ERC20 token to be used to pay the minting fee. the token must be registered in story protocol.
-     *   @param request.royaltyPolicyAddress [Optional] The address of the royalty policy contract, default value is LAP.
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to a transaction hash, and if encodedTxDataOnly is true, includes encoded transaction data, and if waitForTransaction is true, includes license terms Id.
-     * @emits LicenseTermsRegistered (licenseTermsId, licenseTemplate, licenseTerms);
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicenseTemplate.sol#L19 | `LicenseTermsRegistered`} event.
      */
     )
   }, {
@@ -8477,7 +8293,7 @@ var LicenseClient = /*#__PURE__*/function () {
               licenseTerms = getLicenseTermByType(PIL_TYPE.COMMERCIAL_REMIX, {
                 defaultMintingFee: request.defaultMintingFee,
                 currency: request.currency,
-                royaltyPolicyAddress: request.royaltyPolicyAddress && getAddress$1(request.royaltyPolicyAddress, "request.royaltyPolicyAddress") || royaltyPolicyLapAddress[chain[this.chainId]],
+                royaltyPolicyAddress: validateAddress(request.royaltyPolicyAddress || royaltyPolicyLapAddress[chain[this.chainId]]),
                 commercialRevShare: request.commercialRevShare
               });
               _context4.next = 4;
@@ -8547,13 +8363,6 @@ var LicenseClient = /*#__PURE__*/function () {
     }()
     /**
      * Attaches license terms to an IP.
-     * @param request - The request object that contains all data needed to attach license terms.
-     *   @param request.ipId The address of the IP to which the license terms are attached.
-     *   @param request.licenseTemplate The address of the license template, default value is Programmable IP License.
-     *   @param request.licenseTermsId The ID of the license terms.
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to a transaction hash, and if encodedTxDataOnly is true, includes encoded transaction data, and if waitForTransaction is true, includes success.
-     * If Ip have attached license terms, success will return false and txhash is empty.
      */
     )
   }, {
@@ -8568,7 +8377,7 @@ var LicenseClient = /*#__PURE__*/function () {
               request.licenseTermsId = BigInt(request.licenseTermsId);
               _context5.next = 4;
               return this.ipAssetRegistryClient.isRegistered({
-                id: getAddress$1(request.ipId, "request.ipId")
+                id: validateAddress(request.ipId)
               });
             case 4:
               isRegistered = _context5.sent;
@@ -8593,7 +8402,7 @@ var LicenseClient = /*#__PURE__*/function () {
               _context5.next = 14;
               return this.licenseRegistryReadOnlyClient.hasIpAttachedLicenseTerms({
                 ipId: request.ipId,
-                licenseTemplate: request.licenseTemplate && getAddress$1(request.licenseTemplate, "request.licenseTemplate") || this.licenseTemplateClient.address,
+                licenseTemplate: validateAddress(request.licenseTemplate || this.licenseTemplateClient.address),
                 licenseTermsId: request.licenseTermsId
               });
             case 14:
@@ -8661,27 +8470,18 @@ var LicenseClient = /*#__PURE__*/function () {
     }()
     /**
      * Mints license tokens for the license terms attached to an IP.
-     * The license tokens are minted to the receiver.
-     * The license terms must be attached to the IP before calling this function.
-     * But it can mint license token of default license terms without attaching the default license terms,
-     * since it is attached to all IPs by default.
-     * IP owners can mint license tokens for their IPs for arbitrary license terms
-     * without attaching the license terms to IP.
      * It might require the caller pay the minting fee, depending on the license terms or configured by the iP owner.
      * The minting fee is paid in the minting fee token specified in the license terms or configured by the IP owner.
-     * IP owners can configure the minting fee of their IPs or
-     * configure the minting fee module to determine the minting fee.
-     * @param request - The request object that contains all data needed to mint license tokens.
-     *   @param request.licensorIpId The licensor IP ID.
-     *   @param request.licenseTemplate The address of the license template, default value is Programmable IP License.
-     *   @param request.licenseTermsId The ID of the license terms within the license template.
-     *   @param request.amount The amount of license tokens to mint.
-     *   @param request.receiver The address of the receiver.
-     *   @param request.maxMintingFee The maximum minting fee that the caller is willing to pay. if set to 0 then no limit.
-     *   @param request.maxRevenueShare The maximum revenue share percentage allowed for minting the License Tokens. Must be between 0 and 100,000,000 (where 100,000,000 represents 100%).
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to a transaction hash, and if encodedTxDataOnly is true, includes encoded transaction data, and if waitForTransaction is true, includes license token IDs.
-     * @emits LicenseTokensMinted (msg.sender, licensorIpId, licenseTemplate, licenseTermsId, amount, receiver, startLicenseTokenId);
+     * IP owners can configure the minting fee of their IPs or configure the minting fee module to determine the minting fee.
+     *
+     * @remarks
+     * Before minting license tokens, the license terms must be attached to the IP, with two exceptions:
+     * 1. Default license terms can be minted without explicit attachment since they are automatically
+     *    attached to all IPs by default
+     * 2. IP owners have special privileges and can mint license tokens for their own IPs using any
+     *    license terms, even if those terms are not explicitly attached
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicensingModule.sol#L34 | `LicenseTokensMinted`} event.
      */
     )
   }, {
@@ -8689,15 +8489,15 @@ var LicenseClient = /*#__PURE__*/function () {
     value: (function () {
       var _mintLicenseTokens = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6(request) {
         var _this = this;
-        var _request$txOptions11, receiver, req, isLicenseIpIdRegistered, isExisted, isAttachedLicenseTerms, encodedTxData, licenseMintingFee, wipSpenders, _yield$contractCallWi, txHash, receipt, targetLogs, startLicenseTokenId, licenseTokenIds, i;
+        var _request$txOptions11, receiver, req, isLicenseIpIdRegistered, isExisted, ipAccount, ipOwner, isAttachedLicenseTerms, encodedTxData, licenseMintingFee, wipSpenders, _yield$contractCallWi, txHash, receipt, targetLogs, startLicenseTokenId, licenseTokenIds, i;
         return _regeneratorRuntime().wrap(function _callee6$(_context6) {
           while (1) switch (_context6.prev = _context6.next) {
             case 0:
               _context6.prev = 0;
-              receiver = request.receiver && getAddress$1(request.receiver, "request.receiver") || this.walletAddress;
+              receiver = validateAddress(request.receiver || this.walletAddress);
               req = {
-                licensorIpId: getAddress$1(request.licensorIpId, "request.licensorIpId"),
-                licenseTemplate: request.licenseTemplate && getAddress$1(request.licenseTemplate, "request.licenseTemplate") || this.licenseTemplateClient.address,
+                licensorIpId: validateAddress(request.licensorIpId),
+                licenseTemplate: validateAddress(request.licenseTemplate || this.licenseTemplateClient.address),
                 licenseTermsId: BigInt(request.licenseTermsId),
                 amount: BigInt(request.amount || 1),
                 receiver: receiver,
@@ -8713,7 +8513,7 @@ var LicenseClient = /*#__PURE__*/function () {
             case 5:
               _context6.next = 7;
               return this.ipAssetRegistryClient.isRegistered({
-                id: getAddress$1(request.licensorIpId, "request.licensorIpId")
+                id: validateAddress(request.licensorIpId)
               });
             case 7:
               isLicenseIpIdRegistered = _context6.sent;
@@ -8735,40 +8535,46 @@ var LicenseClient = /*#__PURE__*/function () {
               }
               throw new Error("License terms id ".concat(request.licenseTermsId, " do not exist."));
             case 15:
-              _context6.next = 17;
+              ipAccount = new IpAccountImplClient(this.rpcClient, this.wallet, req.licensorIpId);
+              _context6.next = 18;
+              return ipAccount.owner();
+            case 18:
+              ipOwner = _context6.sent;
+              if (!(ipOwner !== this.walletAddress)) {
+                _context6.next = 25;
+                break;
+              }
+              _context6.next = 22;
               return this.licenseRegistryReadOnlyClient.hasIpAttachedLicenseTerms({
-                ipId: request.licensorIpId,
-                licenseTemplate: request.licenseTemplate && getAddress$1(request.licenseTemplate, "request.licenseTemplate") || this.licenseTemplateClient.address,
+                ipId: req.licensorIpId,
+                licenseTemplate: validateAddress(req.licenseTemplate || this.licenseTemplateClient.address),
                 licenseTermsId: req.licenseTermsId
               });
-            case 17:
+            case 22:
               isAttachedLicenseTerms = _context6.sent;
               if (isAttachedLicenseTerms) {
-                _context6.next = 20;
+                _context6.next = 25;
                 break;
               }
-              throw new Error("License terms id ".concat(request.licenseTermsId, " is not attached to the IP with id ").concat(request.licensorIpId, "."));
-            case 20:
+              throw new Error("License terms id ".concat(req.licenseTermsId, " is not attached to the IP with id ").concat(req.licensorIpId, "."));
+            case 25:
               encodedTxData = this.licensingModuleClient.mintLicenseTokensEncode(req);
               if (!((_request$txOptions11 = request.txOptions) !== null && _request$txOptions11 !== void 0 && _request$txOptions11.encodedTxDataOnly)) {
-                _context6.next = 23;
+                _context6.next = 28;
                 break;
               }
               return _context6.abrupt("return", {
                 encodedTxData: encodedTxData
               });
-            case 23:
-              _context6.next = 25;
+            case 28:
+              _context6.next = 30;
               return calculateLicenseWipMintFee({
-                multicall3Client: this.multicall3Client,
-                licenseTemplateClient: this.licenseTemplateClient,
-                licensingModuleClient: this.licensingModuleClient,
-                parentIpId: req.licensorIpId,
-                licenseTermsId: req.licenseTermsId,
-                receiver: receiver,
-                amount: req.amount
+                predictMintingFeeRequest: req,
+                rpcClient: this.rpcClient,
+                chainId: this.chainId,
+                walletAddress: this.walletAddress
               });
-            case 25:
+            case 30:
               licenseMintingFee = _context6.sent;
               wipSpenders = [];
               if (licenseMintingFee > 0n) {
@@ -8777,7 +8583,7 @@ var LicenseClient = /*#__PURE__*/function () {
                   amount: licenseMintingFee
                 });
               }
-              _context6.next = 30;
+              _context6.next = 35;
               return contractCallWithFees({
                 totalFees: licenseMintingFee,
                 options: {
@@ -8794,18 +8600,18 @@ var LicenseClient = /*#__PURE__*/function () {
                 txOptions: request.txOptions,
                 encodedTxs: [encodedTxData]
               });
-            case 30:
+            case 35:
               _yield$contractCallWi = _context6.sent;
               txHash = _yield$contractCallWi.txHash;
               receipt = _yield$contractCallWi.receipt;
               if (receipt) {
-                _context6.next = 35;
+                _context6.next = 40;
                 break;
               }
               return _context6.abrupt("return", {
                 txHash: txHash
               });
-            case 35:
+            case 40:
               targetLogs = this.licensingModuleClient.parseTxLicenseTokensMintedEvent(receipt);
               startLicenseTokenId = targetLogs[0].startLicenseTokenId;
               licenseTokenIds = [];
@@ -8817,15 +8623,15 @@ var LicenseClient = /*#__PURE__*/function () {
                 licenseTokenIds: licenseTokenIds,
                 receipt: receipt
               });
-            case 42:
-              _context6.prev = 42;
+            case 47:
+              _context6.prev = 47;
               _context6.t0 = _context6["catch"](0);
               handleError(_context6.t0, "Failed to mint license tokens");
-            case 45:
+            case 50:
             case "end":
               return _context6.stop();
           }
-        }, _callee6, this, [[0, 42]]);
+        }, _callee6, this, [[0, 47]]);
       }));
       function mintLicenseTokens(_x6) {
         return _mintLicenseTokens.apply(this, arguments);
@@ -8834,8 +8640,6 @@ var LicenseClient = /*#__PURE__*/function () {
     }()
     /**
      * Gets license terms of the given ID.
-     * @param selectedLicenseTermsId The ID of the license terms.
-     * @returns A Promise that resolves to an object containing the PILTerms associate with the given ID.
      */
     )
   }, {
@@ -8869,20 +8673,12 @@ var LicenseClient = /*#__PURE__*/function () {
     }()
     /**
      * Pre-compute the minting license fee for the given IP and license terms. The function can be used to calculate the minting license fee before minting license tokens.
-     * @param request - The request object that contains all data needed to predict minting licenses fee.
-     *   @param request.licensorIpId The IP ID of the licensor.
-     *   @param request.licenseTermsId The ID of the license terms.
-     *   @param request.amount The amount of license tokens to mint.
-     *   @param request.licenseTemplate [Optional] The address of the license template, default value is Programmable IP License.
-     *   @param request.receiver [Optional] The address of the receiver,default value is your wallet address.
-     *   @param request.txOptions [Optional] This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to an object containing the currency token and token amount.
      */
     )
   }, {
     key: "predictMintingLicenseFee",
     value: (function () {
-      var _predictMintingLicenseFee = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee8(request) {
+      var _predictMintingLicenseFee2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee8(request) {
         var isLicenseIpIdRegistered, licenseTermsId, isExisted, object;
         return _regeneratorRuntime().wrap(function _callee8$(_context8) {
           while (1) switch (_context8.prev = _context8.next) {
@@ -8890,7 +8686,7 @@ var LicenseClient = /*#__PURE__*/function () {
               _context8.prev = 0;
               _context8.next = 3;
               return this.ipAssetRegistryClient.isRegistered({
-                id: getAddress$1(request.licensorIpId, "request.licensorIpId")
+                id: validateAddress(request.licensorIpId)
               });
             case 3:
               isLicenseIpIdRegistered = _context8.sent;
@@ -8914,14 +8710,19 @@ var LicenseClient = /*#__PURE__*/function () {
               throw new Error("License terms id ".concat(request.licenseTermsId, " do not exist."));
             case 12:
               object = _objectSpread2(_objectSpread2({}, request), {}, {
-                receiver: request.receiver && getAddress$1(request.receiver, "request.receiver") || this.wallet.account.address,
+                receiver: validateAddress(request.receiver || this.walletAddress),
                 amount: BigInt(request.amount),
                 royaltyContext: zeroAddress,
-                licenseTemplate: request.licenseTemplate && getAddress$1(request.licenseTemplate, "request.licenseTemplate") || this.licenseTemplateClient.address,
+                licenseTemplate: validateAddress(request.licenseTemplate || this.licenseTemplateClient.address),
                 licenseTermsId: licenseTermsId
               });
               _context8.next = 15;
-              return this.licensingModuleClient.predictMintingLicenseFee(object);
+              return predictMintingLicenseFee({
+                predictMintingFeeRequest: object,
+                rpcClient: this.rpcClient,
+                chainId: this.chainId,
+                walletAddress: this.walletAddress
+              });
             case 15:
               return _context8.abrupt("return", _context8.sent);
             case 18:
@@ -8934,10 +8735,10 @@ var LicenseClient = /*#__PURE__*/function () {
           }
         }, _callee8, this, [[0, 18]]);
       }));
-      function predictMintingLicenseFee(_x8) {
-        return _predictMintingLicenseFee.apply(this, arguments);
+      function predictMintingLicenseFee$1(_x8) {
+        return _predictMintingLicenseFee2.apply(this, arguments);
       }
-      return predictMintingLicenseFee;
+      return predictMintingLicenseFee$1;
     }()
     /**
      * Sets the licensing configuration for a specific license terms of an IP. If both licenseTemplate and licenseTermsId are not specified then the licensing config apply to all licenses of given IP.
@@ -9151,6 +8952,10 @@ var convertHashIPFStoCID = function convertHashIPFStoCID(hash) {
   }
 };
 
+/**
+ * The ABI for the OptimisticOracleV3 contract. Contract address may be changed.
+ * @see https://aeneid.storyscan.io/address/0xABac6a158431edED06EE6cba37eDE8779F599eE4?tab=contract_abi
+ */
 var ASSERTION_ABI = [{
   inputs: [{
     internalType: "bytes32",
@@ -9245,6 +9050,20 @@ var ASSERTION_ABI = [{
   outputs: [],
   stateMutability: "nonpayable",
   type: "function"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "currency",
+    type: "address"
+  }],
+  name: "getMinimumBond",
+  outputs: [{
+    internalType: "uint256",
+    name: "",
+    type: "uint256"
+  }],
+  stateMutability: "view",
+  type: "function"
 }];
 
 var getOov3Contract = /*#__PURE__*/function () {
@@ -9297,6 +9116,35 @@ var getAssertionDetails = /*#__PURE__*/function () {
     return _ref2.apply(this, arguments);
   };
 }();
+var getMinimumBond = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(rpcClient, arbitrationPolicyUmaClient, currency) {
+    var oov3Contract;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.next = 2;
+          return getOov3Contract(arbitrationPolicyUmaClient);
+        case 2:
+          oov3Contract = _context3.sent;
+          _context3.next = 5;
+          return rpcClient.readContract({
+            address: oov3Contract,
+            abi: ASSERTION_ABI,
+            functionName: "getMinimumBond",
+            args: [currency]
+          });
+        case 5:
+          return _context3.abrupt("return", _context3.sent);
+        case 6:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return function getMinimumBond(_x5, _x6, _x7) {
+    return _ref3.apply(this, arguments);
+  };
+}();
 
 var DisputeClient = /*#__PURE__*/function () {
   function DisputeClient(rpcClient, wallet, chainId) {
@@ -9313,53 +9161,51 @@ var DisputeClient = /*#__PURE__*/function () {
   /**
    * Raises a dispute on a given ipId.
    *
-   * Submits a {@link DisputeRaised} event.
-   * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/dispute/IDisputeModule.sol#L64 | IDisputeModule.sol}
-   * for a list of on-chain events emitted when a dispute is raised.
-   *
-   * @remarks `WipOptions.useMulticallWhenPossible` is disabled for this function due to disputeInitiator issue. It will be executed sequentially with several transactions.
+   * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/dispute/IDisputeModule.sol#L64 | `DisputeRaised`} event.
    */
   return _createClass(DisputeClient, [{
     key: "raiseDispute",
     value: (function () {
       var _raiseDispute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
         var _this = this;
-        var _request$txOptions, liveness, bonds, tokenAddress, _yield$Promise$all, _yield$Promise$all2, minLiveness, maxLiveness, tag, maxBonds, data, _yield$this$disputeMo, isWhiteList, req, encodedTxData, contractCall, _yield$contractCallWi, txHash, receipt, targetLogs;
+        var _request$txOptions, liveness, _yield$Promise$all, _yield$Promise$all2, minLiveness, maxLiveness, _yield$Promise$all3, _yield$Promise$all4, minimumBond, maximumBond, bonds, tag, data, _yield$this$disputeMo, isWhiteList, req, encodedTxData, contractCall, _yield$contractCallWi, txHash, receipt, targetLogs;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               _context.prev = 0;
               liveness = BigInt(request.liveness);
-              bonds = BigInt(request.bond);
-              tokenAddress = wrappedIpAddress[chain[this.chainId]];
-              _context.next = 6;
+              _context.next = 4;
               return Promise.all([this.arbitrationPolicyUmaClient.minLiveness(), this.arbitrationPolicyUmaClient.maxLiveness()]);
-            case 6:
+            case 4:
               _yield$Promise$all = _context.sent;
               _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
               minLiveness = _yield$Promise$all2[0];
               maxLiveness = _yield$Promise$all2[1];
-              tag = stringToHex(request.targetTag, {
-                size: 32
-              });
               if (!(liveness < minLiveness || liveness > maxLiveness)) {
-                _context.next = 13;
+                _context.next = 10;
                 break;
               }
               throw new Error("Liveness must be between ".concat(minLiveness, " and ").concat(maxLiveness, "."));
-            case 13:
-              _context.next = 15;
-              return this.arbitrationPolicyUmaClient.maxBonds({
-                token: tokenAddress
-              });
-            case 15:
-              maxBonds = _context.sent;
-              if (!(bonds > maxBonds)) {
-                _context.next = 18;
+            case 10:
+              _context.next = 12;
+              return Promise.all([getMinimumBond(this.rpcClient, this.arbitrationPolicyUmaClient, WIP_TOKEN_ADDRESS), this.arbitrationPolicyUmaClient.maxBonds({
+                token: WIP_TOKEN_ADDRESS
+              })]);
+            case 12:
+              _yield$Promise$all3 = _context.sent;
+              _yield$Promise$all4 = _slicedToArray(_yield$Promise$all3, 2);
+              minimumBond = _yield$Promise$all4[0];
+              maximumBond = _yield$Promise$all4[1];
+              bonds = BigInt(request.bond || minimumBond);
+              if (!(bonds > maximumBond || bonds < minimumBond)) {
+                _context.next = 19;
                 break;
               }
-              throw new Error("Bonds must be less than ".concat(maxBonds, "."));
-            case 18:
+              throw new Error("Bonds must be between ".concat(minimumBond, " and ").concat(maximumBond, "."));
+            case 19:
+              tag = stringToHex(request.targetTag, {
+                size: 32
+              });
               data = encodeAbiParameters([{
                 name: "",
                 type: "uint64"
@@ -9369,20 +9215,20 @@ var DisputeClient = /*#__PURE__*/function () {
               }, {
                 name: "",
                 type: "uint256"
-              }], [liveness, tokenAddress, bonds]);
-              _context.next = 21;
+              }], [liveness, WIP_TOKEN_ADDRESS, bonds]);
+              _context.next = 23;
               return this.disputeModuleClient.isWhitelistedDisputeTag({
                 tag: tag
               });
-            case 21:
+            case 23:
               _yield$this$disputeMo = _context.sent;
               isWhiteList = _yield$this$disputeMo.allowed;
               if (isWhiteList) {
-                _context.next = 25;
+                _context.next = 27;
                 break;
               }
               throw new Error("The target tag ".concat(request.targetTag, " is not whitelisted."));
-            case 25:
+            case 27:
               req = {
                 targetIpId: validateAddress(request.targetIpId),
                 targetTag: tag,
@@ -9391,17 +9237,17 @@ var DisputeClient = /*#__PURE__*/function () {
               };
               encodedTxData = this.disputeModuleClient.raiseDisputeEncode(req);
               if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.encodedTxDataOnly)) {
-                _context.next = 31;
+                _context.next = 33;
                 break;
               }
               return _context.abrupt("return", {
                 encodedTxData: encodedTxData
               });
-            case 31:
+            case 33:
               contractCall = function contractCall() {
                 return _this.disputeModuleClient.raiseDispute(req);
               };
-              _context.next = 34;
+              _context.next = 36;
               return contractCallWithFees({
                 totalFees: bonds,
                 options: {
@@ -9422,35 +9268,35 @@ var DisputeClient = /*#__PURE__*/function () {
                 txOptions: request.txOptions,
                 sender: this.wallet.account.address
               });
-            case 34:
+            case 36:
               _yield$contractCallWi = _context.sent;
               txHash = _yield$contractCallWi.txHash;
               receipt = _yield$contractCallWi.receipt;
               if (receipt) {
-                _context.next = 39;
+                _context.next = 41;
                 break;
               }
               return _context.abrupt("return", {
                 txHash: txHash
               });
-            case 39:
+            case 41:
               targetLogs = this.disputeModuleClient.parseTxDisputeRaisedEvent(receipt);
               return _context.abrupt("return", {
                 txHash: txHash,
                 disputeId: targetLogs[0].disputeId
               });
-            case 41:
-              _context.next = 46;
-              break;
             case 43:
-              _context.prev = 43;
+              _context.next = 48;
+              break;
+            case 45:
+              _context.prev = 45;
               _context.t0 = _context["catch"](0);
               handleError(_context.t0, "Failed to raise dispute");
-            case 46:
+            case 48:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 43]]);
+        }, _callee, this, [[0, 45]]);
       }));
       function raiseDispute(_x) {
         return _raiseDispute.apply(this, arguments);
@@ -9459,16 +9305,8 @@ var DisputeClient = /*#__PURE__*/function () {
     }()
     /**
      * Cancels an ongoing dispute
-     * @param request - The request object containing details to cancel the dispute.
-     *   @param request.disputeId The ID of the dispute to be cancelled.
-     *   @param request.data [Optional] additional data used in the cancellation process.
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to a CancelDisputeResponse containing the transaction hash.
-     * @throws NotInDisputeState, if the currentTag of the Dispute is not being disputed
-     * @throws NotDisputeInitiator, if the transaction executor is not the one that initiated the dispute
-     * @throws error if the Dispute's ArbitrationPolicy contract is not valid
-     * @calls cancelDispute(uint256 _disputeId, bytes calldata _data) external nonReentrant {
-     * @emits DisputeCancelled (_disputeId, _data);
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/dispute/IDisputeModule.sol#L84 | `DisputeCancelled`} event.
      */
     )
   }, {
@@ -9527,29 +9365,23 @@ var DisputeClient = /*#__PURE__*/function () {
       return cancelDispute;
     }()
     /**
-     * Resolves a dispute after it has been judged
-     * @param request - The request object containing details to resolve the dispute.
-     *   @param request.disputeId The ID of the dispute to be resolved.
-     *   @param request.data The data to resolve the dispute.
-     *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns A Promise that resolves to a ResolveDisputeResponse.
-     * @throws NotAbleToResolve, if currentTag is still in dispute (i.e still needs a judgement to be set)
-     * @throws NotDisputeInitiator, if the transaction executor is not the one that initiated the dispute
-     * @emits DisputeResolved (_disputeId)
+     * Resolves a dispute after it has been judged.
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/dispute/IDisputeModule.sol#L104 | `DisputeResolved`} event.
      */
     )
   }, {
     key: "resolveDispute",
     value: (function () {
       var _resolveDispute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(request) {
-        var _request$txOptions4, _req2, _request$txOptions5, txHash;
+        var _request$data, _request$txOptions4, _req2, _request$txOptions5, txHash;
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
               _context3.prev = 0;
               _req2 = {
                 disputeId: BigInt(request.disputeId),
-                data: request.data
+                data: (_request$data = request.data) !== null && _request$data !== void 0 ? _request$data : "0x"
               };
               if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.encodedTxDataOnly)) {
                 _context3.next = 6;
@@ -9597,8 +9429,7 @@ var DisputeClient = /*#__PURE__*/function () {
      * Tags a derivative if a parent has been tagged with an infringement tag
      * or a group ip if a group member has been tagged with an infringement tag.
      *
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/dispute/IDisputeModule.sol#L93 | IDisputeModule.sol}
-     * for a list of on-chain events emitted when a derivative is tagged on an infringement.
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/dispute/IDisputeModule.sol#L93 | `IpTaggedOnRelatedIpInfringement`} event.
      */
     )
   }, {
@@ -9606,7 +9437,7 @@ var DisputeClient = /*#__PURE__*/function () {
     value: (function () {
       var _tagIfRelatedIpInfringed = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(request) {
         var _this2 = this;
-        var _request$options, objects, txHashes, calls, txHash;
+        var _request$options, objects, txHashes, calls, txHash, _iterator, _step, object, _txHash;
         return _regeneratorRuntime().wrap(function _callee4$(_context4) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
@@ -9636,17 +9467,39 @@ var DisputeClient = /*#__PURE__*/function () {
             case 7:
               txHash = _context4.sent;
               txHashes.push(txHash);
-              _context4.next = 14;
+              _context4.next = 30;
               break;
             case 11:
-              _context4.next = 13;
-              return Promise.all(objects.map(function (object) {
-                return _this2.disputeModuleClient.tagIfRelatedIpInfringed(object);
-              }));
-            case 13:
-              txHashes = _context4.sent;
+              _iterator = _createForOfIteratorHelper(objects);
+              _context4.prev = 12;
+              _iterator.s();
             case 14:
-              _context4.next = 16;
+              if ((_step = _iterator.n()).done) {
+                _context4.next = 22;
+                break;
+              }
+              object = _step.value;
+              _context4.next = 18;
+              return this.disputeModuleClient.tagIfRelatedIpInfringed(object);
+            case 18:
+              _txHash = _context4.sent;
+              txHashes.push(_txHash);
+            case 20:
+              _context4.next = 14;
+              break;
+            case 22:
+              _context4.next = 27;
+              break;
+            case 24:
+              _context4.prev = 24;
+              _context4.t0 = _context4["catch"](12);
+              _iterator.e(_context4.t0);
+            case 27:
+              _context4.prev = 27;
+              _iterator.f();
+              return _context4.finish(27);
+            case 30:
+              _context4.next = 32;
               return Promise.all(txHashes.map(function (txHash) {
                 return handleTxOptions({
                   txHash: txHash,
@@ -9654,17 +9507,17 @@ var DisputeClient = /*#__PURE__*/function () {
                   rpcClient: _this2.rpcClient
                 });
               }));
-            case 16:
+            case 32:
               return _context4.abrupt("return", _context4.sent);
-            case 19:
-              _context4.prev = 19;
-              _context4.t0 = _context4["catch"](0);
-              handleError(_context4.t0, "Failed to tag related ip infringed");
-            case 22:
+            case 35:
+              _context4.prev = 35;
+              _context4.t1 = _context4["catch"](0);
+              handleError(_context4.t1, "Failed to tag related ip infringed");
+            case 38:
             case "end":
               return _context4.stop();
           }
-        }, _callee4, this, [[0, 19]]);
+        }, _callee4, this, [[0, 35], [12, 24, 27, 30]]);
       }));
       function tagIfRelatedIpInfringed(_x4) {
         return _tagIfRelatedIpInfringed.apply(this, arguments);
@@ -9673,10 +9526,13 @@ var DisputeClient = /*#__PURE__*/function () {
     }()
     /**
      * Counters a dispute that was raised by another party on an IP using counter evidence.
+     * The counter evidence (e.g., documents, images) should be uploaded to IPFS,
+     * and its corresponding CID is converted to a hash for the request.
      *
-     * This method can only be called by the IP's owner to counter a dispute by providing
-     * counter evidence. The counter evidence (e.g., documents, images) should be
-     * uploaded to IPFS, and its corresponding CID is converted to a hash for the request.
+     * @remarks
+     *  The liveness period is split in two parts:
+     *  - the first part of the liveness period in which only the IP's owner can be called the method.
+     *  - a second part in which any address can be called the method.
      *
      * If you only have a `disputeId`, call {@link disputeIdToAssertionId} to get the `assertionId` needed here.
      */
@@ -9686,7 +9542,7 @@ var DisputeClient = /*#__PURE__*/function () {
     value: (function () {
       var _disputeAssertion = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(request) {
         var _this3 = this;
-        var ipAccount, bond, counterEvidenceHash, encodedData, _yield$this$wrappedIp, allowance, _txHash, contractCall, _yield$contractCallWi2, txHash, receipt;
+        var ipAccount, bond, counterEvidenceHash, encodedData, _yield$this$wrappedIp, allowance, _txHash2, contractCall, _yield$contractCallWi2, txHash, receipt;
         return _regeneratorRuntime().wrap(function _callee5$(_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
@@ -9719,10 +9575,10 @@ var DisputeClient = /*#__PURE__*/function () {
                 amount: maxUint256
               });
             case 14:
-              _txHash = _context5.sent;
+              _txHash2 = _context5.sent;
               _context5.next = 17;
               return this.rpcClient.waitForTransactionReceipt({
-                hash: _txHash
+                hash: _txHash2
               });
             case 17:
               contractCall = function contractCall() {
@@ -9848,15 +9704,8 @@ var IPAccountClient = /*#__PURE__*/function () {
     this.erc20Client = new Erc20Client(rpcClient, wallet);
   }
 
-  /** Executes a transaction from the IP Account.
-   * @param request - The request object containing necessary data to execute IP Account a transaction.
-   *   @param request.ipId The Ip Id to get ip account.
-   *   @param request.to The recipient of the transaction.
-   *   @param request.value The amount of Ether to send.
-   *   @param request.accountAddress The ipId to send.
-   *   @param request.data The data to send along with the transaction.
-   *   @param request.txOptions - [Optional] transaction. This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-   * @returns Tx hash for the transaction.
+  /**
+   * Executes a transaction from the IP Account.
    */
   return _createClass(IPAccountClient, [{
     key: "execute",
@@ -9867,7 +9716,7 @@ var IPAccountClient = /*#__PURE__*/function () {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               _context.prev = 0;
-              ipAccountClient = new IpAccountImplClient(this.rpcClient, this.wallet, getAddress$1(request.ipId, "request.ipId"));
+              ipAccountClient = new IpAccountImplClient(this.rpcClient, this.wallet, validateAddress(request.ipId));
               req = {
                 to: request.to,
                 value: BigInt(0),
@@ -9919,17 +9768,8 @@ var IPAccountClient = /*#__PURE__*/function () {
       }
       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.ipId The Ip Id to get ip account.
-     *   @param request.to The recipient of the transaction.
-     *   @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.
-     *   @param request.value [Optional] The amount of Ether to send.
-     *   @param request.txOptions [Optional] This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-     * @returns Tx hash for the transaction.
+    /**
+     * Executes a transaction from the IP Account with a signature.
      */
     )
   }, {
@@ -9941,12 +9781,12 @@ var IPAccountClient = /*#__PURE__*/function () {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
               _context2.prev = 0;
-              ipAccountClient = new IpAccountImplClient(this.rpcClient, this.wallet, getAddress$1(request.ipId, "request.ipId"));
+              ipAccountClient = new IpAccountImplClient(this.rpcClient, this.wallet, validateAddress(request.ipId));
               req = {
-                to: getAddress$1(request.to, "request.to"),
+                to: validateAddress(request.to),
                 value: BigInt(request.value || 0),
                 data: request.data,
-                signer: getAddress$1(request.signer, "request.signer"),
+                signer: validateAddress(request.signer),
                 deadline: BigInt(request.deadline),
                 signature: request.signature
               };
@@ -9992,9 +9832,8 @@ var IPAccountClient = /*#__PURE__*/function () {
       }
       return executeWithSig;
     }()
-    /** Returns the IPAccount's internal nonce for transaction ordering.
-     * @param ipId The IP ID
-     * @returns A Promise that resolves to the IP Account's nonce.
+    /**
+     * Returns the IPAccount's internal nonce for transaction ordering.
      */
     )
   }, {
@@ -10006,7 +9845,7 @@ var IPAccountClient = /*#__PURE__*/function () {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
               _context3.prev = 0;
-              ipAccount = new IpAccountImplClient(this.rpcClient, this.wallet, getAddress$1(ipId, "ipId"));
+              ipAccount = new IpAccountImplClient(this.rpcClient, this.wallet, validateAddress(ipId));
               _context3.next = 4;
               return ipAccount.state();
             case 4:
@@ -10030,7 +9869,6 @@ var IPAccountClient = /*#__PURE__*/function () {
     }()
     /**
      * Returns the identifier of the non-fungible token which owns the account
-     * @returns A Promise that resolves to an object containing the chain ID, token contract address, and token ID.
      */
     )
   }, {
@@ -10042,7 +9880,7 @@ var IPAccountClient = /*#__PURE__*/function () {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
               _context4.prev = 0;
-              ipAccount = new IpAccountImplClient(this.rpcClient, this.wallet, getAddress$1(ipId, "ipId"));
+              ipAccount = new IpAccountImplClient(this.rpcClient, this.wallet, validateAddress(ipId));
               _context4.next = 4;
               return ipAccount.token();
             case 4:
@@ -10187,6 +10025,8 @@ var IPAccountClient = /*#__PURE__*/function () {
   }]);
 }();
 
+/** The amount of revenue token claimable. */
+
 /**
  * Native royalty policy created by the Story team
  */
@@ -10227,9 +10067,14 @@ var RoyaltyClient = /*#__PURE__*/function () {
     this.walletAddress = wallet.account.address;
   }
   /**
-   * Claims all revenue from the child IPs of an ancestor IP, then transfer.
+   * Claims all revenue from the child IPs of an ancestor IP, then transfer
    * all claimed tokens to the wallet if the wallet owns the IP or is the claimer.
    * If claimed token is WIP, it will also be converted back to IP.
+   *
+   * @remarks
+   * Even if there are no child IPs, you must still populate {@link ClaimAllRevenueRequest.currencyTokens} with
+   * the token addresses you wish to claim. This is required for the claim operation to know which
+   * token balances to process.
    */
   return _createClass(RoyaltyClient, [{
     key: "claimAllRevenue",
@@ -10334,6 +10179,11 @@ var RoyaltyClient = /*#__PURE__*/function () {
      * if multicall is disabled, it will call @link{claimAllRevenue} for each ancestor IP.
      * Then transfer all claimed tokens to the wallet if the wallet owns the IP or is the claimer.
      * If claimed token is WIP, it will also be converted back to IP.
+     *
+     * @remarks
+     * Even if there are no child IPs, you must still populate `currencyTokens` in each ancestor IP
+     * with the token addresses you wish to claim. This is required for the claim operation to know which
+     * token balances to process.
      */
     )
   }, {
@@ -10666,11 +10516,7 @@ var RoyaltyClient = /*#__PURE__*/function () {
     }()
     /**
      * Get total amount of revenue token claimable by a royalty token holder.
-     * @param request - The request object that contains all data needed to claim Revenue.
-     *   @param request.royaltyVaultIpId The id of the royalty vault.
-     *   @param request.claimer The address of the royalty token holder
-     *   @param request.token The revenue token to claim.
-     * @returns A Promise that contains the amount of revenue token claimable
+     * Returns the amount of revenue token claimable by the claimer.
      */
     )
   }, {
@@ -10683,14 +10529,14 @@ var RoyaltyClient = /*#__PURE__*/function () {
             case 0:
               _context5.prev = 0;
               _context5.next = 3;
-              return this.getRoyaltyVaultAddress(getAddress$1(request.royaltyVaultIpId, "request.royaltyVaultIpId"));
+              return this.getRoyaltyVaultAddress(validateAddress(request.royaltyVaultIpId));
             case 3:
               proxyAddress = _context5.sent;
               ipRoyaltyVault = new IpRoyaltyVaultImplReadOnlyClient(this.rpcClient, proxyAddress);
               _context5.next = 7;
               return ipRoyaltyVault.claimableRevenue({
-                claimer: getAddress$1(request.claimer, "request.account"),
-                token: getAddress$1(request.token, "request.token")
+                claimer: validateAddress(request.claimer),
+                token: validateAddress(request.token)
               });
             case 7:
               return _context5.abrupt("return", _context5.sent);
@@ -10711,8 +10557,6 @@ var RoyaltyClient = /*#__PURE__*/function () {
     }()
     /**
      * Get the royalty vault proxy address of given royaltyVaultIpId.
-     * @param royaltyVaultIpId the id of the royalty vault.
-     * @returns A Promise that resolves to an object containing the royalty vault address.
      */
     )
   }, {
@@ -10725,7 +10569,7 @@ var RoyaltyClient = /*#__PURE__*/function () {
             case 0:
               _context6.next = 2;
               return this.ipAssetRegistryClient.isRegistered({
-                id: getAddress$1(royaltyVaultIpId, "royaltyVaultIpId")
+                id: validateAddress(royaltyVaultIpId)
               });
             case 2:
               isRoyaltyVaultIpIdRegistered = _context6.sent;
@@ -10960,21 +10804,9 @@ var NftClient = /*#__PURE__*/function () {
 
   /**
    * Creates a new SPG NFT Collection.
-   * @param request - The request object containing necessary data to create a SPG NFT Collection.
-   *   @param request.name - The name of the collection.
-   * 	 @param request.symbol - The symbol of the collection.
-   * 	 @param request.isPublicMinting - If true, anyone can mint from the collection. If false, only the addresses with the minter role can mint.
-   * 	 @param request.mintOpen Whether the collection is open for minting on creation.
-   *   @param request.mintFeeRecipient - The address to receive mint fees.
-   *   @param request.contractURI - The contract URI for the collection. Follows ERC-7572 standard. See https://eips.ethereum.org/EIPS/eip-7572
-   * 	 @param request.baseURI - [Optional] The base URI for the collection. If baseURI is not empty, tokenURI will be either baseURI + token ID (if nftMetadataURI is empty) or baseURI + nftMetadataURI.
-   * 	 @param request.maxSupply - [Optional] The maximum supply of the collection.
-   * 	 @param request.mintFee - [Optional] The cost to mint a token.
-   * 	 @param request.mintFeeToken - [Optional] The token to mint.
-   * 	 @param request.owner - [Optional] The owner of the collection.
-   *   @param request.txOptions [Optional] This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-   * @returns A Promise that resolves to a transaction hash, and if encodedTxDataOnly is true, includes encoded transaction data, and if waitForTransaction is true, includes spg nft contract address.
-   * @emits CollectionCreated (spgNftContract);
+   *
+   * Emits an on-chain `CollectionCreated` event.
+   * @see {@link https://github.com/storyprotocol/protocol-periphery-v1/blob/v1.3.1/contracts/interfaces/workflows/IRegistrationWorkflows.sol#L12 | IRegistrationWorkflows}
    */
   return _createClass(NftClient, [{
     key: "createNFTCollection",
@@ -10999,8 +10831,8 @@ var NftClient = /*#__PURE__*/function () {
                   maxSupply: (_request$maxSupply = request.maxSupply) !== null && _request$maxSupply !== void 0 ? _request$maxSupply : Number(maxUint32),
                   mintFee: (_request$mintFee = request.mintFee) !== null && _request$mintFee !== void 0 ? _request$mintFee : 0n,
                   mintFeeToken: (_request$mintFeeToken = request.mintFeeToken) !== null && _request$mintFeeToken !== void 0 ? _request$mintFeeToken : zeroAddress,
-                  owner: request.owner && getAddress$1(request.owner, "request.owner") || this.wallet.account.address,
-                  mintFeeRecipient: getAddress$1(request.mintFeeRecipient, "request.mintFeeRecipient"),
+                  owner: validateAddress(request.owner || this.wallet.account.address),
+                  mintFeeRecipient: validateAddress(request.mintFeeRecipient),
                   mintOpen: request.mintOpen,
                   isPublicMinting: request.isPublicMinting,
                   contractURI: request.contractURI
@@ -11043,7 +10875,7 @@ var NftClient = /*#__PURE__*/function () {
             case 20:
               _context.prev = 20;
               _context.t0 = _context["catch"](0);
-              handleError(_context.t0, "Failed to create a SPG NFT collection");
+              handleError(_context.t0, "Failed to create an SPG NFT collection");
             case 23:
             case "end":
               return _context.stop();
@@ -11126,11 +10958,8 @@ var GroupClient = /*#__PURE__*/function () {
     this.royaltyModuleEventClient = new RoyaltyModuleEventClient(rpcClient);
   }
   /** Registers a Group IPA.
-   * @param request - The request object containing necessary data to register group.
-   *   @param request.groupPool The address specifying how royalty will be split amongst the pool of IPs in the group.
-   *   @param request.txOptions [Optional] This extends `WaitForTransactionReceiptParameters` from the Viem library, excluding the `hash` property.
-   * @returns A Promise that resolves to a transaction hash, and if encodedTxDataOnly is true, includes encoded transaction data, and if waitForTransaction is true, includes group id.
-   * @emits PGroupRegistered (groupId, groupPool);
+   *
+   * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/grouping/IGroupingModule.sol#L14 | `IPGroupRegistered`} event.
    */
   return _createClass(GroupClient, [{
     key: "registerGroup",
@@ -11142,7 +10971,7 @@ var GroupClient = /*#__PURE__*/function () {
             case 0:
               _context.prev = 0;
               object = {
-                groupPool: getAddress$1(request.groupPool, "request.groupPool")
+                groupPool: validateAddress(request.groupPool)
               };
               if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.encodedTxDataOnly)) {
                 _context.next = 6;
@@ -11194,8 +11023,8 @@ var GroupClient = /*#__PURE__*/function () {
       return registerGroup;
     }()
     /** Mint an NFT from a SPGNFT collection, register it with metadata as an IP, attach license terms to the registered IP, and add it to a group IP.
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | IIPAssetRegistry}
-     * for a list of on-chain events emitted when an IP is minted and registered, license terms are attached to an IP, and it is added to a group.
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} event.
      */
     )
   }, {
@@ -11210,7 +11039,7 @@ var GroupClient = /*#__PURE__*/function () {
               groupId = request.groupId, recipient = request.recipient, spgNftContract = request.spgNftContract, deadline = request.deadline;
               _context2.next = 4;
               return this.ipAssetRegistryClient.isRegistered({
-                id: getAddress$1(groupId, "groupId")
+                id: validateAddress(groupId)
               });
             case 4:
               isRegistered = _context2.sent;
@@ -11240,8 +11069,8 @@ var GroupClient = /*#__PURE__*/function () {
                 chainId: chain[this.chainId],
                 permissions: [{
                   ipId: groupId,
-                  signer: getAddress$1(this.groupingWorkflowsClient.address, "groupingWorkflowsClient"),
-                  to: getAddress$1(this.groupingModuleClient.address, "groupingModuleClient"),
+                  signer: validateAddress(this.groupingWorkflowsClient.address),
+                  to: validateAddress(this.groupingModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(groupingModuleAbi, "addIp")
                 }]
@@ -11251,13 +11080,13 @@ var GroupClient = /*#__PURE__*/function () {
               sigAddToGroupSignature = _yield$getPermissionS.signature;
               object = _objectSpread2(_objectSpread2({}, request), {}, {
                 allowDuplicates: request.allowDuplicates || true,
-                spgNftContract: getAddress$1(spgNftContract, "request.spgNftContract"),
-                recipient: recipient && getAddress$1(recipient, "request.recipient") || this.wallet.account.address,
+                spgNftContract: validateAddress(spgNftContract),
+                recipient: validateAddress(recipient || this.wallet.account.address),
                 maxAllowedRewardShare: BigInt(getRevenueShare(request.maxAllowedRewardShare, RevShareType.MAX_ALLOWED_REWARD_SHARE)),
                 licensesData: this.getLicenseData(request.licenseData),
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata),
                 sigAddToGroup: {
-                  signer: getAddress$1(this.wallet.account.address, "wallet.account.address"),
+                  signer: validateAddress(this.wallet.account.address),
                   deadline: calculatedDeadline,
                   signature: sigAddToGroupSignature
                 }
@@ -11313,8 +11142,8 @@ var GroupClient = /*#__PURE__*/function () {
       return mintAndRegisterIpAndAttachLicenseAndAddToGroup;
     }()
     /** Register an NFT as IP with metadata, attach license terms to the registered IP, and add it to a group IP.
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | IIPAssetRegistry}
-     * for a list of on-chain events emitted when an IP is registered, license terms are attached to an IP, and it is added to a group.
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} event.
      */
     )
   }, {
@@ -11329,14 +11158,14 @@ var GroupClient = /*#__PURE__*/function () {
               _context3.next = 3;
               return this.ipAssetRegistryClient.ipId({
                 chainId: BigInt(chain[this.chainId]),
-                tokenContract: getAddress$1(request.nftContract, "nftContract"),
+                tokenContract: validateAddress(request.nftContract),
                 tokenId: BigInt(request.tokenId)
               });
             case 3:
               ipIdAddress = _context3.sent;
               _context3.next = 6;
               return this.ipAssetRegistryClient.isRegistered({
-                id: getAddress$1(request.groupId, "request.groupId")
+                id: validateAddress(request.groupId)
               });
             case 6:
               isRegistered = _context3.sent;
@@ -11359,13 +11188,13 @@ var GroupClient = /*#__PURE__*/function () {
               calculatedDeadline = getDeadline(blockTimestamp, request.deadline);
               _context3.next = 20;
               return getPermissionSignature({
-                ipId: getAddress$1(request.groupId, "request.groupId"),
+                ipId: request.groupId,
                 deadline: calculatedDeadline,
                 state: state,
                 wallet: this.wallet,
                 chainId: chain[this.chainId],
                 permissions: [{
-                  ipId: getAddress$1(request.groupId, "request.groupId"),
+                  ipId: request.groupId,
                   signer: this.groupingWorkflowsClient.address,
                   to: this.groupingModuleClient.address,
                   permission: AccessPermission.ALLOW,
@@ -11387,19 +11216,19 @@ var GroupClient = /*#__PURE__*/function () {
                 permissions: [{
                   ipId: ipIdAddress,
                   signer: this.groupingWorkflowsClient.address,
-                  to: getAddress$1(this.coreMetadataModuleClient.address, "coreMetadataModuleAddress"),
+                  to: validateAddress(this.coreMetadataModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(coreMetadataModuleAbi, "setAll")
                 }, {
                   ipId: ipIdAddress,
                   signer: this.groupingWorkflowsClient.address,
-                  to: getAddress$1(this.licensingModuleClient.address, "licensingModuleAddress"),
+                  to: validateAddress(this.licensingModuleClient.address),
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(licensingModuleAbi, "attachLicenseTerms")
                 }, {
                   ipId: ipIdAddress,
                   signer: this.groupingWorkflowsClient.address,
-                  to: getAddress$1(this.licensingModuleClient.address, "licensingModuleAddress"),
+                  to: this.licensingModuleClient.address,
                   permission: AccessPermission.ALLOW,
                   func: getFunctionSignature(licensingModuleAbi, "setLicensingConfig")
                 }]
@@ -11408,19 +11237,19 @@ var GroupClient = /*#__PURE__*/function () {
               _yield$getPermissionS3 = _context3.sent;
               sigMetadataAndAttachSignature = _yield$getPermissionS3.signature;
               object = {
-                nftContract: getAddress$1(request.nftContract, "request.nftContract"),
+                nftContract: request.nftContract,
                 groupId: request.groupId,
                 licensesData: this.getLicenseData(request.licenseData),
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata),
                 tokenId: BigInt(request.tokenId),
                 maxAllowedRewardShare: BigInt(getRevenueShare(request.maxAllowedRewardShare, RevShareType.MAX_ALLOWED_REWARD_SHARE)),
                 sigAddToGroup: {
-                  signer: getAddress$1(this.wallet.account.address, "wallet.account.address"),
+                  signer: validateAddress(this.wallet.account.address),
                   deadline: calculatedDeadline,
                   signature: sigAddToGroupSignature
                 },
                 sigMetadataAndAttachAndConfig: {
-                  signer: getAddress$1(this.wallet.account.address, "wallet.account.address"),
+                  signer: this.wallet.account.address,
                   deadline: calculatedDeadline,
                   signature: sigMetadataAndAttachSignature
                 }
@@ -11473,8 +11302,8 @@ var GroupClient = /*#__PURE__*/function () {
       return registerIpAndAttachLicenseAndAddToGroup;
     }()
     /** Register a group IP with a group reward pool and attach license terms to the group IP.
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/grouping/IGroupingModule.sol#L14 | IGroupingModule}
-     * for a list of on-chain events emitted when a group IP is registered, license terms are attached to a group IP .
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/grouping/IGroupingModule.sol#L14 | `IPGroupRegistered`} event.
      */
     )
   }, {
@@ -11487,7 +11316,7 @@ var GroupClient = /*#__PURE__*/function () {
             case 0:
               _context4.prev = 0;
               object = {
-                groupPool: getAddress$1(request.groupPool, "request.groupPool"),
+                groupPool: validateAddress(request.groupPool),
                 licenseData: this.getLicenseData(request.licenseData)[0]
               };
               if (!((_request$txOptions7 = request.txOptions) !== null && _request$txOptions7 !== void 0 && _request$txOptions7.encodedTxDataOnly)) {
@@ -11537,8 +11366,8 @@ var GroupClient = /*#__PURE__*/function () {
       return registerGroupAndAttachLicense;
     }()
     /** Register a group IP with a group reward pool, attach license terms to the group IP, and add individual IPs to the group IP.
-     * @see {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/grouping/IGroupingModule.sol#L14 | IGroupingModule}
-     * for a list of on-chain events emitted when a group IP is registered, license terms are attached to a group IP, and individual IPs are added to a group.
+     *
+     * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/grouping/IGroupingModule.sol#L14 | `IPGroupRegistered`} event.
      */
     )
   }, {
@@ -11551,7 +11380,7 @@ var GroupClient = /*#__PURE__*/function () {
             case 0:
               _context5.prev = 0;
               object = {
-                groupPool: getAddress$1(request.groupPool, "request.groupPool"),
+                groupPool: validateAddress(request.groupPool),
                 ipIds: request.ipIds,
                 licenseData: this.getLicenseData(request.licenseData)[0],
                 maxAllowedRewardShare: BigInt(getRevenueShare(request.maxAllowedRewardShare))
@@ -11564,7 +11393,7 @@ var GroupClient = /*#__PURE__*/function () {
               }
               _context5.next = 6;
               return this.ipAssetRegistryClient.isRegistered({
-                id: getAddress$1(request.ipIds[i], "request.ipIds".concat(i))
+                id: validateAddress(request.ipIds[i])
               });
             case 6:
               isRegistered = _context5.sent;
@@ -11803,9 +11632,9 @@ var GroupClient = /*#__PURE__*/function () {
         throw new Error("License data is required.");
       }
       var licenseDataArray = isArray ? licenseData : [licenseData];
-      return licenseDataArray.map(function (item, index) {
+      return licenseDataArray.map(function (item) {
         return {
-          licenseTemplate: item.licenseTemplate && getAddress$1(item.licenseTemplate, "request.licenseData.licenseTemplate".concat(isArray ? "[".concat(index, "]") : "")) || _this2.licenseTemplateClient.address,
+          licenseTemplate: validateAddress(item.licenseTemplate || _this2.licenseTemplateClient.address),
           licenseTermsId: BigInt(item.licenseTermsId),
           licensingConfig: validateLicenseConfig(item.licensingConfig)
         };
@@ -12108,9 +11937,6 @@ if (typeof process !== "undefined") {
  * The StoryClient is the main entry point for the SDK.
  */
 var StoryClient = /*#__PURE__*/function () {
-  /**
-   * @param config - the configuration for the SDK client
-   */
   function StoryClient(config) {
     _classCallCheck(this, StoryClient);
     _defineProperty(this, "_ipAsset", null);
@@ -12123,7 +11949,7 @@ var StoryClient = /*#__PURE__*/function () {
     _defineProperty(this, "_group", null);
     _defineProperty(this, "_wip", null);
     this.config = _objectSpread2(_objectSpread2({}, config), {}, {
-      chainId: chain[config.chainId || "aeneid"]
+      chainId: chain[config.chainId || "1315"]
     });
     if (!this.config.transport) {
       throw new Error("transport is null, please pass in a valid RPC Provider URL as the transport.");
@@ -12150,9 +11976,8 @@ var StoryClient = /*#__PURE__*/function () {
       return this.config.chainId;
     }
     /**
-     * Factory method for creating a SDK client with a signer.
+     * Factory method for creating an SDK client with a signer.
      *
-     * @param config StoryClient - the configuration for a new SDK client
      */
   }, {
     key: "ipAsset",
@@ -12160,8 +11985,6 @@ var StoryClient = /*#__PURE__*/function () {
     /**
      * 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) {
@@ -12173,8 +11996,6 @@ var StoryClient = /*#__PURE__*/function () {
     /**
      * Getter for the permission client. The client is lazily created when
      * this method is called.
-     *
-     * @returns the PermissionClient instance
      */
   }, {
     key: "permission",
@@ -12188,8 +12009,6 @@ var StoryClient = /*#__PURE__*/function () {
     /**
      * Getter for the license client. The client is lazily created when
      * this method is called.
-     *
-     * @returns the LicenseClient instance
      */
   }, {
     key: "license",
@@ -12203,8 +12022,6 @@ var StoryClient = /*#__PURE__*/function () {
     /**
      * Getter for the dispute client. The client is lazily created when
      * this method is called.
-     *
-     * @returns the DisputeClient instance
      */
   }, {
     key: "dispute",
@@ -12218,8 +12035,6 @@ var StoryClient = /*#__PURE__*/function () {
     /**
      * Getter for the ip account client. The client is lazily created when
      * this method is called.
-     *
-     * @returns the IPAccountClient instance
      */
   }, {
     key: "ipAccount",
@@ -12233,8 +12048,6 @@ var StoryClient = /*#__PURE__*/function () {
     /**
      * Getter for the royalty client. The client is lazily created when
      * this method is called.
-     *
-     * @returns the RoyaltyClient instance
      */
   }, {
     key: "royalty",
@@ -12248,8 +12061,6 @@ var StoryClient = /*#__PURE__*/function () {
     /**
      * Getter for the NFT client. The client is lazily created when
      * this method is called.
-     *
-     * @returns the NftClient instance
      */
   }, {
     key: "nftClient",
@@ -12263,8 +12074,6 @@ var StoryClient = /*#__PURE__*/function () {
     /**
      * Getter for the group client. The client is lazily created when
      * this method is called.
-     *
-     * @returns the GroupClient instance
      */
   }, {
     key: "groupClient",
@@ -12343,9 +12152,7 @@ var StoryClient = /*#__PURE__*/function () {
     }
 
     /**
-     * Factory method for creating a SDK client with a signer.
-     *
-     * @param config WalletClientConfig - the configuration for a new SDK client
+     * Factory method for creating an SDK client with a signer.
      */
   }, {
     key: "newClientUseWallet",
@@ -12358,9 +12165,7 @@ var StoryClient = /*#__PURE__*/function () {
     }
 
     /**
-     * Factory method for creating a SDK client with a signer.
-     *
-     * @param config UseAccountStoryConfig - the configuration for a new SDK client
+     * Factory method for creating an SDK client with a signer.
      */
   }, {
     key: "newClientUseAccount",
@@ -12484,4 +12289,4 @@ var AIRelationship = /*#__PURE__*/function (AIRelationship) {
   return AIRelationship;
 }({});
 
-export { AIRelationship, AccessPermission, AddressZero, DisputeClient, GroupClient, HashZero, IPAccountClient, IPAssetClient, LicenseClient, NftClient, PIL_TYPE, PermissionClient, RoyaltyClient, StoryClient, StoryRelationship, WIP_TOKEN_ADDRESS, WipClient, aeneid, convertCIDtoHashIPFS, convertHashIPFStoCID, getPermissionSignature, getSignature, mainnet, royaltyPolicyLapAddress, royaltyPolicyLrpAddress };
+export { AIRelationship, AccessPermission, DisputeClient, GroupClient, IPAccountClient, IPAssetClient, LicenseClient, NativeRoyaltyPolicy, NftClient, PIL_TYPE, PermissionClient, RevShareType, RoyaltyClient, StoryClient, StoryRelationship, WIP_TOKEN_ADDRESS, WipClient, aeneid, convertCIDtoHashIPFS, convertHashIPFStoCID, getPermissionSignature, getSignature, mainnet, royaltyPolicyLapAddress, royaltyPolicyLrpAddress };