@story-protocol/core-sdk 1.0.0-rc.3 → 1.0.0-rc.4

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

@@ -4185,6 +4185,928 @@ var licenseRegistryAddress = {
   1513: "0x0c3D467537FAd845a78728CEdc3D9447338c5422"
 };
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// LicenseToken
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ *
+ */
+var licenseTokenAbi = [{
+  type: "constructor",
+  inputs: [],
+  stateMutability: "nonpayable"
+}, {
+  type: "error",
+  inputs: [{
+    name: "target",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "AddressEmptyCode"
+}, {
+  type: "error",
+  inputs: [{
+    name: "implementation",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "ERC1967InvalidImplementation"
+}, {
+  type: "error",
+  inputs: [],
+  name: "ERC1967NonPayable"
+}, {
+  type: "error",
+  inputs: [],
+  name: "ERC721EnumerableForbiddenBatchMint"
+}, {
+  type: "error",
+  inputs: [{
+    name: "sender",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }, {
+    name: "owner",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "ERC721IncorrectOwner"
+}, {
+  type: "error",
+  inputs: [{
+    name: "operator",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "ERC721InsufficientApproval"
+}, {
+  type: "error",
+  inputs: [{
+    name: "approver",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "ERC721InvalidApprover"
+}, {
+  type: "error",
+  inputs: [{
+    name: "operator",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "ERC721InvalidOperator"
+}, {
+  type: "error",
+  inputs: [{
+    name: "owner",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "ERC721InvalidOwner"
+}, {
+  type: "error",
+  inputs: [{
+    name: "receiver",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "ERC721InvalidReceiver"
+}, {
+  type: "error",
+  inputs: [{
+    name: "sender",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "ERC721InvalidSender"
+}, {
+  type: "error",
+  inputs: [{
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "ERC721NonexistentToken"
+}, {
+  type: "error",
+  inputs: [{
+    name: "owner",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "index",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "ERC721OutOfBoundsIndex"
+}, {
+  type: "error",
+  inputs: [],
+  name: "FailedInnerCall"
+}, {
+  type: "error",
+  inputs: [],
+  name: "Governance__InconsistentState"
+}, {
+  type: "error",
+  inputs: [],
+  name: "Governance__OnlyProtocolAdmin"
+}, {
+  type: "error",
+  inputs: [{
+    name: "interfaceName",
+    internalType: "string",
+    type: "string"
+  }],
+  name: "Governance__UnsupportedInterface"
+}, {
+  type: "error",
+  inputs: [],
+  name: "Governance__ZeroAddress"
+}, {
+  type: "error",
+  inputs: [],
+  name: "InvalidInitialization"
+}, {
+  type: "error",
+  inputs: [{
+    name: "licenseTemplate",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "anotherLicenseTemplate",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "LicenseToken__AllLicenseTokensMustFromSameLicenseTemplate"
+}, {
+  type: "error",
+  inputs: [],
+  name: "LicenseToken__CallerNotLicensingModule"
+}, {
+  type: "error",
+  inputs: [{
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }, {
+    name: "expiredAt",
+    internalType: "uint256",
+    type: "uint256"
+  }, {
+    name: "currentTimestamp",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "LicenseToken__LicenseTokenExpired"
+}, {
+  type: "error",
+  inputs: [{
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }, {
+    name: "iPowner",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "tokenOwner",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "LicenseToken__NotLicenseTokenOwner"
+}, {
+  type: "error",
+  inputs: [],
+  name: "LicenseToken__NotTransferable"
+}, {
+  type: "error",
+  inputs: [{
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "LicenseToken__RevokedLicense"
+}, {
+  type: "error",
+  inputs: [],
+  name: "LicenseToken__ZeroDisputeModule"
+}, {
+  type: "error",
+  inputs: [],
+  name: "LicenseToken__ZeroLicensingModule"
+}, {
+  type: "error",
+  inputs: [],
+  name: "NotInitializing"
+}, {
+  type: "error",
+  inputs: [{
+    name: "value",
+    internalType: "uint256",
+    type: "uint256"
+  }, {
+    name: "length",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "StringsInsufficientHexLength"
+}, {
+  type: "error",
+  inputs: [],
+  name: "UUPSUnauthorizedCallContext"
+}, {
+  type: "error",
+  inputs: [{
+    name: "slot",
+    internalType: "bytes32",
+    type: "bytes32"
+  }],
+  name: "UUPSUnsupportedProxiableUUID"
+}, {
+  type: "event",
+  anonymous: false,
+  inputs: [{
+    name: "owner",
+    internalType: "address",
+    type: "address",
+    indexed: true
+  }, {
+    name: "approved",
+    internalType: "address",
+    type: "address",
+    indexed: true
+  }, {
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256",
+    indexed: true
+  }],
+  name: "Approval"
+}, {
+  type: "event",
+  anonymous: false,
+  inputs: [{
+    name: "owner",
+    internalType: "address",
+    type: "address",
+    indexed: true
+  }, {
+    name: "operator",
+    internalType: "address",
+    type: "address",
+    indexed: true
+  }, {
+    name: "approved",
+    internalType: "bool",
+    type: "bool",
+    indexed: false
+  }],
+  name: "ApprovalForAll"
+}, {
+  type: "event",
+  anonymous: false,
+  inputs: [{
+    name: "_fromTokenId",
+    internalType: "uint256",
+    type: "uint256",
+    indexed: false
+  }, {
+    name: "_toTokenId",
+    internalType: "uint256",
+    type: "uint256",
+    indexed: false
+  }],
+  name: "BatchMetadataUpdate"
+}, {
+  type: "event",
+  anonymous: false,
+  inputs: [{
+    name: "newGovernance",
+    internalType: "address",
+    type: "address",
+    indexed: true
+  }],
+  name: "GovernanceUpdated"
+}, {
+  type: "event",
+  anonymous: false,
+  inputs: [{
+    name: "version",
+    internalType: "uint64",
+    type: "uint64",
+    indexed: false
+  }],
+  name: "Initialized"
+}, {
+  type: "event",
+  anonymous: false,
+  inputs: [{
+    name: "minter",
+    internalType: "address",
+    type: "address",
+    indexed: true
+  }, {
+    name: "receiver",
+    internalType: "address",
+    type: "address",
+    indexed: true
+  }, {
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256",
+    indexed: true
+  }],
+  name: "LicenseTokenMinted"
+}, {
+  type: "event",
+  anonymous: false,
+  inputs: [{
+    name: "from",
+    internalType: "address",
+    type: "address",
+    indexed: true
+  }, {
+    name: "to",
+    internalType: "address",
+    type: "address",
+    indexed: true
+  }, {
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256",
+    indexed: true
+  }],
+  name: "Transfer"
+}, {
+  type: "event",
+  anonymous: false,
+  inputs: [{
+    name: "implementation",
+    internalType: "address",
+    type: "address",
+    indexed: true
+  }],
+  name: "Upgraded"
+}, {
+  type: "function",
+  inputs: [],
+  name: "UPGRADE_INTERFACE_VERSION",
+  outputs: [{
+    name: "",
+    internalType: "string",
+    type: "string"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "to",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "approve",
+  outputs: [],
+  stateMutability: "nonpayable"
+}, {
+  type: "function",
+  inputs: [{
+    name: "owner",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "balanceOf",
+  outputs: [{
+    name: "",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "holder",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "tokenIds",
+    internalType: "uint256[]",
+    type: "uint256[]"
+  }],
+  name: "burnLicenseTokens",
+  outputs: [],
+  stateMutability: "nonpayable"
+}, {
+  type: "function",
+  inputs: [{
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "getApproved",
+  outputs: [{
+    name: "",
+    internalType: "address",
+    type: "address"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "getExpirationTime",
+  outputs: [{
+    name: "",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [],
+  name: "getGovernance",
+  outputs: [{
+    name: "",
+    internalType: "address",
+    type: "address"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "getLicenseTemplate",
+  outputs: [{
+    name: "",
+    internalType: "address",
+    type: "address"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "getLicenseTermsId",
+  outputs: [{
+    name: "",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "getLicenseTokenMetadata",
+  outputs: [{
+    name: "",
+    internalType: "struct ILicenseToken.LicenseTokenMetadata",
+    type: "tuple",
+    components: [{
+      name: "licensorIpId",
+      internalType: "address",
+      type: "address"
+    }, {
+      name: "licenseTemplate",
+      internalType: "address",
+      type: "address"
+    }, {
+      name: "licenseTermsId",
+      internalType: "uint256",
+      type: "uint256"
+    }, {
+      name: "transferable",
+      internalType: "bool",
+      type: "bool"
+    }, {
+      name: "mintedAt",
+      internalType: "uint256",
+      type: "uint256"
+    }, {
+      name: "expiresAt",
+      internalType: "uint256",
+      type: "uint256"
+    }]
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "getLicensorIpId",
+  outputs: [{
+    name: "",
+    internalType: "address",
+    type: "address"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "governance",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "imageUrl",
+    internalType: "string",
+    type: "string"
+  }],
+  name: "initialize",
+  outputs: [],
+  stateMutability: "nonpayable"
+}, {
+  type: "function",
+  inputs: [{
+    name: "owner",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "operator",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "isApprovedForAll",
+  outputs: [{
+    name: "",
+    internalType: "bool",
+    type: "bool"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "isLicenseTokenRevoked",
+  outputs: [{
+    name: "",
+    internalType: "bool",
+    type: "bool"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [],
+  name: "licensingModule",
+  outputs: [{
+    name: "",
+    internalType: "contract ILicensingModule",
+    type: "address"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "licensorIpId",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "licenseTemplate",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "licenseTermsId",
+    internalType: "uint256",
+    type: "uint256"
+  }, {
+    name: "amount",
+    internalType: "uint256",
+    type: "uint256"
+  }, {
+    name: "minter",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "receiver",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "mintLicenseTokens",
+  outputs: [{
+    name: "startLicenseTokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  stateMutability: "nonpayable"
+}, {
+  type: "function",
+  inputs: [],
+  name: "name",
+  outputs: [{
+    name: "",
+    internalType: "string",
+    type: "string"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "ownerOf",
+  outputs: [{
+    name: "",
+    internalType: "address",
+    type: "address"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [],
+  name: "proxiableUUID",
+  outputs: [{
+    name: "",
+    internalType: "bytes32",
+    type: "bytes32"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "from",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "to",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "safeTransferFrom",
+  outputs: [],
+  stateMutability: "nonpayable"
+}, {
+  type: "function",
+  inputs: [{
+    name: "from",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "to",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }, {
+    name: "data",
+    internalType: "bytes",
+    type: "bytes"
+  }],
+  name: "safeTransferFrom",
+  outputs: [],
+  stateMutability: "nonpayable"
+}, {
+  type: "function",
+  inputs: [{
+    name: "operator",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "approved",
+    internalType: "bool",
+    type: "bool"
+  }],
+  name: "setApprovalForAll",
+  outputs: [],
+  stateMutability: "nonpayable"
+}, {
+  type: "function",
+  inputs: [{
+    name: "newDisputeModule",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "setDisputeModule",
+  outputs: [],
+  stateMutability: "nonpayable"
+}, {
+  type: "function",
+  inputs: [{
+    name: "newGovernance",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "setGovernance",
+  outputs: [],
+  stateMutability: "nonpayable"
+}, {
+  type: "function",
+  inputs: [{
+    name: "url",
+    internalType: "string",
+    type: "string"
+  }],
+  name: "setLicensingImageUrl",
+  outputs: [],
+  stateMutability: "nonpayable"
+}, {
+  type: "function",
+  inputs: [{
+    name: "newLicensingModule",
+    internalType: "address",
+    type: "address"
+  }],
+  name: "setLicensingModule",
+  outputs: [],
+  stateMutability: "nonpayable"
+}, {
+  type: "function",
+  inputs: [{
+    name: "interfaceId",
+    internalType: "bytes4",
+    type: "bytes4"
+  }],
+  name: "supportsInterface",
+  outputs: [{
+    name: "",
+    internalType: "bool",
+    type: "bool"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [],
+  name: "symbol",
+  outputs: [{
+    name: "",
+    internalType: "string",
+    type: "string"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "index",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "tokenByIndex",
+  outputs: [{
+    name: "",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "owner",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "index",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "tokenOfOwnerByIndex",
+  outputs: [{
+    name: "",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "id",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "tokenURI",
+  outputs: [{
+    name: "",
+    internalType: "string",
+    type: "string"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [],
+  name: "totalMintedTokens",
+  outputs: [{
+    name: "",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [],
+  name: "totalSupply",
+  outputs: [{
+    name: "",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  stateMutability: "view"
+}, {
+  type: "function",
+  inputs: [{
+    name: "from",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "to",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "tokenId",
+    internalType: "uint256",
+    type: "uint256"
+  }],
+  name: "transferFrom",
+  outputs: [],
+  stateMutability: "nonpayable"
+}, {
+  type: "function",
+  inputs: [{
+    name: "newImplementation",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "data",
+    internalType: "bytes",
+    type: "bytes"
+  }],
+  name: "upgradeToAndCall",
+  outputs: [],
+  stateMutability: "payable"
+}, {
+  type: "function",
+  inputs: [{
+    name: "childIpId",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "childIpOwner",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "tokenIds",
+    internalType: "uint256[]",
+    type: "uint256[]"
+  }],
+  name: "validateLicenseTokensForDerivative",
+  outputs: [{
+    name: "licenseTemplate",
+    internalType: "address",
+    type: "address"
+  }, {
+    name: "licensorIpIds",
+    internalType: "address[]",
+    type: "address[]"
+  }, {
+    name: "licenseTermsIds",
+    internalType: "uint256[]",
+    type: "uint256[]"
+  }],
+  stateMutability: "view"
+}];
+
+/**
+ *
+ */
+var licenseTokenAddress = {
+  1513: "0xD40b7bCA204f96a346021e31c9ad54FF495226e7"
+};
+
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // LicensingModule
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -7304,6 +8226,14 @@ var IpAssetRegistryClient = /*#__PURE__*/function (_IpAssetRegistryReadO) {
 
 // Contract IpRoyaltyVaultImpl =============================================================
 
+/**
+ * IpRoyaltyVaultImplRevenueTokenClaimedEvent
+ *
+ * @param claimer address
+ * @param token address
+ * @param amount uint256
+ */
+
 /**
  * IpRoyaltyVaultImplRoyaltyTokensCollectedEvent
  *
@@ -7359,15 +8289,15 @@ var IpRoyaltyVaultImplEventClient = /*#__PURE__*/function () {
   }
 
   /**
-   * event RoyaltyTokensCollected for contract IpRoyaltyVaultImpl
+   * event RevenueTokenClaimed for contract IpRoyaltyVaultImpl
    */
   return _createClass(IpRoyaltyVaultImplEventClient, [{
-    key: "watchRoyaltyTokensCollectedEvent",
-    value: function watchRoyaltyTokensCollectedEvent(_onLogs6) {
+    key: "watchRevenueTokenClaimedEvent",
+    value: function watchRevenueTokenClaimedEvent(_onLogs6) {
       return this.rpcClient.watchContractEvent({
         abi: ipRoyaltyVaultImplAbi,
         address: this.address,
-        eventName: "RoyaltyTokensCollected",
+        eventName: "RevenueTokenClaimed",
         onLogs: function onLogs(evs) {
           evs.forEach(function (it) {
             return _onLogs6(it.transactionHash, it.args);
@@ -7377,11 +8307,11 @@ var IpRoyaltyVaultImplEventClient = /*#__PURE__*/function () {
     }
 
     /**
-     * parse tx receipt event RoyaltyTokensCollected for contract IpRoyaltyVaultImpl
+     * parse tx receipt event RevenueTokenClaimed for contract IpRoyaltyVaultImpl
      */
   }, {
-    key: "parseTxRoyaltyTokensCollectedEvent",
-    value: function parseTxRoyaltyTokensCollectedEvent(txReceipt) {
+    key: "parseTxRevenueTokenClaimedEvent",
+    value: function parseTxRevenueTokenClaimedEvent(txReceipt) {
       var targetLogs = [];
       var _iterator6 = _createForOfIteratorHelper(txReceipt.logs),
         _step6;
@@ -7391,11 +8321,11 @@ var IpRoyaltyVaultImplEventClient = /*#__PURE__*/function () {
           try {
             var event = decodeEventLog({
               abi: ipRoyaltyVaultImplAbi,
-              eventName: "RoyaltyTokensCollected",
+              eventName: "RevenueTokenClaimed",
               data: log.data,
               topics: log.topics
             });
-            if (event.eventName === "RoyaltyTokensCollected") {
+            if (event.eventName === "RevenueTokenClaimed") {
               targetLogs.push(event.args);
             }
           } catch (e) {
@@ -7410,19 +8340,71 @@ var IpRoyaltyVaultImplEventClient = /*#__PURE__*/function () {
       return targetLogs;
     }
 
+    /**
+     * event RoyaltyTokensCollected for contract IpRoyaltyVaultImpl
+     */
+  }, {
+    key: "watchRoyaltyTokensCollectedEvent",
+    value: function watchRoyaltyTokensCollectedEvent(_onLogs7) {
+      return this.rpcClient.watchContractEvent({
+        abi: ipRoyaltyVaultImplAbi,
+        address: this.address,
+        eventName: "RoyaltyTokensCollected",
+        onLogs: function onLogs(evs) {
+          evs.forEach(function (it) {
+            return _onLogs7(it.transactionHash, it.args);
+          });
+        }
+      });
+    }
+
+    /**
+     * parse tx receipt event RoyaltyTokensCollected for contract IpRoyaltyVaultImpl
+     */
+  }, {
+    key: "parseTxRoyaltyTokensCollectedEvent",
+    value: function parseTxRoyaltyTokensCollectedEvent(txReceipt) {
+      var targetLogs = [];
+      var _iterator7 = _createForOfIteratorHelper(txReceipt.logs),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var log = _step7.value;
+          try {
+            var event = decodeEventLog({
+              abi: ipRoyaltyVaultImplAbi,
+              eventName: "RoyaltyTokensCollected",
+              data: log.data,
+              topics: log.topics
+            });
+            if (event.eventName === "RoyaltyTokensCollected") {
+              targetLogs.push(event.args);
+            }
+          } catch (e) {
+            /* empty */
+          }
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+      return targetLogs;
+    }
+
     /**
      * event SnapshotCompleted for contract IpRoyaltyVaultImpl
      */
   }, {
     key: "watchSnapshotCompletedEvent",
-    value: function watchSnapshotCompletedEvent(_onLogs7) {
+    value: function watchSnapshotCompletedEvent(_onLogs8) {
       return this.rpcClient.watchContractEvent({
         abi: ipRoyaltyVaultImplAbi,
         address: this.address,
         eventName: "SnapshotCompleted",
         onLogs: function onLogs(evs) {
           evs.forEach(function (it) {
-            return _onLogs7(it.transactionHash, it.args);
+            return _onLogs8(it.transactionHash, it.args);
           });
         }
       });
@@ -7435,11 +8417,11 @@ var IpRoyaltyVaultImplEventClient = /*#__PURE__*/function () {
     key: "parseTxSnapshotCompletedEvent",
     value: function parseTxSnapshotCompletedEvent(txReceipt) {
       var targetLogs = [];
-      var _iterator7 = _createForOfIteratorHelper(txReceipt.logs),
-        _step7;
+      var _iterator8 = _createForOfIteratorHelper(txReceipt.logs),
+        _step8;
       try {
-        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-          var log = _step7.value;
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var log = _step8.value;
           try {
             var event = decodeEventLog({
               abi: ipRoyaltyVaultImplAbi,
@@ -7455,9 +8437,9 @@ var IpRoyaltyVaultImplEventClient = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator7.e(err);
+        _iterator8.e(err);
       } finally {
-        _iterator7.f();
+        _iterator8.f();
       }
       return targetLogs;
     }
@@ -7990,14 +8972,14 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
    */
   return _createClass(LicenseRegistryEventClient, [{
     key: "watchExpirationTimeSetEvent",
-    value: function watchExpirationTimeSetEvent(_onLogs8) {
+    value: function watchExpirationTimeSetEvent(_onLogs9) {
       return this.rpcClient.watchContractEvent({
         abi: licenseRegistryAbi,
         address: this.address,
         eventName: "ExpirationTimeSet",
         onLogs: function onLogs(evs) {
           evs.forEach(function (it) {
-            return _onLogs8(it.transactionHash, it.args);
+            return _onLogs9(it.transactionHash, it.args);
           });
         }
       });
@@ -8010,11 +8992,11 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
     key: "parseTxExpirationTimeSetEvent",
     value: function parseTxExpirationTimeSetEvent(txReceipt) {
       var targetLogs = [];
-      var _iterator8 = _createForOfIteratorHelper(txReceipt.logs),
-        _step8;
+      var _iterator9 = _createForOfIteratorHelper(txReceipt.logs),
+        _step9;
       try {
-        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-          var log = _step8.value;
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var log = _step9.value;
           try {
             var event = decodeEventLog({
               abi: licenseRegistryAbi,
@@ -8030,9 +9012,9 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator8.e(err);
+        _iterator9.e(err);
       } finally {
-        _iterator8.f();
+        _iterator9.f();
       }
       return targetLogs;
     }
@@ -8042,14 +9024,14 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
      */
   }, {
     key: "watchGovernanceUpdatedEvent",
-    value: function watchGovernanceUpdatedEvent(_onLogs9) {
+    value: function watchGovernanceUpdatedEvent(_onLogs10) {
       return this.rpcClient.watchContractEvent({
         abi: licenseRegistryAbi,
         address: this.address,
         eventName: "GovernanceUpdated",
         onLogs: function onLogs(evs) {
           evs.forEach(function (it) {
-            return _onLogs9(it.transactionHash, it.args);
+            return _onLogs10(it.transactionHash, it.args);
           });
         }
       });
@@ -8062,11 +9044,11 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
     key: "parseTxGovernanceUpdatedEvent",
     value: function parseTxGovernanceUpdatedEvent(txReceipt) {
       var targetLogs = [];
-      var _iterator9 = _createForOfIteratorHelper(txReceipt.logs),
-        _step9;
+      var _iterator10 = _createForOfIteratorHelper(txReceipt.logs),
+        _step10;
       try {
-        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
-          var log = _step9.value;
+        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+          var log = _step10.value;
           try {
             var event = decodeEventLog({
               abi: licenseRegistryAbi,
@@ -8082,9 +9064,9 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator9.e(err);
+        _iterator10.e(err);
       } finally {
-        _iterator9.f();
+        _iterator10.f();
       }
       return targetLogs;
     }
@@ -8094,14 +9076,14 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
      */
   }, {
     key: "watchInitializedEvent",
-    value: function watchInitializedEvent(_onLogs10) {
+    value: function watchInitializedEvent(_onLogs11) {
       return this.rpcClient.watchContractEvent({
         abi: licenseRegistryAbi,
         address: this.address,
         eventName: "Initialized",
         onLogs: function onLogs(evs) {
           evs.forEach(function (it) {
-            return _onLogs10(it.transactionHash, it.args);
+            return _onLogs11(it.transactionHash, it.args);
           });
         }
       });
@@ -8114,11 +9096,11 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
     key: "parseTxInitializedEvent",
     value: function parseTxInitializedEvent(txReceipt) {
       var targetLogs = [];
-      var _iterator10 = _createForOfIteratorHelper(txReceipt.logs),
-        _step10;
+      var _iterator11 = _createForOfIteratorHelper(txReceipt.logs),
+        _step11;
       try {
-        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
-          var log = _step10.value;
+        for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+          var log = _step11.value;
           try {
             var event = decodeEventLog({
               abi: licenseRegistryAbi,
@@ -8134,9 +9116,9 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator10.e(err);
+        _iterator11.e(err);
       } finally {
-        _iterator10.f();
+        _iterator11.f();
       }
       return targetLogs;
     }
@@ -8146,14 +9128,14 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
      */
   }, {
     key: "watchLicenseTemplateRegisteredEvent",
-    value: function watchLicenseTemplateRegisteredEvent(_onLogs11) {
+    value: function watchLicenseTemplateRegisteredEvent(_onLogs12) {
       return this.rpcClient.watchContractEvent({
         abi: licenseRegistryAbi,
         address: this.address,
         eventName: "LicenseTemplateRegistered",
         onLogs: function onLogs(evs) {
           evs.forEach(function (it) {
-            return _onLogs11(it.transactionHash, it.args);
+            return _onLogs12(it.transactionHash, it.args);
           });
         }
       });
@@ -8166,11 +9148,11 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
     key: "parseTxLicenseTemplateRegisteredEvent",
     value: function parseTxLicenseTemplateRegisteredEvent(txReceipt) {
       var targetLogs = [];
-      var _iterator11 = _createForOfIteratorHelper(txReceipt.logs),
-        _step11;
+      var _iterator12 = _createForOfIteratorHelper(txReceipt.logs),
+        _step12;
       try {
-        for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
-          var log = _step11.value;
+        for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+          var log = _step12.value;
           try {
             var event = decodeEventLog({
               abi: licenseRegistryAbi,
@@ -8186,9 +9168,9 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator11.e(err);
+        _iterator12.e(err);
       } finally {
-        _iterator11.f();
+        _iterator12.f();
       }
       return targetLogs;
     }
@@ -8198,14 +9180,14 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
      */
   }, {
     key: "watchMintingLicenseConfigSetForIpEvent",
-    value: function watchMintingLicenseConfigSetForIpEvent(_onLogs12) {
+    value: function watchMintingLicenseConfigSetForIpEvent(_onLogs13) {
       return this.rpcClient.watchContractEvent({
         abi: licenseRegistryAbi,
         address: this.address,
         eventName: "MintingLicenseConfigSetForIP",
         onLogs: function onLogs(evs) {
           evs.forEach(function (it) {
-            return _onLogs12(it.transactionHash, it.args);
+            return _onLogs13(it.transactionHash, it.args);
           });
         }
       });
@@ -8218,11 +9200,11 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
     key: "parseTxMintingLicenseConfigSetForIpEvent",
     value: function parseTxMintingLicenseConfigSetForIpEvent(txReceipt) {
       var targetLogs = [];
-      var _iterator12 = _createForOfIteratorHelper(txReceipt.logs),
-        _step12;
+      var _iterator13 = _createForOfIteratorHelper(txReceipt.logs),
+        _step13;
       try {
-        for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
-          var log = _step12.value;
+        for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+          var log = _step13.value;
           try {
             var event = decodeEventLog({
               abi: licenseRegistryAbi,
@@ -8238,9 +9220,9 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator12.e(err);
+        _iterator13.e(err);
       } finally {
-        _iterator12.f();
+        _iterator13.f();
       }
       return targetLogs;
     }
@@ -8250,14 +9232,14 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
      */
   }, {
     key: "watchMintingLicenseConfigSetLicenseEvent",
-    value: function watchMintingLicenseConfigSetLicenseEvent(_onLogs13) {
+    value: function watchMintingLicenseConfigSetLicenseEvent(_onLogs14) {
       return this.rpcClient.watchContractEvent({
         abi: licenseRegistryAbi,
         address: this.address,
         eventName: "MintingLicenseConfigSetLicense",
         onLogs: function onLogs(evs) {
           evs.forEach(function (it) {
-            return _onLogs13(it.transactionHash, it.args);
+            return _onLogs14(it.transactionHash, it.args);
           });
         }
       });
@@ -8270,11 +9252,11 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
     key: "parseTxMintingLicenseConfigSetLicenseEvent",
     value: function parseTxMintingLicenseConfigSetLicenseEvent(txReceipt) {
       var targetLogs = [];
-      var _iterator13 = _createForOfIteratorHelper(txReceipt.logs),
-        _step13;
+      var _iterator14 = _createForOfIteratorHelper(txReceipt.logs),
+        _step14;
       try {
-        for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
-          var log = _step13.value;
+        for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+          var log = _step14.value;
           try {
             var event = decodeEventLog({
               abi: licenseRegistryAbi,
@@ -8290,9 +9272,9 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator13.e(err);
+        _iterator14.e(err);
       } finally {
-        _iterator13.f();
+        _iterator14.f();
       }
       return targetLogs;
     }
@@ -8302,14 +9284,14 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
      */
   }, {
     key: "watchUpgradedEvent",
-    value: function watchUpgradedEvent(_onLogs14) {
+    value: function watchUpgradedEvent(_onLogs15) {
       return this.rpcClient.watchContractEvent({
         abi: licenseRegistryAbi,
         address: this.address,
         eventName: "Upgraded",
         onLogs: function onLogs(evs) {
           evs.forEach(function (it) {
-            return _onLogs14(it.transactionHash, it.args);
+            return _onLogs15(it.transactionHash, it.args);
           });
         }
       });
@@ -8322,11 +9304,11 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
     key: "parseTxUpgradedEvent",
     value: function parseTxUpgradedEvent(txReceipt) {
       var targetLogs = [];
-      var _iterator14 = _createForOfIteratorHelper(txReceipt.logs),
-        _step14;
+      var _iterator15 = _createForOfIteratorHelper(txReceipt.logs),
+        _step15;
       try {
-        for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
-          var log = _step14.value;
+        for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
+          var log = _step15.value;
           try {
             var event = decodeEventLog({
               abi: licenseRegistryAbi,
@@ -8342,9 +9324,9 @@ var LicenseRegistryEventClient = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator14.e(err);
+        _iterator15.e(err);
       } finally {
-        _iterator14.f();
+        _iterator15.f();
       }
       return targetLogs;
     }
@@ -9088,6 +10070,61 @@ var LicenseRegistryReadOnlyClient = /*#__PURE__*/function (_LicenseRegistryEvent
   }]);
 }(LicenseRegistryEventClient);
 
+// Contract LicenseToken =============================================================
+
+/**
+ * LicenseTokenOwnerOfRequest
+ *
+ * @param tokenId uint256
+ */
+
+/**
+ * contract LicenseToken readonly method
+ */
+var LicenseTokenReadOnlyClient = /*#__PURE__*/function () {
+  function LicenseTokenReadOnlyClient(rpcClient, address) {
+    var _rpcClient$chain7;
+    _classCallCheck(this, LicenseTokenReadOnlyClient);
+    this.address = address || getAddress(licenseTokenAddress, (_rpcClient$chain7 = rpcClient.chain) === null || _rpcClient$chain7 === void 0 ? void 0 : _rpcClient$chain7.id);
+    this.rpcClient = rpcClient;
+  }
+
+  /**
+   * method ownerOf for contract LicenseToken
+   *
+   * @param request LicenseTokenOwnerOfRequest
+   * @return Promise<LicenseTokenOwnerOfResponse>
+   */
+  return _createClass(LicenseTokenReadOnlyClient, [{
+    key: "ownerOf",
+    value: (function () {
+      var _ownerOf = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee49(request) {
+        return _regeneratorRuntime().wrap(function _callee49$(_context49) {
+          while (1) switch (_context49.prev = _context49.next) {
+            case 0:
+              _context49.next = 2;
+              return this.rpcClient.readContract({
+                abi: licenseTokenAbi,
+                address: this.address,
+                functionName: "ownerOf",
+                args: [request.tokenId]
+              });
+            case 2:
+              return _context49.abrupt("return", _context49.sent);
+            case 3:
+            case "end":
+              return _context49.stop();
+          }
+        }, _callee49, this);
+      }));
+      function ownerOf(_x40) {
+        return _ownerOf.apply(this, arguments);
+      }
+      return ownerOf;
+    }())
+  }]);
+}();
+
 // Contract LicensingModule =============================================================
 
 /**
@@ -9144,9 +10181,9 @@ var LicenseRegistryReadOnlyClient = /*#__PURE__*/function (_LicenseRegistryEvent
  */
 var LicensingModuleEventClient = /*#__PURE__*/function () {
   function LicensingModuleEventClient(rpcClient, address) {
-    var _rpcClient$chain7;
+    var _rpcClient$chain8;
     _classCallCheck(this, LicensingModuleEventClient);
-    this.address = address || getAddress(licensingModuleAddress, (_rpcClient$chain7 = rpcClient.chain) === null || _rpcClient$chain7 === void 0 ? void 0 : _rpcClient$chain7.id);
+    this.address = address || getAddress(licensingModuleAddress, (_rpcClient$chain8 = rpcClient.chain) === null || _rpcClient$chain8 === void 0 ? void 0 : _rpcClient$chain8.id);
     this.rpcClient = rpcClient;
   }
 
@@ -9155,14 +10192,14 @@ var LicensingModuleEventClient = /*#__PURE__*/function () {
    */
   return _createClass(LicensingModuleEventClient, [{
     key: "watchLicenseTokensMintedEvent",
-    value: function watchLicenseTokensMintedEvent(_onLogs15) {
+    value: function watchLicenseTokensMintedEvent(_onLogs16) {
       return this.rpcClient.watchContractEvent({
         abi: licensingModuleAbi,
         address: this.address,
         eventName: "LicenseTokensMinted",
         onLogs: function onLogs(evs) {
           evs.forEach(function (it) {
-            return _onLogs15(it.transactionHash, it.args);
+            return _onLogs16(it.transactionHash, it.args);
           });
         }
       });
@@ -9175,11 +10212,11 @@ var LicensingModuleEventClient = /*#__PURE__*/function () {
     key: "parseTxLicenseTokensMintedEvent",
     value: function parseTxLicenseTokensMintedEvent(txReceipt) {
       var targetLogs = [];
-      var _iterator15 = _createForOfIteratorHelper(txReceipt.logs),
-        _step15;
+      var _iterator16 = _createForOfIteratorHelper(txReceipt.logs),
+        _step16;
       try {
-        for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
-          var log = _step15.value;
+        for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+          var log = _step16.value;
           try {
             var event = decodeEventLog({
               abi: licensingModuleAbi,
@@ -9195,9 +10232,9 @@ var LicensingModuleEventClient = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator15.e(err);
+        _iterator16.e(err);
       } finally {
-        _iterator15.f();
+        _iterator16.f();
       }
       return targetLogs;
     }
@@ -9226,12 +10263,12 @@ var LicensingModuleClient = /*#__PURE__*/function (_LicensingModuleEvent) {
   return _createClass(LicensingModuleClient, [{
     key: "attachLicenseTerms",
     value: (function () {
-      var _attachLicenseTerms = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee49(request) {
+      var _attachLicenseTerms = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee50(request) {
         var _yield$this$rpcClient24, call;
-        return _regeneratorRuntime().wrap(function _callee49$(_context49) {
-          while (1) switch (_context49.prev = _context49.next) {
+        return _regeneratorRuntime().wrap(function _callee50$(_context50) {
+          while (1) switch (_context50.prev = _context50.next) {
             case 0:
-              _context49.next = 2;
+              _context50.next = 2;
               return this.rpcClient.simulateContract({
                 abi: licensingModuleAbi,
                 address: this.address,
@@ -9240,19 +10277,19 @@ var LicensingModuleClient = /*#__PURE__*/function (_LicensingModuleEvent) {
                 args: [request.ipId, request.licenseTemplate, request.licenseTermsId]
               });
             case 2:
-              _yield$this$rpcClient24 = _context49.sent;
+              _yield$this$rpcClient24 = _context50.sent;
               call = _yield$this$rpcClient24.request;
-              _context49.next = 6;
+              _context50.next = 6;
               return this.wallet.writeContract(call);
             case 6:
-              return _context49.abrupt("return", _context49.sent);
+              return _context50.abrupt("return", _context50.sent);
             case 7:
             case "end":
-              return _context49.stop();
+              return _context50.stop();
           }
-        }, _callee49, this);
+        }, _callee50, this);
       }));
-      function attachLicenseTerms(_x40) {
+      function attachLicenseTerms(_x41) {
         return _attachLicenseTerms.apply(this, arguments);
       }
       return attachLicenseTerms;
@@ -9267,12 +10304,12 @@ var LicensingModuleClient = /*#__PURE__*/function (_LicensingModuleEvent) {
   }, {
     key: "mintLicenseTokens",
     value: (function () {
-      var _mintLicenseTokens = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee50(request) {
+      var _mintLicenseTokens = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee51(request) {
         var _yield$this$rpcClient25, call;
-        return _regeneratorRuntime().wrap(function _callee50$(_context50) {
-          while (1) switch (_context50.prev = _context50.next) {
+        return _regeneratorRuntime().wrap(function _callee51$(_context51) {
+          while (1) switch (_context51.prev = _context51.next) {
             case 0:
-              _context50.next = 2;
+              _context51.next = 2;
               return this.rpcClient.simulateContract({
                 abi: licensingModuleAbi,
                 address: this.address,
@@ -9281,19 +10318,19 @@ var LicensingModuleClient = /*#__PURE__*/function (_LicensingModuleEvent) {
                 args: [request.licensorIpId, request.licenseTemplate, request.licenseTermsId, request.amount, request.receiver, request.royaltyContext]
               });
             case 2:
-              _yield$this$rpcClient25 = _context50.sent;
+              _yield$this$rpcClient25 = _context51.sent;
               call = _yield$this$rpcClient25.request;
-              _context50.next = 6;
+              _context51.next = 6;
               return this.wallet.writeContract(call);
             case 6:
-              return _context50.abrupt("return", _context50.sent);
+              return _context51.abrupt("return", _context51.sent);
             case 7:
             case "end":
-              return _context50.stop();
+              return _context51.stop();
           }
-        }, _callee50, this);
+        }, _callee51, this);
       }));
-      function mintLicenseTokens(_x41) {
+      function mintLicenseTokens(_x42) {
         return _mintLicenseTokens.apply(this, arguments);
       }
       return mintLicenseTokens;
@@ -9308,12 +10345,12 @@ var LicensingModuleClient = /*#__PURE__*/function (_LicensingModuleEvent) {
   }, {
     key: "registerDerivative",
     value: (function () {
-      var _registerDerivative = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee51(request) {
+      var _registerDerivative = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee52(request) {
         var _yield$this$rpcClient26, call;
-        return _regeneratorRuntime().wrap(function _callee51$(_context51) {
-          while (1) switch (_context51.prev = _context51.next) {
+        return _regeneratorRuntime().wrap(function _callee52$(_context52) {
+          while (1) switch (_context52.prev = _context52.next) {
             case 0:
-              _context51.next = 2;
+              _context52.next = 2;
               return this.rpcClient.simulateContract({
                 abi: licensingModuleAbi,
                 address: this.address,
@@ -9322,19 +10359,19 @@ var LicensingModuleClient = /*#__PURE__*/function (_LicensingModuleEvent) {
                 args: [request.childIpId, request.parentIpIds, request.licenseTermsIds, request.licenseTemplate, request.royaltyContext]
               });
             case 2:
-              _yield$this$rpcClient26 = _context51.sent;
+              _yield$this$rpcClient26 = _context52.sent;
               call = _yield$this$rpcClient26.request;
-              _context51.next = 6;
+              _context52.next = 6;
               return this.wallet.writeContract(call);
             case 6:
-              return _context51.abrupt("return", _context51.sent);
+              return _context52.abrupt("return", _context52.sent);
             case 7:
             case "end":
-              return _context51.stop();
+              return _context52.stop();
           }
-        }, _callee51, this);
+        }, _callee52, this);
       }));
-      function registerDerivative(_x42) {
+      function registerDerivative(_x43) {
         return _registerDerivative.apply(this, arguments);
       }
       return registerDerivative;
@@ -9349,12 +10386,12 @@ var LicensingModuleClient = /*#__PURE__*/function (_LicensingModuleEvent) {
   }, {
     key: "registerDerivativeWithLicenseTokens",
     value: (function () {
-      var _registerDerivativeWithLicenseTokens = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee52(request) {
+      var _registerDerivativeWithLicenseTokens = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee53(request) {
         var _yield$this$rpcClient27, call;
-        return _regeneratorRuntime().wrap(function _callee52$(_context52) {
-          while (1) switch (_context52.prev = _context52.next) {
+        return _regeneratorRuntime().wrap(function _callee53$(_context53) {
+          while (1) switch (_context53.prev = _context53.next) {
             case 0:
-              _context52.next = 2;
+              _context53.next = 2;
               return this.rpcClient.simulateContract({
                 abi: licensingModuleAbi,
                 address: this.address,
@@ -9363,19 +10400,19 @@ var LicensingModuleClient = /*#__PURE__*/function (_LicensingModuleEvent) {
                 args: [request.childIpId, request.licenseTokenIds, request.royaltyContext]
               });
             case 2:
-              _yield$this$rpcClient27 = _context52.sent;
+              _yield$this$rpcClient27 = _context53.sent;
               call = _yield$this$rpcClient27.request;
-              _context52.next = 6;
+              _context53.next = 6;
               return this.wallet.writeContract(call);
             case 6:
-              return _context52.abrupt("return", _context52.sent);
+              return _context53.abrupt("return", _context53.sent);
             case 7:
             case "end":
-              return _context52.stop();
+              return _context53.stop();
           }
-        }, _callee52, this);
+        }, _callee53, this);
       }));
-      function registerDerivativeWithLicenseTokens(_x43) {
+      function registerDerivativeWithLicenseTokens(_x44) {
         return _registerDerivativeWithLicenseTokens.apply(this, arguments);
       }
       return registerDerivativeWithLicenseTokens;
@@ -9539,9 +10576,9 @@ var LicensingModuleClient = /*#__PURE__*/function (_LicensingModuleEvent) {
  */
 var PiLicenseTemplateEventClient = /*#__PURE__*/function () {
   function PiLicenseTemplateEventClient(rpcClient, address) {
-    var _rpcClient$chain9;
+    var _rpcClient$chain10;
     _classCallCheck(this, PiLicenseTemplateEventClient);
-    this.address = address || getAddress(piLicenseTemplateAddress, (_rpcClient$chain9 = rpcClient.chain) === null || _rpcClient$chain9 === void 0 ? void 0 : _rpcClient$chain9.id);
+    this.address = address || getAddress(piLicenseTemplateAddress, (_rpcClient$chain10 = rpcClient.chain) === null || _rpcClient$chain10 === void 0 ? void 0 : _rpcClient$chain10.id);
     this.rpcClient = rpcClient;
   }
 
@@ -9550,14 +10587,14 @@ var PiLicenseTemplateEventClient = /*#__PURE__*/function () {
    */
   return _createClass(PiLicenseTemplateEventClient, [{
     key: "watchDerivativeApprovedEvent",
-    value: function watchDerivativeApprovedEvent(_onLogs16) {
+    value: function watchDerivativeApprovedEvent(_onLogs17) {
       return this.rpcClient.watchContractEvent({
         abi: piLicenseTemplateAbi,
         address: this.address,
         eventName: "DerivativeApproved",
         onLogs: function onLogs(evs) {
           evs.forEach(function (it) {
-            return _onLogs16(it.transactionHash, it.args);
+            return _onLogs17(it.transactionHash, it.args);
           });
         }
       });
@@ -9570,11 +10607,11 @@ var PiLicenseTemplateEventClient = /*#__PURE__*/function () {
     key: "parseTxDerivativeApprovedEvent",
     value: function parseTxDerivativeApprovedEvent(txReceipt) {
       var targetLogs = [];
-      var _iterator16 = _createForOfIteratorHelper(txReceipt.logs),
-        _step16;
+      var _iterator17 = _createForOfIteratorHelper(txReceipt.logs),
+        _step17;
       try {
-        for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
-          var log = _step16.value;
+        for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
+          var log = _step17.value;
           try {
             var event = decodeEventLog({
               abi: piLicenseTemplateAbi,
@@ -9590,9 +10627,9 @@ var PiLicenseTemplateEventClient = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator16.e(err);
+        _iterator17.e(err);
       } finally {
-        _iterator16.f();
+        _iterator17.f();
       }
       return targetLogs;
     }
@@ -9602,14 +10639,14 @@ var PiLicenseTemplateEventClient = /*#__PURE__*/function () {
      */
   }, {
     key: "watchInitializedEvent",
-    value: function watchInitializedEvent(_onLogs17) {
+    value: function watchInitializedEvent(_onLogs18) {
       return this.rpcClient.watchContractEvent({
         abi: piLicenseTemplateAbi,
         address: this.address,
         eventName: "Initialized",
         onLogs: function onLogs(evs) {
           evs.forEach(function (it) {
-            return _onLogs17(it.transactionHash, it.args);
+            return _onLogs18(it.transactionHash, it.args);
           });
         }
       });
@@ -9622,11 +10659,11 @@ var PiLicenseTemplateEventClient = /*#__PURE__*/function () {
     key: "parseTxInitializedEvent",
     value: function parseTxInitializedEvent(txReceipt) {
       var targetLogs = [];
-      var _iterator17 = _createForOfIteratorHelper(txReceipt.logs),
-        _step17;
+      var _iterator18 = _createForOfIteratorHelper(txReceipt.logs),
+        _step18;
       try {
-        for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
-          var log = _step17.value;
+        for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
+          var log = _step18.value;
           try {
             var event = decodeEventLog({
               abi: piLicenseTemplateAbi,
@@ -9642,9 +10679,9 @@ var PiLicenseTemplateEventClient = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator17.e(err);
+        _iterator18.e(err);
       } finally {
-        _iterator17.f();
+        _iterator18.f();
       }
       return targetLogs;
     }
@@ -9654,14 +10691,14 @@ var PiLicenseTemplateEventClient = /*#__PURE__*/function () {
      */
   }, {
     key: "watchLicenseTermsRegisteredEvent",
-    value: function watchLicenseTermsRegisteredEvent(_onLogs18) {
+    value: function watchLicenseTermsRegisteredEvent(_onLogs19) {
       return this.rpcClient.watchContractEvent({
         abi: piLicenseTemplateAbi,
         address: this.address,
         eventName: "LicenseTermsRegistered",
         onLogs: function onLogs(evs) {
           evs.forEach(function (it) {
-            return _onLogs18(it.transactionHash, it.args);
+            return _onLogs19(it.transactionHash, it.args);
           });
         }
       });
@@ -9674,11 +10711,11 @@ var PiLicenseTemplateEventClient = /*#__PURE__*/function () {
     key: "parseTxLicenseTermsRegisteredEvent",
     value: function parseTxLicenseTermsRegisteredEvent(txReceipt) {
       var targetLogs = [];
-      var _iterator18 = _createForOfIteratorHelper(txReceipt.logs),
-        _step18;
+      var _iterator19 = _createForOfIteratorHelper(txReceipt.logs),
+        _step19;
       try {
-        for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
-          var log = _step18.value;
+        for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
+          var log = _step19.value;
           try {
             var event = decodeEventLog({
               abi: piLicenseTemplateAbi,
@@ -9694,9 +10731,9 @@ var PiLicenseTemplateEventClient = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator18.e(err);
+        _iterator19.e(err);
       } finally {
-        _iterator18.f();
+        _iterator19.f();
       }
       return targetLogs;
     }
@@ -9722,23 +10759,23 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   return _createClass(PiLicenseTemplateReadOnlyClient, [{
     key: "accessController",
     value: (function () {
-      var _accessController = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee54() {
-        return _regeneratorRuntime().wrap(function _callee54$(_context54) {
-          while (1) switch (_context54.prev = _context54.next) {
+      var _accessController = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee55() {
+        return _regeneratorRuntime().wrap(function _callee55$(_context55) {
+          while (1) switch (_context55.prev = _context55.next) {
             case 0:
-              _context54.next = 2;
+              _context55.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
                 functionName: "ACCESS_CONTROLLER"
               });
             case 2:
-              return _context54.abrupt("return", _context54.sent);
+              return _context55.abrupt("return", _context55.sent);
             case 3:
             case "end":
-              return _context54.stop();
+              return _context55.stop();
           }
-        }, _callee54, this);
+        }, _callee55, this);
       }));
       function accessController() {
         return _accessController.apply(this, arguments);
@@ -9755,23 +10792,23 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "ipAccountRegistry",
     value: (function () {
-      var _ipAccountRegistry = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee55() {
-        return _regeneratorRuntime().wrap(function _callee55$(_context55) {
-          while (1) switch (_context55.prev = _context55.next) {
+      var _ipAccountRegistry = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee56() {
+        return _regeneratorRuntime().wrap(function _callee56$(_context56) {
+          while (1) switch (_context56.prev = _context56.next) {
             case 0:
-              _context55.next = 2;
+              _context56.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
                 functionName: "IP_ACCOUNT_REGISTRY"
               });
             case 2:
-              return _context55.abrupt("return", _context55.sent);
+              return _context56.abrupt("return", _context56.sent);
             case 3:
             case "end":
-              return _context55.stop();
+              return _context56.stop();
           }
-        }, _callee55, this);
+        }, _callee56, this);
       }));
       function ipAccountRegistry() {
         return _ipAccountRegistry.apply(this, arguments);
@@ -9788,23 +10825,23 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "licenseNft",
     value: (function () {
-      var _licenseNft = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee56() {
-        return _regeneratorRuntime().wrap(function _callee56$(_context56) {
-          while (1) switch (_context56.prev = _context56.next) {
+      var _licenseNft = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee57() {
+        return _regeneratorRuntime().wrap(function _callee57$(_context57) {
+          while (1) switch (_context57.prev = _context57.next) {
             case 0:
-              _context56.next = 2;
+              _context57.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
                 functionName: "LICENSE_NFT"
               });
             case 2:
-              return _context56.abrupt("return", _context56.sent);
+              return _context57.abrupt("return", _context57.sent);
             case 3:
             case "end":
-              return _context56.stop();
+              return _context57.stop();
           }
-        }, _callee56, this);
+        }, _callee57, this);
       }));
       function licenseNft() {
         return _licenseNft.apply(this, arguments);
@@ -9821,23 +10858,23 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "licenseRegistry",
     value: (function () {
-      var _licenseRegistry = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee57() {
-        return _regeneratorRuntime().wrap(function _callee57$(_context57) {
-          while (1) switch (_context57.prev = _context57.next) {
+      var _licenseRegistry = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee58() {
+        return _regeneratorRuntime().wrap(function _callee58$(_context58) {
+          while (1) switch (_context58.prev = _context58.next) {
             case 0:
-              _context57.next = 2;
+              _context58.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
                 functionName: "LICENSE_REGISTRY"
               });
             case 2:
-              return _context57.abrupt("return", _context57.sent);
+              return _context58.abrupt("return", _context58.sent);
             case 3:
             case "end":
-              return _context57.stop();
+              return _context58.stop();
           }
-        }, _callee57, this);
+        }, _callee58, this);
       }));
       function licenseRegistry() {
         return _licenseRegistry.apply(this, arguments);
@@ -9854,23 +10891,23 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "royaltyModule",
     value: (function () {
-      var _royaltyModule = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee58() {
-        return _regeneratorRuntime().wrap(function _callee58$(_context58) {
-          while (1) switch (_context58.prev = _context58.next) {
+      var _royaltyModule = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee59() {
+        return _regeneratorRuntime().wrap(function _callee59$(_context59) {
+          while (1) switch (_context59.prev = _context59.next) {
             case 0:
-              _context58.next = 2;
+              _context59.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
                 functionName: "ROYALTY_MODULE"
               });
             case 2:
-              return _context58.abrupt("return", _context58.sent);
+              return _context59.abrupt("return", _context59.sent);
             case 3:
             case "end":
-              return _context58.stop();
+              return _context59.stop();
           }
-        }, _callee58, this);
+        }, _callee59, this);
       }));
       function royaltyModule() {
         return _royaltyModule.apply(this, arguments);
@@ -9887,11 +10924,11 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "exists",
     value: (function () {
-      var _exists2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee59(request) {
-        return _regeneratorRuntime().wrap(function _callee59$(_context59) {
-          while (1) switch (_context59.prev = _context59.next) {
+      var _exists2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee60(request) {
+        return _regeneratorRuntime().wrap(function _callee60$(_context60) {
+          while (1) switch (_context60.prev = _context60.next) {
             case 0:
-              _context59.next = 2;
+              _context60.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -9899,14 +10936,14 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
                 args: [request.licenseTermsId]
               });
             case 2:
-              return _context59.abrupt("return", _context59.sent);
+              return _context60.abrupt("return", _context60.sent);
             case 3:
             case "end":
-              return _context59.stop();
+              return _context60.stop();
           }
-        }, _callee59, this);
+        }, _callee60, this);
       }));
-      function exists(_x45) {
+      function exists(_x46) {
         return _exists2.apply(this, arguments);
       }
       return exists;
@@ -9921,11 +10958,11 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "getEarlierExpireTime",
     value: (function () {
-      var _getEarlierExpireTime = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee60(request) {
-        return _regeneratorRuntime().wrap(function _callee60$(_context60) {
-          while (1) switch (_context60.prev = _context60.next) {
+      var _getEarlierExpireTime = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee61(request) {
+        return _regeneratorRuntime().wrap(function _callee61$(_context61) {
+          while (1) switch (_context61.prev = _context61.next) {
             case 0:
-              _context60.next = 2;
+              _context61.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -9933,14 +10970,14 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
                 args: [request.licenseTermsIds, request.start]
               });
             case 2:
-              return _context60.abrupt("return", _context60.sent);
+              return _context61.abrupt("return", _context61.sent);
             case 3:
             case "end":
-              return _context60.stop();
+              return _context61.stop();
           }
-        }, _callee60, this);
+        }, _callee61, this);
       }));
-      function getEarlierExpireTime(_x46) {
+      function getEarlierExpireTime(_x47) {
         return _getEarlierExpireTime.apply(this, arguments);
       }
       return getEarlierExpireTime;
@@ -9955,11 +10992,11 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "getExpireTime",
     value: (function () {
-      var _getExpireTime2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee61(request) {
-        return _regeneratorRuntime().wrap(function _callee61$(_context61) {
-          while (1) switch (_context61.prev = _context61.next) {
+      var _getExpireTime2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee62(request) {
+        return _regeneratorRuntime().wrap(function _callee62$(_context62) {
+          while (1) switch (_context62.prev = _context62.next) {
             case 0:
-              _context61.next = 2;
+              _context62.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -9967,14 +11004,14 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
                 args: [request.licenseTermsId, request.start]
               });
             case 2:
-              return _context61.abrupt("return", _context61.sent);
+              return _context62.abrupt("return", _context62.sent);
             case 3:
             case "end":
-              return _context61.stop();
+              return _context62.stop();
           }
-        }, _callee61, this);
+        }, _callee62, this);
       }));
-      function getExpireTime(_x47) {
+      function getExpireTime(_x48) {
         return _getExpireTime2.apply(this, arguments);
       }
       return getExpireTime;
@@ -9989,12 +11026,12 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "getLicenseTermsId",
     value: (function () {
-      var _getLicenseTermsId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee62(request) {
+      var _getLicenseTermsId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee63(request) {
         var result;
-        return _regeneratorRuntime().wrap(function _callee62$(_context62) {
-          while (1) switch (_context62.prev = _context62.next) {
+        return _regeneratorRuntime().wrap(function _callee63$(_context63) {
+          while (1) switch (_context63.prev = _context63.next) {
             case 0:
-              _context62.next = 2;
+              _context63.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -10002,17 +11039,17 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
                 args: [request.terms]
               });
             case 2:
-              result = _context62.sent;
-              return _context62.abrupt("return", {
+              result = _context63.sent;
+              return _context63.abrupt("return", {
                 selectedLicenseTermsId: result
               });
             case 4:
             case "end":
-              return _context62.stop();
+              return _context63.stop();
           }
-        }, _callee62, this);
+        }, _callee63, this);
       }));
-      function getLicenseTermsId(_x48) {
+      function getLicenseTermsId(_x49) {
         return _getLicenseTermsId.apply(this, arguments);
       }
       return getLicenseTermsId;
@@ -10027,23 +11064,23 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "getMetadataUri",
     value: (function () {
-      var _getMetadataUri = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee63() {
-        return _regeneratorRuntime().wrap(function _callee63$(_context63) {
-          while (1) switch (_context63.prev = _context63.next) {
+      var _getMetadataUri = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee64() {
+        return _regeneratorRuntime().wrap(function _callee64$(_context64) {
+          while (1) switch (_context64.prev = _context64.next) {
             case 0:
-              _context63.next = 2;
+              _context64.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
                 functionName: "getMetadataURI"
               });
             case 2:
-              return _context63.abrupt("return", _context63.sent);
+              return _context64.abrupt("return", _context64.sent);
             case 3:
             case "end":
-              return _context63.stop();
+              return _context64.stop();
           }
-        }, _callee63, this);
+        }, _callee64, this);
       }));
       function getMetadataUri() {
         return _getMetadataUri.apply(this, arguments);
@@ -10060,12 +11097,12 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "getRoyaltyPolicy",
     value: (function () {
-      var _getRoyaltyPolicy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee64(request) {
+      var _getRoyaltyPolicy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee65(request) {
         var result;
-        return _regeneratorRuntime().wrap(function _callee64$(_context64) {
-          while (1) switch (_context64.prev = _context64.next) {
+        return _regeneratorRuntime().wrap(function _callee65$(_context65) {
+          while (1) switch (_context65.prev = _context65.next) {
             case 0:
-              _context64.next = 2;
+              _context65.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -10073,8 +11110,8 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
                 args: [request.licenseTermsId]
               });
             case 2:
-              result = _context64.sent;
-              return _context64.abrupt("return", {
+              result = _context65.sent;
+              return _context65.abrupt("return", {
                 royaltyPolicy: result[0],
                 royaltyData: result[1],
                 mintingFee: result[2],
@@ -10082,11 +11119,11 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
               });
             case 4:
             case "end":
-              return _context64.stop();
+              return _context65.stop();
           }
-        }, _callee64, this);
+        }, _callee65, this);
       }));
-      function getRoyaltyPolicy(_x49) {
+      function getRoyaltyPolicy(_x50) {
         return _getRoyaltyPolicy.apply(this, arguments);
       }
       return getRoyaltyPolicy;
@@ -10101,11 +11138,11 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "isDerivativeApproved",
     value: (function () {
-      var _isDerivativeApproved = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee65(request) {
-        return _regeneratorRuntime().wrap(function _callee65$(_context65) {
-          while (1) switch (_context65.prev = _context65.next) {
+      var _isDerivativeApproved = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee66(request) {
+        return _regeneratorRuntime().wrap(function _callee66$(_context66) {
+          while (1) switch (_context66.prev = _context66.next) {
             case 0:
-              _context65.next = 2;
+              _context66.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -10113,14 +11150,14 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
                 args: [request.licenseTokenId, request.childIpId]
               });
             case 2:
-              return _context65.abrupt("return", _context65.sent);
+              return _context66.abrupt("return", _context66.sent);
             case 3:
             case "end":
-              return _context65.stop();
+              return _context66.stop();
           }
-        }, _callee65, this);
+        }, _callee66, this);
       }));
-      function isDerivativeApproved(_x50) {
+      function isDerivativeApproved(_x51) {
         return _isDerivativeApproved.apply(this, arguments);
       }
       return isDerivativeApproved;
@@ -10135,11 +11172,11 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "isLicenseTransferable",
     value: (function () {
-      var _isLicenseTransferable = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee66(request) {
-        return _regeneratorRuntime().wrap(function _callee66$(_context66) {
-          while (1) switch (_context66.prev = _context66.next) {
+      var _isLicenseTransferable = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee67(request) {
+        return _regeneratorRuntime().wrap(function _callee67$(_context67) {
+          while (1) switch (_context67.prev = _context67.next) {
             case 0:
-              _context66.next = 2;
+              _context67.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -10147,14 +11184,14 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
                 args: [request.licenseTermsId]
               });
             case 2:
-              return _context66.abrupt("return", _context66.sent);
+              return _context67.abrupt("return", _context67.sent);
             case 3:
             case "end":
-              return _context66.stop();
+              return _context67.stop();
           }
-        }, _callee66, this);
+        }, _callee67, this);
       }));
-      function isLicenseTransferable(_x51) {
+      function isLicenseTransferable(_x52) {
         return _isLicenseTransferable.apply(this, arguments);
       }
       return isLicenseTransferable;
@@ -10169,23 +11206,23 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "name",
     value: (function () {
-      var _name = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee67() {
-        return _regeneratorRuntime().wrap(function _callee67$(_context67) {
-          while (1) switch (_context67.prev = _context67.next) {
+      var _name = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee68() {
+        return _regeneratorRuntime().wrap(function _callee68$(_context68) {
+          while (1) switch (_context68.prev = _context68.next) {
             case 0:
-              _context67.next = 2;
+              _context68.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
                 functionName: "name"
               });
             case 2:
-              return _context67.abrupt("return", _context67.sent);
+              return _context68.abrupt("return", _context68.sent);
             case 3:
             case "end":
-              return _context67.stop();
+              return _context68.stop();
           }
-        }, _callee67, this);
+        }, _callee68, this);
       }));
       function name() {
         return _name.apply(this, arguments);
@@ -10202,11 +11239,11 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "supportsInterface",
     value: (function () {
-      var _supportsInterface = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee68(request) {
-        return _regeneratorRuntime().wrap(function _callee68$(_context68) {
-          while (1) switch (_context68.prev = _context68.next) {
+      var _supportsInterface = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee69(request) {
+        return _regeneratorRuntime().wrap(function _callee69$(_context69) {
+          while (1) switch (_context69.prev = _context69.next) {
             case 0:
-              _context68.next = 2;
+              _context69.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -10214,14 +11251,14 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
                 args: [request.interfaceId]
               });
             case 2:
-              return _context68.abrupt("return", _context68.sent);
+              return _context69.abrupt("return", _context69.sent);
             case 3:
             case "end":
-              return _context68.stop();
+              return _context69.stop();
           }
-        }, _callee68, this);
+        }, _callee69, this);
       }));
-      function supportsInterface(_x52) {
+      function supportsInterface(_x53) {
         return _supportsInterface.apply(this, arguments);
       }
       return supportsInterface;
@@ -10236,11 +11273,11 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "toJson",
     value: (function () {
-      var _toJson = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee69(request) {
-        return _regeneratorRuntime().wrap(function _callee69$(_context69) {
-          while (1) switch (_context69.prev = _context69.next) {
+      var _toJson = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee70(request) {
+        return _regeneratorRuntime().wrap(function _callee70$(_context70) {
+          while (1) switch (_context70.prev = _context70.next) {
             case 0:
-              _context69.next = 2;
+              _context70.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -10248,14 +11285,14 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
                 args: [request.licenseTermsId]
               });
             case 2:
-              return _context69.abrupt("return", _context69.sent);
+              return _context70.abrupt("return", _context70.sent);
             case 3:
             case "end":
-              return _context69.stop();
+              return _context70.stop();
           }
-        }, _callee69, this);
+        }, _callee70, this);
       }));
-      function toJson(_x53) {
+      function toJson(_x54) {
         return _toJson.apply(this, arguments);
       }
       return toJson;
@@ -10270,23 +11307,23 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "totalRegisteredLicenseTerms",
     value: (function () {
-      var _totalRegisteredLicenseTerms = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee70() {
-        return _regeneratorRuntime().wrap(function _callee70$(_context70) {
-          while (1) switch (_context70.prev = _context70.next) {
+      var _totalRegisteredLicenseTerms = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee71() {
+        return _regeneratorRuntime().wrap(function _callee71$(_context71) {
+          while (1) switch (_context71.prev = _context71.next) {
             case 0:
-              _context70.next = 2;
+              _context71.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
                 functionName: "totalRegisteredLicenseTerms"
               });
             case 2:
-              return _context70.abrupt("return", _context70.sent);
+              return _context71.abrupt("return", _context71.sent);
             case 3:
             case "end":
-              return _context70.stop();
+              return _context71.stop();
           }
-        }, _callee70, this);
+        }, _callee71, this);
       }));
       function totalRegisteredLicenseTerms() {
         return _totalRegisteredLicenseTerms.apply(this, arguments);
@@ -10303,11 +11340,11 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
   }, {
     key: "verifyCompatibleLicenses",
     value: (function () {
-      var _verifyCompatibleLicenses = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee71(request) {
-        return _regeneratorRuntime().wrap(function _callee71$(_context71) {
-          while (1) switch (_context71.prev = _context71.next) {
+      var _verifyCompatibleLicenses = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee72(request) {
+        return _regeneratorRuntime().wrap(function _callee72$(_context72) {
+          while (1) switch (_context72.prev = _context72.next) {
             case 0:
-              _context71.next = 2;
+              _context72.next = 2;
               return this.rpcClient.readContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -10315,14 +11352,14 @@ var PiLicenseTemplateReadOnlyClient = /*#__PURE__*/function (_PiLicenseTemplateE
                 args: [request.licenseTermsIds]
               });
             case 2:
-              return _context71.abrupt("return", _context71.sent);
+              return _context72.abrupt("return", _context72.sent);
             case 3:
             case "end":
-              return _context71.stop();
+              return _context72.stop();
           }
-        }, _callee71, this);
+        }, _callee72, this);
       }));
-      function verifyCompatibleLicenses(_x54) {
+      function verifyCompatibleLicenses(_x55) {
         return _verifyCompatibleLicenses.apply(this, arguments);
       }
       return verifyCompatibleLicenses;
@@ -10352,12 +11389,12 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
   return _createClass(PiLicenseTemplateClient, [{
     key: "initialize",
     value: (function () {
-      var _initialize2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee72(request) {
+      var _initialize2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee73(request) {
         var _yield$this$rpcClient28, call;
-        return _regeneratorRuntime().wrap(function _callee72$(_context72) {
-          while (1) switch (_context72.prev = _context72.next) {
+        return _regeneratorRuntime().wrap(function _callee73$(_context73) {
+          while (1) switch (_context73.prev = _context73.next) {
             case 0:
-              _context72.next = 2;
+              _context73.next = 2;
               return this.rpcClient.simulateContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -10366,19 +11403,19 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
                 args: [request.name, request.metadataURI]
               });
             case 2:
-              _yield$this$rpcClient28 = _context72.sent;
+              _yield$this$rpcClient28 = _context73.sent;
               call = _yield$this$rpcClient28.request;
-              _context72.next = 6;
+              _context73.next = 6;
               return this.wallet.writeContract(call);
             case 6:
-              return _context72.abrupt("return", _context72.sent);
+              return _context73.abrupt("return", _context73.sent);
             case 7:
             case "end":
-              return _context72.stop();
+              return _context73.stop();
           }
-        }, _callee72, this);
+        }, _callee73, this);
       }));
-      function initialize(_x55) {
+      function initialize(_x56) {
         return _initialize2.apply(this, arguments);
       }
       return initialize;
@@ -10393,12 +11430,12 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
   }, {
     key: "registerLicenseTerms",
     value: (function () {
-      var _registerLicenseTerms = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee73(request) {
+      var _registerLicenseTerms = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee74(request) {
         var _yield$this$rpcClient29, call;
-        return _regeneratorRuntime().wrap(function _callee73$(_context73) {
-          while (1) switch (_context73.prev = _context73.next) {
+        return _regeneratorRuntime().wrap(function _callee74$(_context74) {
+          while (1) switch (_context74.prev = _context74.next) {
             case 0:
-              _context73.next = 2;
+              _context74.next = 2;
               return this.rpcClient.simulateContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -10407,19 +11444,19 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
                 args: [request.terms]
               });
             case 2:
-              _yield$this$rpcClient29 = _context73.sent;
+              _yield$this$rpcClient29 = _context74.sent;
               call = _yield$this$rpcClient29.request;
-              _context73.next = 6;
+              _context74.next = 6;
               return this.wallet.writeContract(call);
             case 6:
-              return _context73.abrupt("return", _context73.sent);
+              return _context74.abrupt("return", _context74.sent);
             case 7:
             case "end":
-              return _context73.stop();
+              return _context74.stop();
           }
-        }, _callee73, this);
+        }, _callee74, this);
       }));
-      function registerLicenseTerms(_x56) {
+      function registerLicenseTerms(_x57) {
         return _registerLicenseTerms.apply(this, arguments);
       }
       return registerLicenseTerms;
@@ -10434,12 +11471,12 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
   }, {
     key: "setApproval",
     value: (function () {
-      var _setApproval = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee74(request) {
+      var _setApproval = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee75(request) {
         var _yield$this$rpcClient30, call;
-        return _regeneratorRuntime().wrap(function _callee74$(_context74) {
-          while (1) switch (_context74.prev = _context74.next) {
+        return _regeneratorRuntime().wrap(function _callee75$(_context75) {
+          while (1) switch (_context75.prev = _context75.next) {
             case 0:
-              _context74.next = 2;
+              _context75.next = 2;
               return this.rpcClient.simulateContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -10448,19 +11485,19 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
                 args: [request.licenseTokenId, request.childIpId, request.approved]
               });
             case 2:
-              _yield$this$rpcClient30 = _context74.sent;
+              _yield$this$rpcClient30 = _context75.sent;
               call = _yield$this$rpcClient30.request;
-              _context74.next = 6;
+              _context75.next = 6;
               return this.wallet.writeContract(call);
             case 6:
-              return _context74.abrupt("return", _context74.sent);
+              return _context75.abrupt("return", _context75.sent);
             case 7:
             case "end":
-              return _context74.stop();
+              return _context75.stop();
           }
-        }, _callee74, this);
+        }, _callee75, this);
       }));
-      function setApproval(_x57) {
+      function setApproval(_x58) {
         return _setApproval.apply(this, arguments);
       }
       return setApproval;
@@ -10475,12 +11512,12 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
   }, {
     key: "verifyMintLicenseToken",
     value: (function () {
-      var _verifyMintLicenseToken2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee75(request) {
+      var _verifyMintLicenseToken2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee76(request) {
         var _yield$this$rpcClient31, call;
-        return _regeneratorRuntime().wrap(function _callee75$(_context75) {
-          while (1) switch (_context75.prev = _context75.next) {
+        return _regeneratorRuntime().wrap(function _callee76$(_context76) {
+          while (1) switch (_context76.prev = _context76.next) {
             case 0:
-              _context75.next = 2;
+              _context76.next = 2;
               return this.rpcClient.simulateContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -10489,19 +11526,19 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
                 args: [request[0], request[1], request[2], request[3]]
               });
             case 2:
-              _yield$this$rpcClient31 = _context75.sent;
+              _yield$this$rpcClient31 = _context76.sent;
               call = _yield$this$rpcClient31.request;
-              _context75.next = 6;
+              _context76.next = 6;
               return this.wallet.writeContract(call);
             case 6:
-              return _context75.abrupt("return", _context75.sent);
+              return _context76.abrupt("return", _context76.sent);
             case 7:
             case "end":
-              return _context75.stop();
+              return _context76.stop();
           }
-        }, _callee75, this);
+        }, _callee76, this);
       }));
-      function verifyMintLicenseToken(_x58) {
+      function verifyMintLicenseToken(_x59) {
         return _verifyMintLicenseToken2.apply(this, arguments);
       }
       return verifyMintLicenseToken;
@@ -10516,12 +11553,12 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
   }, {
     key: "verifyRegisterDerivative",
     value: (function () {
-      var _verifyRegisterDerivative = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee76(request) {
+      var _verifyRegisterDerivative = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee77(request) {
         var _yield$this$rpcClient32, call;
-        return _regeneratorRuntime().wrap(function _callee76$(_context76) {
-          while (1) switch (_context76.prev = _context76.next) {
+        return _regeneratorRuntime().wrap(function _callee77$(_context77) {
+          while (1) switch (_context77.prev = _context77.next) {
             case 0:
-              _context76.next = 2;
+              _context77.next = 2;
               return this.rpcClient.simulateContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -10530,19 +11567,19 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
                 args: [request.childIpId, request.parentIpId, request.licenseTermsId, request.licensee]
               });
             case 2:
-              _yield$this$rpcClient32 = _context76.sent;
+              _yield$this$rpcClient32 = _context77.sent;
               call = _yield$this$rpcClient32.request;
-              _context76.next = 6;
+              _context77.next = 6;
               return this.wallet.writeContract(call);
             case 6:
-              return _context76.abrupt("return", _context76.sent);
+              return _context77.abrupt("return", _context77.sent);
             case 7:
             case "end":
-              return _context76.stop();
+              return _context77.stop();
           }
-        }, _callee76, this);
+        }, _callee77, this);
       }));
-      function verifyRegisterDerivative(_x59) {
+      function verifyRegisterDerivative(_x60) {
         return _verifyRegisterDerivative.apply(this, arguments);
       }
       return verifyRegisterDerivative;
@@ -10557,12 +11594,12 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
   }, {
     key: "verifyRegisterDerivativeForAllParents",
     value: (function () {
-      var _verifyRegisterDerivativeForAllParents = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee77(request) {
+      var _verifyRegisterDerivativeForAllParents = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee78(request) {
         var _yield$this$rpcClient33, call;
-        return _regeneratorRuntime().wrap(function _callee77$(_context77) {
-          while (1) switch (_context77.prev = _context77.next) {
+        return _regeneratorRuntime().wrap(function _callee78$(_context78) {
+          while (1) switch (_context78.prev = _context78.next) {
             case 0:
-              _context77.next = 2;
+              _context78.next = 2;
               return this.rpcClient.simulateContract({
                 abi: piLicenseTemplateAbi,
                 address: this.address,
@@ -10571,19 +11608,19 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
                 args: [request.childIpId, request.parentIpIds, request.licenseTermsIds, request.childIpOwner]
               });
             case 2:
-              _yield$this$rpcClient33 = _context77.sent;
+              _yield$this$rpcClient33 = _context78.sent;
               call = _yield$this$rpcClient33.request;
-              _context77.next = 6;
+              _context78.next = 6;
               return this.wallet.writeContract(call);
             case 6:
-              return _context77.abrupt("return", _context77.sent);
+              return _context78.abrupt("return", _context78.sent);
             case 7:
             case "end":
-              return _context77.stop();
+              return _context78.stop();
           }
-        }, _callee77, this);
+        }, _callee78, this);
       }));
-      function verifyRegisterDerivativeForAllParents(_x60) {
+      function verifyRegisterDerivativeForAllParents(_x61) {
         return _verifyRegisterDerivativeForAllParents.apply(this, arguments);
       }
       return verifyRegisterDerivativeForAllParents;
@@ -10607,9 +11644,9 @@ var PiLicenseTemplateClient = /*#__PURE__*/function (_PiLicenseTemplateRea) {
  */
 var RoyaltyModuleClient = /*#__PURE__*/function () {
   function RoyaltyModuleClient(rpcClient, wallet, address) {
-    var _rpcClient$chain10;
+    var _rpcClient$chain11;
     _classCallCheck(this, RoyaltyModuleClient);
-    this.address = address || getAddress(royaltyModuleAddress, (_rpcClient$chain10 = rpcClient.chain) === null || _rpcClient$chain10 === void 0 ? void 0 : _rpcClient$chain10.id);
+    this.address = address || getAddress(royaltyModuleAddress, (_rpcClient$chain11 = rpcClient.chain) === null || _rpcClient$chain11 === void 0 ? void 0 : _rpcClient$chain11.id);
     this.rpcClient = rpcClient;
     this.wallet = wallet;
   }
@@ -10623,12 +11660,12 @@ var RoyaltyModuleClient = /*#__PURE__*/function () {
   return _createClass(RoyaltyModuleClient, [{
     key: "payRoyaltyOnBehalf",
     value: (function () {
-      var _payRoyaltyOnBehalf = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee78(request) {
+      var _payRoyaltyOnBehalf = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee79(request) {
         var _yield$this$rpcClient34, call;
-        return _regeneratorRuntime().wrap(function _callee78$(_context78) {
-          while (1) switch (_context78.prev = _context78.next) {
+        return _regeneratorRuntime().wrap(function _callee79$(_context79) {
+          while (1) switch (_context79.prev = _context79.next) {
             case 0:
-              _context78.next = 2;
+              _context79.next = 2;
               return this.rpcClient.simulateContract({
                 abi: royaltyModuleAbi,
                 address: this.address,
@@ -10637,19 +11674,19 @@ var RoyaltyModuleClient = /*#__PURE__*/function () {
                 args: [request.receiverIpId, request.payerIpId, request.token, request.amount]
               });
             case 2:
-              _yield$this$rpcClient34 = _context78.sent;
+              _yield$this$rpcClient34 = _context79.sent;
               call = _yield$this$rpcClient34.request;
-              _context78.next = 6;
+              _context79.next = 6;
               return this.wallet.writeContract(call);
             case 6:
-              return _context78.abrupt("return", _context78.sent);
+              return _context79.abrupt("return", _context79.sent);
             case 7:
             case "end":
-              return _context78.stop();
+              return _context79.stop();
           }
-        }, _callee78, this);
+        }, _callee79, this);
       }));
-      function payRoyaltyOnBehalf(_x61) {
+      function payRoyaltyOnBehalf(_x62) {
         return _payRoyaltyOnBehalf.apply(this, arguments);
       }
       return payRoyaltyOnBehalf;
@@ -10689,9 +11726,9 @@ var RoyaltyModuleClient = /*#__PURE__*/function () {
  */
 var RoyaltyPolicyLapReadOnlyClient = /*#__PURE__*/function () {
   function RoyaltyPolicyLapReadOnlyClient(rpcClient, address) {
-    var _rpcClient$chain11;
+    var _rpcClient$chain12;
     _classCallCheck(this, RoyaltyPolicyLapReadOnlyClient);
-    this.address = address || getAddress(royaltyPolicyLapAddress, (_rpcClient$chain11 = rpcClient.chain) === null || _rpcClient$chain11 === void 0 ? void 0 : _rpcClient$chain11.id);
+    this.address = address || getAddress(royaltyPolicyLapAddress, (_rpcClient$chain12 = rpcClient.chain) === null || _rpcClient$chain12 === void 0 ? void 0 : _rpcClient$chain12.id);
     this.rpcClient = rpcClient;
   }
 
@@ -10704,11 +11741,11 @@ var RoyaltyPolicyLapReadOnlyClient = /*#__PURE__*/function () {
   return _createClass(RoyaltyPolicyLapReadOnlyClient, [{
     key: "getRoyaltyData",
     value: (function () {
-      var _getRoyaltyData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee79(request) {
-        return _regeneratorRuntime().wrap(function _callee79$(_context79) {
-          while (1) switch (_context79.prev = _context79.next) {
+      var _getRoyaltyData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee80(request) {
+        return _regeneratorRuntime().wrap(function _callee80$(_context80) {
+          while (1) switch (_context80.prev = _context80.next) {
             case 0:
-              _context79.next = 2;
+              _context80.next = 2;
               return this.rpcClient.readContract({
                 abi: royaltyPolicyLapAbi,
                 address: this.address,
@@ -10716,14 +11753,14 @@ var RoyaltyPolicyLapReadOnlyClient = /*#__PURE__*/function () {
                 args: [request.ipId]
               });
             case 2:
-              return _context79.abrupt("return", _context79.sent);
+              return _context80.abrupt("return", _context80.sent);
             case 3:
             case "end":
-              return _context79.stop();
+              return _context80.stop();
           }
-        }, _callee79, this);
+        }, _callee80, this);
       }));
-      function getRoyaltyData(_x62) {
+      function getRoyaltyData(_x63) {
         return _getRoyaltyData.apply(this, arguments);
       }
       return getRoyaltyData;
@@ -10753,12 +11790,12 @@ var RoyaltyPolicyLapClient = /*#__PURE__*/function (_RoyaltyPolicyLapRead) {
   return _createClass(RoyaltyPolicyLapClient, [{
     key: "onRoyaltyPayment",
     value: (function () {
-      var _onRoyaltyPayment = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee80(request) {
+      var _onRoyaltyPayment = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee81(request) {
         var _yield$this$rpcClient35, call;
-        return _regeneratorRuntime().wrap(function _callee80$(_context80) {
-          while (1) switch (_context80.prev = _context80.next) {
+        return _regeneratorRuntime().wrap(function _callee81$(_context81) {
+          while (1) switch (_context81.prev = _context81.next) {
             case 0:
-              _context80.next = 2;
+              _context81.next = 2;
               return this.rpcClient.simulateContract({
                 abi: royaltyPolicyLapAbi,
                 address: this.address,
@@ -10767,19 +11804,19 @@ var RoyaltyPolicyLapClient = /*#__PURE__*/function (_RoyaltyPolicyLapRead) {
                 args: [request.caller, request.ipId, request.token, request.amount]
               });
             case 2:
-              _yield$this$rpcClient35 = _context80.sent;
+              _yield$this$rpcClient35 = _context81.sent;
               call = _yield$this$rpcClient35.request;
-              _context80.next = 6;
+              _context81.next = 6;
               return this.wallet.writeContract(call);
             case 6:
-              return _context80.abrupt("return", _context80.sent);
+              return _context81.abrupt("return", _context81.sent);
             case 7:
             case "end":
-              return _context80.stop();
+              return _context81.stop();
           }
-        }, _callee80, this);
+        }, _callee81, this);
       }));
-      function onRoyaltyPayment(_x63) {
+      function onRoyaltyPayment(_x64) {
         return _onRoyaltyPayment.apply(this, arguments);
       }
       return onRoyaltyPayment;
@@ -10790,20 +11827,21 @@ var RoyaltyPolicyLapClient = /*#__PURE__*/function (_RoyaltyPolicyLapRead) {
 var IPAssetClient = /*#__PURE__*/function () {
   function IPAssetClient(rpcClient, wallet, chainId) {
     _classCallCheck(this, IPAssetClient);
+    this.licensingModuleClient = new LicensingModuleClient(rpcClient, wallet);
+    this.ipAssetRegistryClient = new IpAssetRegistryClient(rpcClient, wallet);
+    this.licenseTemplateClient = new PiLicenseTemplateClient(rpcClient, wallet);
+    this.licenseRegistryReadOnlyClient = new LicenseRegistryReadOnlyClient(rpcClient);
+    this.licenseTokenReadOnlyClient = new LicenseTokenReadOnlyClient(rpcClient);
     this.rpcClient = rpcClient;
     this.chainId = chainId;
-    this.ipAssetRegistryClient = new IpAssetRegistryClient(rpcClient, wallet);
-    this.licensingModuleClient = new LicensingModuleClient(this.rpcClient, wallet);
-    this.licenseTemplateClient = new PiLicenseTemplateClient(this.rpcClient, wallet);
-    this.licenseRegistryReadOnlyClient = new LicenseRegistryReadOnlyClient(this.rpcClient);
   }
 
   /**
    * 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.tokenContract The address of the NFT.
-   *  @param request.tokenId The token identifier of the NFT.
-   *  @param request.txOptions [Optional] The transaction options.
+   *   @param request.tokenContract The address of the NFT.
+   *   @param request.tokenId The token identifier of the NFT.
+   *   @param request.txOptions [Optional] The transaction options.
    * @returns A Promise that resolves to an object containing the transaction hash and optional IP ID if waitForTxn is set to true.
    * @emits IPRegistered (ipId, chainId, tokenContract, tokenId, resolverAddr, metadataProviderAddress, metadata)
    */
@@ -10880,10 +11918,10 @@ var IPAssetClient = /*#__PURE__*/function () {
      * All IPs attached default license terms by default.
      * The derivative IP owner must be the caller or an authorized operator.
      * @param request The request object that contains all data needed to register derivative IP.
-     *  @param request.childIpId The derivative IP ID.
-     *  @param request.parentIpIds The parent IP IDs.
-     *  @param request.licenseTermsIds The IDs of the license terms that the parent IP supports.
-     *  @param request.txOptions [Optional] The transaction options.
+     *   @param request.childIpId The derivative IP ID.
+     *   @param request.parentIpIds The parent IP IDs.
+     *   @param request.licenseTermsIds The IDs of the license terms that the parent IP supports.
+     *   @param request.txOptions [Optional] The transaction options.
      * @returns A Promise that resolves to an object containing the transaction hash.
      */
     )
@@ -10891,83 +11929,85 @@ var IPAssetClient = /*#__PURE__*/function () {
     key: "registerDerivative",
     value: (function () {
       var _registerDerivative = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, _iterator, _step, parentId, i, isAttachedLicenseTerms, txHash;
+        var _request$txOptions2, isChildIpIdRegistered, _iterator, _step, parentId, isParentIpIdRegistered, i, isAttachedLicenseTerms, txHash;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
               _context2.prev = 0;
               _context2.next = 3;
-              return this.isIpIdRegistered(request.childIpId);
+              return this.isRegistered(request.childIpId);
             case 3:
-              if (_context2.sent) {
-                _context2.next = 5;
+              isChildIpIdRegistered = _context2.sent;
+              if (isChildIpIdRegistered) {
+                _context2.next = 6;
                 break;
               }
-              throw new Error("IP asset must be registered before registering derivative");
-            case 5:
+              throw new Error("The child IP with id ".concat(request.childIpId, " is not registered."));
+            case 6:
               _iterator = _createForOfIteratorHelper(request.parentIpIds);
-              _context2.prev = 6;
+              _context2.prev = 7;
               _iterator.s();
-            case 8:
+            case 9:
               if ((_step = _iterator.n()).done) {
-                _context2.next = 16;
+                _context2.next = 18;
                 break;
               }
               parentId = _step.value;
-              _context2.next = 12;
-              return this.isIpIdRegistered(parentId);
-            case 12:
-              if (_context2.sent) {
-                _context2.next = 14;
+              _context2.next = 13;
+              return this.isRegistered(parentId);
+            case 13:
+              isParentIpIdRegistered = _context2.sent;
+              if (isParentIpIdRegistered) {
+                _context2.next = 16;
                 break;
               }
-              throw new Error("Parent IP asset must be registered before registering derivative");
-            case 14:
-              _context2.next = 8;
-              break;
+              throw new Error("The parent IP with id ".concat(parentId, " is not registered."));
             case 16:
-              _context2.next = 21;
+              _context2.next = 9;
               break;
             case 18:
-              _context2.prev = 18;
-              _context2.t0 = _context2["catch"](6);
+              _context2.next = 23;
+              break;
+            case 20:
+              _context2.prev = 20;
+              _context2.t0 = _context2["catch"](7);
               _iterator.e(_context2.t0);
-            case 21:
-              _context2.prev = 21;
+            case 23:
+              _context2.prev = 23;
               _iterator.f();
-              return _context2.finish(21);
-            case 24:
+              return _context2.finish(23);
+            case 26:
               if (!(request.parentIpIds.length !== request.licenseTermsIds.length)) {
-                _context2.next = 26;
+                _context2.next = 28;
                 break;
               }
-              throw new Error("Parent IP IDs and License terms IDs must be provided in pairs");
-            case 26:
+              throw new Error("Parent IP IDs and License terms IDs must be provided in pairs.");
+            case 28:
               i = 0;
-            case 27:
+            case 29:
               if (!(i < request.parentIpIds.length)) {
-                _context2.next = 36;
+                _context2.next = 38;
                 break;
               }
-              _context2.next = 30;
+              _context2.next = 32;
               return this.licenseRegistryReadOnlyClient.hasIpAttachedLicenseTerms({
                 ipId: request.parentIpIds[i],
                 licenseTemplate: request.licenseTemplate || this.licenseTemplateClient.address,
                 licenseTermsId: BigInt(request.licenseTermsIds[i])
               });
-            case 30:
+            case 32:
               isAttachedLicenseTerms = _context2.sent;
               if (isAttachedLicenseTerms) {
-                _context2.next = 33;
+                _context2.next = 35;
                 break;
               }
-              throw new Error("License terms must be attached to the parent ipId before registering derivative");
-            case 33:
+              throw new Error("License terms id ".concat(request.licenseTermsIds[i], " must be attached to the parent ipId ").concat(request.parentIpIds[i], " before registering derivative."));
+            case 35:
               i++;
-              _context2.next = 27;
+              _context2.next = 29;
               break;
-            case 36:
-              _context2.next = 38;
+            case 38:
+              _context2.next = 40;
               return this.licensingModuleClient.registerDerivative({
                 childIpId: request.childIpId,
                 parentIpIds: request.parentIpIds,
@@ -10977,36 +12017,36 @@ var IPAssetClient = /*#__PURE__*/function () {
                 licenseTemplate: request.licenseTemplate || this.licenseTemplateClient.address,
                 royaltyContext: zeroAddress
               });
-            case 38:
+            case 40:
               txHash = _context2.sent;
               if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context2.next = 45;
+                _context2.next = 47;
                 break;
               }
-              _context2.next = 42;
+              _context2.next = 44;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 42:
+            case 44:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 45:
+            case 47:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 46:
-              _context2.next = 51;
-              break;
             case 48:
-              _context2.prev = 48;
+              _context2.next = 53;
+              break;
+            case 50:
+              _context2.prev = 50;
               _context2.t1 = _context2["catch"](0);
               handleError(_context2.t1, "Failed to register derivative");
-            case 51:
+            case 53:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this, [[0, 48], [6, 18, 21, 24]]);
+        }, _callee2, this, [[0, 50], [7, 20, 23, 26]]);
       }));
       function registerDerivative(_x2) {
         return _registerDerivative.apply(this, arguments);
@@ -11019,9 +12059,9 @@ var IPAssetClient = /*#__PURE__*/function () {
      * 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 request.licenseTokenIds The IDs of the license tokens.
-     *  @param request.txOptions [Optional] The transaction options.
+     *   @param request.childIpId The derivative IP ID.
+     *   @param request.licenseTokenIds The IDs of the license tokens.
+     *   @param request.txOptions [Optional] The transaction options.
      * @returns A Promise that resolves to an object containing the transaction hash.
      */
     )
@@ -11029,21 +12069,57 @@ var IPAssetClient = /*#__PURE__*/function () {
     key: "registerDerivativeWithLicenseTokens",
     value: (function () {
       var _registerDerivativeWithLicenseTokens = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(request) {
-        var _request$txOptions3, txHash;
+        var _request$txOptions3, isChildIpIdRegistered, _iterator2, _step2, licenseTokenId, tokenOwnerAddress, txHash;
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
               _context3.prev = 0;
               _context3.next = 3;
-              return this.isIpIdRegistered(request.childIpId);
+              return this.isRegistered(request.childIpId);
             case 3:
-              if (_context3.sent) {
-                _context3.next = 5;
+              isChildIpIdRegistered = _context3.sent;
+              if (isChildIpIdRegistered) {
+                _context3.next = 6;
                 break;
               }
-              throw new Error("IP asset must be registered before registering derivative with license tokens");
-            case 5:
-              _context3.next = 7;
+              throw new Error("The child IP with id ".concat(request.childIpId, " is not registered."));
+            case 6:
+              _iterator2 = _createForOfIteratorHelper(request.licenseTokenIds);
+              _context3.prev = 7;
+              _iterator2.s();
+            case 9:
+              if ((_step2 = _iterator2.n()).done) {
+                _context3.next = 18;
+                break;
+              }
+              licenseTokenId = _step2.value;
+              _context3.next = 13;
+              return this.licenseTokenReadOnlyClient.ownerOf({
+                tokenId: BigInt(licenseTokenId)
+              });
+            case 13:
+              tokenOwnerAddress = _context3.sent;
+              if (tokenOwnerAddress) {
+                _context3.next = 16;
+                break;
+              }
+              throw new Error("License token id ".concat(licenseTokenId, " must be owned by the caller."));
+            case 16:
+              _context3.next = 9;
+              break;
+            case 18:
+              _context3.next = 23;
+              break;
+            case 20:
+              _context3.prev = 20;
+              _context3.t0 = _context3["catch"](7);
+              _iterator2.e(_context3.t0);
+            case 23:
+              _context3.prev = 23;
+              _iterator2.f();
+              return _context3.finish(23);
+            case 26:
+              _context3.next = 28;
               return this.licensingModuleClient.registerDerivativeWithLicenseTokens({
                 childIpId: request.childIpId,
                 licenseTokenIds: request.licenseTokenIds.map(function (id) {
@@ -11051,36 +12127,36 @@ var IPAssetClient = /*#__PURE__*/function () {
                 }),
                 royaltyContext: zeroAddress
               });
-            case 7:
+            case 28:
               txHash = _context3.sent;
               if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.waitForTransaction)) {
-                _context3.next = 14;
+                _context3.next = 35;
                 break;
               }
-              _context3.next = 11;
+              _context3.next = 32;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 11:
+            case 32:
               return _context3.abrupt("return", {
                 txHash: txHash
               });
-            case 14:
+            case 35:
               return _context3.abrupt("return", {
                 txHash: txHash
               });
-            case 15:
-              _context3.next = 20;
+            case 36:
+              _context3.next = 41;
               break;
-            case 17:
-              _context3.prev = 17;
-              _context3.t0 = _context3["catch"](0);
-              handleError(_context3.t0, "Failed to register derivative with license tokens");
-            case 20:
+            case 38:
+              _context3.prev = 38;
+              _context3.t1 = _context3["catch"](0);
+              handleError(_context3.t1, "Failed to register derivative with license tokens");
+            case 41:
             case "end":
               return _context3.stop();
           }
-        }, _callee3, this, [[0, 17]]);
+        }, _callee3, this, [[0, 38], [7, 20, 23, 26]]);
       }));
       function registerDerivativeWithLicenseTokens(_x3) {
         return _registerDerivativeWithLicenseTokens.apply(this, arguments);
@@ -11122,9 +12198,9 @@ var IPAssetClient = /*#__PURE__*/function () {
       return isNFTRegistered;
     }()
   }, {
-    key: "isIpIdRegistered",
+    key: "isRegistered",
     value: function () {
-      var _isIpIdRegistered = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(ipId) {
+      var _isRegistered = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(ipId) {
         return _regeneratorRuntime().wrap(function _callee5$(_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
@@ -11140,10 +12216,10 @@ var IPAssetClient = /*#__PURE__*/function () {
           }
         }, _callee5, this);
       }));
-      function isIpIdRegistered(_x6) {
-        return _isIpIdRegistered.apply(this, arguments);
+      function isRegistered(_x6) {
+        return _isRegistered.apply(this, arguments);
       }
-      return isIpIdRegistered;
+      return isRegistered;
     }()
   }]);
 }();
@@ -11245,22 +12321,22 @@ var PermissionClient = /*#__PURE__*/function () {
 }();
 
 var LicenseClient = /*#__PURE__*/function () {
-  function LicenseClient(rpcClient, wallet, storyClient) {
+  function LicenseClient(rpcClient, wallet) {
     _classCallCheck(this, LicenseClient);
-    this.wallet = wallet;
-    this.rpcClient = rpcClient;
-    this.storyClient = storyClient;
-    this.licenseRegistryClient = new LicenseRegistryEventClient(this.rpcClient);
-    this.licenseTemplateClient = new PiLicenseTemplateClient(this.rpcClient, this.wallet);
-    this.licensingModuleClient = new LicensingModuleClient(this.rpcClient, this.wallet);
-    this.royaltyPolicyLAPClient = new RoyaltyPolicyLapClient(this.rpcClient, this.wallet);
-    this.licenseRegistryReadOnlyClient = new LicenseRegistryReadOnlyClient(this.rpcClient);
+    this.licensingModuleClient = new LicensingModuleClient(rpcClient, wallet);
+    this.licenseRegistryClient = new LicenseRegistryEventClient(rpcClient);
+    this.piLicenseTemplateReadOnlyClient = new PiLicenseTemplateReadOnlyClient(rpcClient);
+    this.licenseTemplateClient = new PiLicenseTemplateClient(rpcClient, wallet);
+    this.royaltyPolicyLAPClient = new RoyaltyPolicyLapClient(rpcClient, wallet);
+    this.licenseRegistryReadOnlyClient = new LicenseRegistryReadOnlyClient(rpcClient);
     this.ipAssetRegistryClient = new IpAssetRegistryClient(rpcClient, wallet);
+    this.rpcClient = rpcClient;
+    this.wallet = wallet;
   }
   /**
    * Convenient function to register a PIL non commercial social remix license to the registry
-   * @param request The request object that contains all data needed to register a PIL non commercial social remix license.
-   *  @param request.txOptions [Optional] The transaction options.
+   * @param request [Optional] The request object that contains all data needed to register a PIL non commercial social remix license.
+   *   @param request.txOptions [Optional] The transaction options.
    * @returns A Promise that resolves to an object containing the optional transaction hash and optional license terms Id.
    * @emits LicenseTermsRegistered (licenseTermsId, licenseTemplate, licenseTerms);
    */
@@ -11309,7 +12385,7 @@ var LicenseClient = /*#__PURE__*/function () {
               });
             case 9:
               txHash = _context.sent;
-              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
+              if (!(request !== null && request !== void 0 && (_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
                 _context.next = 18;
                 break;
               }
@@ -11349,11 +12425,10 @@ 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.mintingFee The fee to be paid when minting a license.
-     *  @param request.currency The ERC20 token to be used to pay the minting fee.
-     *  the token must be registered in story protocol.
-     *  @param request.royaltyPolicy The address of the royalty policy contract which required to StoryProtocol in advance.
-     *  @param request.txOptions [Optional] The transaction options.
+     *   @param request.mintingFee 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.royaltyPolicy The address of the royalty policy contract which required to StoryProtocol in advance.
+     *   @param request.txOptions [Optional] The transaction options.
      * @returns A Promise that resolves to an object containing the optional transaction hash and optional license terms Id.
      * @emits LicenseTermsRegistered (licenseTermsId, licenseTemplate, licenseTerms);
      */
@@ -11443,11 +12518,11 @@ 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.mintingFee 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.royaltyPolicy The address of the royalty policy contract which required to StoryProtocol in advance.
-     *  @param request.txOptions [Optional] The transaction options.
+     *   @param request.mintingFee 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.royaltyPolicy The address of the royalty policy contract which required to StoryProtocol in advance.
+     *   @param request.txOptions [Optional] The transaction options.
      * @returns A Promise that resolves to an object containing the optional transaction hash and optional license terms Id.
      * @emits LicenseTermsRegistered (licenseTermsId, licenseTemplate, licenseTerms);
      */
@@ -11537,14 +12612,10 @@ 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 IP ID.
-     @param request.tokenAddress The address of the NFT.
-     @param request.licenseTemplate The address of the license template.
-     @param request.licenseTermsId The ID of the 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.
-        @param request.licenseTermsId The ID of the license terms.
-     *  @param request.txOptions [Optional] The transaction options.
+     *   @param request.ipId The address of the IP to which the license terms are attached.
+     *   @param request.licenseTemplate The address of the license template.
+     *   @param request.licenseTermsId The ID of the license terms.
+     *   @param request.txOptions [Optional] The transaction options.
      * @returns A Promise that resolves to an object containing the transaction hash.
      */
     )
@@ -11552,66 +12623,85 @@ var LicenseClient = /*#__PURE__*/function () {
     key: "attachLicenseTerms",
     value: (function () {
       var _attachLicenseTerms = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(request) {
-        var _request$txOptions4;
-        var isRegistered, isAttachedLicenseTerms, txHash;
+        var _request$txOptions4, isRegistered, isExisted, isAttachedLicenseTerms, txHash;
         return _regeneratorRuntime().wrap(function _callee4$(_context4) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
-              _context4.next = 2;
+              _context4.prev = 0;
+              _context4.next = 3;
               return this.ipAssetRegistryClient.isRegistered({
                 id: request.ipId
               });
-            case 2:
+            case 3:
               isRegistered = _context4.sent;
               if (isRegistered) {
-                _context4.next = 5;
+                _context4.next = 6;
                 break;
               }
-              throw new Error("IP asset must be registered before attaching license terms");
-            case 5:
-              _context4.next = 7;
+              throw new Error("The IP with id ".concat(request.ipId, " is not registered."));
+            case 6:
+              _context4.next = 8;
+              return this.piLicenseTemplateReadOnlyClient.exists({
+                licenseTermsId: BigInt(request.licenseTermsId)
+              });
+            case 8:
+              isExisted = _context4.sent;
+              if (isExisted) {
+                _context4.next = 11;
+                break;
+              }
+              throw new Error("License terms id ".concat(request.licenseTermsId, " do not exist."));
+            case 11:
+              _context4.next = 13;
               return this.licenseRegistryReadOnlyClient.hasIpAttachedLicenseTerms({
                 ipId: request.ipId,
                 licenseTemplate: request.licenseTemplate || this.licenseTemplateClient.address,
                 licenseTermsId: BigInt(request.licenseTermsId)
               });
-            case 7:
+            case 13:
               isAttachedLicenseTerms = _context4.sent;
               if (!isAttachedLicenseTerms) {
-                _context4.next = 10;
+                _context4.next = 16;
                 break;
               }
-              throw new Error("License terms are already attached to the IP");
-            case 10:
-              _context4.next = 12;
+              throw new Error("License terms id ".concat(request.licenseTermsId, " is already attached to the IP with id ").concat(request.ipId, "."));
+            case 16:
+              _context4.next = 18;
               return this.licensingModuleClient.attachLicenseTerms({
                 ipId: request.ipId,
                 licenseTemplate: request.licenseTemplate || this.licenseTemplateClient.address,
                 licenseTermsId: BigInt(request.licenseTermsId)
               });
-            case 12:
+            case 18:
               txHash = _context4.sent;
               if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.waitForTransaction)) {
-                _context4.next = 19;
+                _context4.next = 25;
                 break;
               }
-              _context4.next = 16;
+              _context4.next = 22;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 16:
+            case 22:
               return _context4.abrupt("return", {
                 txHash: txHash
               });
-            case 19:
+            case 25:
               return _context4.abrupt("return", {
                 txHash: txHash
               });
-            case 20:
+            case 26:
+              _context4.next = 31;
+              break;
+            case 28:
+              _context4.prev = 28;
+              _context4.t0 = _context4["catch"](0);
+              handleError(_context4.t0, "Failed to attach license terms");
+            case 31:
             case "end":
               return _context4.stop();
           }
-        }, _callee4, this);
+        }, _callee4, this, [[0, 28]]);
       }));
       function attachLicenseTerms(_x4) {
         return _attachLicenseTerms.apply(this, arguments);
@@ -11631,12 +12721,12 @@ var LicenseClient = /*#__PURE__*/function () {
      * 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.
-     *  @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.txOptions [Optional] The transaction options.
+     *   @param request.licensorIpId The licensor IP ID.
+     *   @param request.licenseTemplate The address of the license template.
+     *   @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.txOptions [Optional] The transaction options.
      * @returns A Promise that resolves to an object containing the transaction hash and optional license token ID if waitForTxn is set to true.
      * @emits LicenseTokensMinted (msg.sender, licensorIpId, licenseTemplate, licenseTermsId, amount, receiver, startLicenseTokenId);
      */
@@ -11645,26 +12735,50 @@ var LicenseClient = /*#__PURE__*/function () {
     key: "mintLicenseTokens",
     value: (function () {
       var _mintLicenseTokens = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(request) {
-        var _request$txOptions5, isAttachedLicenseTerms, txHash, txReceipt, targetLogs;
+        var _request$txOptions5, isLicenseIpIdRegistered, isExisted, isAttachedLicenseTerms, txHash, txReceipt, targetLogs;
         return _regeneratorRuntime().wrap(function _callee5$(_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
               _context5.prev = 0;
               _context5.next = 3;
+              return this.ipAssetRegistryClient.isRegistered({
+                id: request.licensorIpId
+              });
+            case 3:
+              isLicenseIpIdRegistered = _context5.sent;
+              if (isLicenseIpIdRegistered) {
+                _context5.next = 6;
+                break;
+              }
+              throw new Error("The licensor IP with id ".concat(request.licensorIpId, " is not registered."));
+            case 6:
+              _context5.next = 8;
+              return this.piLicenseTemplateReadOnlyClient.exists({
+                licenseTermsId: BigInt(request.licenseTermsId)
+              });
+            case 8:
+              isExisted = _context5.sent;
+              if (isExisted) {
+                _context5.next = 11;
+                break;
+              }
+              throw new Error("License terms id ".concat(request.licenseTermsId, " do not exist."));
+            case 11:
+              _context5.next = 13;
               return this.licenseRegistryReadOnlyClient.hasIpAttachedLicenseTerms({
                 ipId: request.licensorIpId,
                 licenseTemplate: request.licenseTemplate || this.licenseTemplateClient.address,
                 licenseTermsId: BigInt(request.licenseTermsId)
               });
-            case 3:
+            case 13:
               isAttachedLicenseTerms = _context5.sent;
               if (isAttachedLicenseTerms) {
-                _context5.next = 6;
+                _context5.next = 16;
                 break;
               }
-              throw new Error("License terms are not attached to the IP");
-            case 6:
-              _context5.next = 8;
+              throw new Error("License terms id ".concat(request.licenseTermsId, " is not attached to the IP with id ").concat(request.licensorIpId, "."));
+            case 16:
+              _context5.next = 18;
               return this.licensingModuleClient.mintLicenseTokens({
                 licensorIpId: request.licensorIpId,
                 licenseTemplate: request.licenseTemplate || this.licenseTemplateClient.address,
@@ -11673,39 +12787,39 @@ var LicenseClient = /*#__PURE__*/function () {
                 receiver: request.receiver || this.wallet.account.address,
                 royaltyContext: zeroAddress
               });
-            case 8:
+            case 18:
               txHash = _context5.sent;
               if (!((_request$txOptions5 = request.txOptions) !== null && _request$txOptions5 !== void 0 && _request$txOptions5.waitForTransaction)) {
-                _context5.next = 17;
+                _context5.next = 27;
                 break;
               }
-              _context5.next = 12;
+              _context5.next = 22;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 12:
+            case 22:
               txReceipt = _context5.sent;
               targetLogs = this.licensingModuleClient.parseTxLicenseTokensMintedEvent(txReceipt);
               return _context5.abrupt("return", {
                 txHash: txHash,
                 licenseTokenId: targetLogs[0].startLicenseTokenId.toString()
               });
-            case 17:
+            case 27:
               return _context5.abrupt("return", {
                 txHash: txHash
               });
-            case 18:
-              _context5.next = 23;
+            case 28:
+              _context5.next = 33;
               break;
-            case 20:
-              _context5.prev = 20;
+            case 30:
+              _context5.prev = 30;
               _context5.t0 = _context5["catch"](0);
               handleError(_context5.t0, "Failed to mint license tokens");
-            case 23:
+            case 33:
             case "end":
               return _context5.stop();
           }
-        }, _callee5, this, [[0, 20]]);
+        }, _callee5, this, [[0, 30]]);
       }));
       function mintLicenseTokens(_x5) {
         return _mintLicenseTokens.apply(this, arguments);
@@ -12115,17 +13229,17 @@ var StoryAPIClient = /*#__PURE__*/function () {
 var RoyaltyClient = /*#__PURE__*/function () {
   function RoyaltyClient(rpcClient, wallet) {
     _classCallCheck(this, RoyaltyClient);
+    this.royaltyPolicyLapClient = new RoyaltyPolicyLapClient(rpcClient, wallet);
+    this.royaltyModuleClient = new RoyaltyModuleClient(rpcClient, wallet);
+    this.ipAssetRegistryClient = new IpAssetRegistryClient(rpcClient, wallet);
     this.rpcClient = rpcClient;
     this.wallet = wallet;
-    this.royaltyVaultImplClient = new IpRoyaltyVaultImplClient(this.rpcClient, this.wallet);
-    this.royaltyPolicyLAPClient = new RoyaltyPolicyLapClient(this.rpcClient, this.wallet);
-    this.royaltyModuleClient = new RoyaltyModuleClient(this.rpcClient, this.wallet);
   }
 
   /**
    * Allows ancestors to claim the royalty tokens and any accrued revenue tokens
    * @param request -  The request object that contains all data needed to collect royalty tokens.
-   *   @param request.ancestorIpId The ip id of the ancestor to whom the royalty tokens belong to.
+   *   @param request.parentIpId The ip id of the ancestor to whom the royalty tokens belong to.
    *   @param request.royaltyVaultIpId The id of the royalty vault.
    *   @param request.txOptions [Optional] The transaction options.
    * @returns A Promise that resolves to an object containing the transaction hash and optional the amount of royalty tokens collected if waitForTxn is set to true.
@@ -12135,53 +13249,65 @@ var RoyaltyClient = /*#__PURE__*/function () {
     key: "collectRoyaltyTokens",
     value: (function () {
       var _collectRoyaltyTokens = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$txOptions, proxyAddress, ipRoyaltyVault, txHash, txReceipt, targetLogs;
+        var _request$txOptions, isParentIpIdRegistered, proxyAddress, ipRoyaltyVault, txHash, txReceipt, targetLogs;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               _context.prev = 0;
               _context.next = 3;
-              return this.getRoyaltyVaultProxyAddress(request.royaltyVaultIpId);
+              return this.ipAssetRegistryClient.isRegistered({
+                id: request.parentIpId
+              });
             case 3:
+              isParentIpIdRegistered = _context.sent;
+              if (isParentIpIdRegistered) {
+                _context.next = 6;
+                break;
+              }
+              throw new Error("The parent IP with id ".concat(request.parentIpId, " is not registered."));
+            case 6:
+              _context.next = 8;
+              return this.getRoyaltyVaultProxyAddress(request.royaltyVaultIpId);
+            case 8:
               proxyAddress = _context.sent;
               ipRoyaltyVault = new IpRoyaltyVaultImplClient(this.rpcClient, this.wallet, proxyAddress);
-              _context.next = 7;
+              _context.next = 12;
               return ipRoyaltyVault.collectRoyaltyTokens({
-                ancestorIpId: request.ancestorIpId
+                ancestorIpId: request.parentIpId
               });
-            case 7:
+            case 12:
               txHash = _context.sent;
               if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 16;
+                _context.next = 21;
                 break;
               }
-              _context.next = 11;
+              _context.next = 16;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 11:
+            case 16:
               txReceipt = _context.sent;
               targetLogs = ipRoyaltyVault.parseTxRoyaltyTokensCollectedEvent(txReceipt);
               return _context.abrupt("return", {
                 txHash: txHash,
                 royaltyTokensCollected: targetLogs[0].royaltyTokensCollected.toString()
               });
-            case 16:
+            case 21:
               return _context.abrupt("return", {
                 txHash: txHash
               });
-            case 17:
-              _context.next = 22;
+            case 22:
+              _context.next = 27;
               break;
-            case 19:
-              _context.prev = 19;
+            case 24:
+              _context.prev = 24;
               _context.t0 = _context["catch"](0);
               handleError(_context.t0, "Failed to collect royalty tokens");
-            case 22:
+            case 27:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 19]]);
+        }, _callee, this, [[0, 24]]);
       }));
       function collectRoyaltyTokens(_x) {
         return _collectRoyaltyTokens.apply(this, arguments);
@@ -12203,48 +13329,72 @@ var RoyaltyClient = /*#__PURE__*/function () {
     key: "payRoyaltyOnBehalf",
     value: (function () {
       var _payRoyaltyOnBehalf = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, txHash;
+        var _request$txOptions2, isReceiverRegistered, isPayerRegistered, txHash;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
               _context2.prev = 0;
               _context2.next = 3;
+              return this.ipAssetRegistryClient.isRegistered({
+                id: request.receiverIpId
+              });
+            case 3:
+              isReceiverRegistered = _context2.sent;
+              if (isReceiverRegistered) {
+                _context2.next = 6;
+                break;
+              }
+              throw new Error("The receiver IP with id ".concat(request.receiverIpId, " is not registered"));
+            case 6:
+              _context2.next = 8;
+              return this.ipAssetRegistryClient.isRegistered({
+                id: request.payerIpId
+              });
+            case 8:
+              isPayerRegistered = _context2.sent;
+              if (isPayerRegistered) {
+                _context2.next = 11;
+                break;
+              }
+              throw new Error("The payer IP with id ".concat(request.payerIpId, " is not registered"));
+            case 11:
+              _context2.next = 13;
               return this.royaltyModuleClient.payRoyaltyOnBehalf({
                 receiverIpId: request.receiverIpId,
                 payerIpId: request.payerIpId,
                 token: request.token,
                 amount: request.amount
               });
-            case 3:
+            case 13:
               txHash = _context2.sent;
               if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context2.next = 10;
+                _context2.next = 20;
                 break;
               }
-              _context2.next = 7;
+              _context2.next = 17;
               return this.rpcClient.waitForTransactionReceipt({
                 hash: txHash
               });
-            case 7:
+            case 17:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 10:
+            case 20:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 11:
-              _context2.next = 16;
+            case 21:
+              _context2.next = 26;
               break;
-            case 13:
-              _context2.prev = 13;
+            case 23:
+              _context2.prev = 23;
               _context2.t0 = _context2["catch"](0);
               handleError(_context2.t0, "Failed to pay royalty on behalf");
-            case 16:
+            case 26:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this, [[0, 13]]);
+        }, _callee2, this, [[0, 23]]);
       }));
       function payRoyaltyOnBehalf(_x2) {
         return _payRoyaltyOnBehalf.apply(this, arguments);
@@ -12300,18 +13450,20 @@ var RoyaltyClient = /*#__PURE__*/function () {
       return claimableRevenue;
     }()
     /**
-     * Snapshots the claimable revenue and royalty token amounts.
-     * @param request - The request object that contains all data needed to snapshot.
+     * Allows token holders to claim by a list of snapshot ids based on the token balance at certain snapshot
+     * @param request - The request object that contains all data needed to claim revenue.
+     *   @param request.snapshotIds The list of snapshot ids.
      *   @param request.royaltyVaultIpId The id of the royalty vault.
+     *   @param request.token The revenue token to claim.
      *   @param request.txOptions [Optional] The transaction options.
-     * @returns A Promise that resolves to an object containing the transaction hash and optional snapshotId if waitForTxn is set to true.
-     * @emits SnapshotCompleted (snapshotId, snapshotTimestamp, unclaimedTokens).
+     * @returns A Promise that resolves to an object containing the transaction hash and optional claimableToken if waitForTxn is set to true.
+     * @emits RevenueTokenClaimed (claimer, token, amount).
      */
     )
   }, {
-    key: "snapshot",
+    key: "claimRevenue",
     value: (function () {
-      var _snapshot = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(request) {
+      var _claimRevenue = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(request) {
         var _request$txOptions3, proxyAddress, ipRoyaltyVault, txHash, txReceipt, targetLogs;
         return _regeneratorRuntime().wrap(function _callee4$(_context4) {
           while (1) switch (_context4.prev = _context4.next) {
@@ -12323,7 +13475,12 @@ var RoyaltyClient = /*#__PURE__*/function () {
               proxyAddress = _context4.sent;
               ipRoyaltyVault = new IpRoyaltyVaultImplClient(this.rpcClient, this.wallet, proxyAddress);
               _context4.next = 7;
-              return ipRoyaltyVault.snapshot();
+              return ipRoyaltyVault.claimRevenueBySnapshotBatch({
+                snapshotIds: request.snapshotIds.map(function (id) {
+                  return BigInt(id);
+                }),
+                token: request.token
+              });
             case 7:
               txHash = _context4.sent;
               if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.waitForTransaction)) {
@@ -12336,10 +13493,10 @@ var RoyaltyClient = /*#__PURE__*/function () {
               });
             case 11:
               txReceipt = _context4.sent;
-              targetLogs = ipRoyaltyVault.parseTxSnapshotCompletedEvent(txReceipt);
+              targetLogs = ipRoyaltyVault.parseTxRevenueTokenClaimedEvent(txReceipt);
               return _context4.abrupt("return", {
                 txHash: txHash,
-                snapshotId: targetLogs[0].snapshotId
+                claimableToken: targetLogs[0].amount
               });
             case 16:
               return _context4.abrupt("return", {
@@ -12351,14 +13508,78 @@ var RoyaltyClient = /*#__PURE__*/function () {
             case 19:
               _context4.prev = 19;
               _context4.t0 = _context4["catch"](0);
-              handleError(_context4.t0, "Failed to snapshot");
+              handleError(_context4.t0, "Failed to claim revenue");
             case 22:
             case "end":
               return _context4.stop();
           }
         }, _callee4, this, [[0, 19]]);
       }));
-      function snapshot(_x4) {
+      function claimRevenue(_x4) {
+        return _claimRevenue.apply(this, arguments);
+      }
+      return claimRevenue;
+    }()
+    /**
+     * Snapshots the claimable revenue and royalty token amounts.
+     * @param request - The request object that contains all data needed to snapshot.
+     *   @param request.royaltyVaultIpId The id of the royalty vault.
+     *   @param request.txOptions [Optional] The transaction options.
+     * @returns A Promise that resolves to an object containing the transaction hash and optional snapshotId if waitForTxn is set to true.
+     * @emits SnapshotCompleted (snapshotId, snapshotTimestamp, unclaimedTokens).
+     */
+    )
+  }, {
+    key: "snapshot",
+    value: (function () {
+      var _snapshot = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(request) {
+        var _request$txOptions4, proxyAddress, ipRoyaltyVault, txHash, txReceipt, targetLogs;
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.prev = 0;
+              _context5.next = 3;
+              return this.getRoyaltyVaultProxyAddress(request.royaltyVaultIpId);
+            case 3:
+              proxyAddress = _context5.sent;
+              ipRoyaltyVault = new IpRoyaltyVaultImplClient(this.rpcClient, this.wallet, proxyAddress);
+              _context5.next = 7;
+              return ipRoyaltyVault.snapshot();
+            case 7:
+              txHash = _context5.sent;
+              if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.waitForTransaction)) {
+                _context5.next = 16;
+                break;
+              }
+              _context5.next = 11;
+              return this.rpcClient.waitForTransactionReceipt({
+                hash: txHash
+              });
+            case 11:
+              txReceipt = _context5.sent;
+              targetLogs = ipRoyaltyVault.parseTxSnapshotCompletedEvent(txReceipt);
+              return _context5.abrupt("return", {
+                txHash: txHash,
+                snapshotId: targetLogs[0].snapshotId
+              });
+            case 16:
+              return _context5.abrupt("return", {
+                txHash: txHash
+              });
+            case 17:
+              _context5.next = 22;
+              break;
+            case 19:
+              _context5.prev = 19;
+              _context5.t0 = _context5["catch"](0);
+              handleError(_context5.t0, "Failed to snapshot");
+            case 22:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this, [[0, 19]]);
+      }));
+      function snapshot(_x5) {
         return _snapshot.apply(this, arguments);
       }
       return snapshot;
@@ -12366,25 +13587,43 @@ var RoyaltyClient = /*#__PURE__*/function () {
   }, {
     key: "getRoyaltyVaultProxyAddress",
     value: function () {
-      var _getRoyaltyVaultProxyAddress = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(royaltyVaultIpId) {
-        var data;
-        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
+      var _getRoyaltyVaultProxyAddress = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(royaltyVaultIpId) {
+        var isRoyaltyVaultIpIdRegistered, data;
+        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
             case 0:
-              _context5.next = 2;
-              return this.royaltyPolicyLAPClient.getRoyaltyData({
-                ipId: royaltyVaultIpId
+              _context6.next = 2;
+              return this.ipAssetRegistryClient.isRegistered({
+                id: royaltyVaultIpId
               });
             case 2:
-              data = _context5.sent;
-              return _context5.abrupt("return", data[1]);
-            case 4:
+              isRoyaltyVaultIpIdRegistered = _context6.sent;
+              if (isRoyaltyVaultIpIdRegistered) {
+                _context6.next = 5;
+                break;
+              }
+              throw new Error("The royalty vault IP with id ".concat(royaltyVaultIpId, " is not registered."));
+            case 5:
+              _context6.next = 7;
+              return this.royaltyPolicyLapClient.getRoyaltyData({
+                ipId: royaltyVaultIpId
+              });
+            case 7:
+              data = _context6.sent;
+              if (!(!data[1] || data[1] === "0x")) {
+                _context6.next = 10;
+                break;
+              }
+              throw new Error("The royalty vault IP with id ".concat(royaltyVaultIpId, " address is not set."));
+            case 10:
+              return _context6.abrupt("return", data[1]);
+            case 11:
             case "end":
-              return _context5.stop();
+              return _context6.stop();
           }
-        }, _callee5, this);
+        }, _callee6, this);
       }));
-      function getRoyaltyVaultProxyAddress(_x5) {
+      function getRoyaltyVaultProxyAddress(_x6) {
         return _getRoyaltyVaultProxyAddress.apply(this, arguments);
       }
       return getRoyaltyVaultProxyAddress;
@@ -12480,7 +13719,7 @@ var StoryClient = /*#__PURE__*/function () {
     key: "license",
     get: function get() {
       if (this._license === null) {
-        this._license = new LicenseClient(this.rpcClient, this.wallet, this.storyClient);
+        this._license = new LicenseClient(this.rpcClient, this.wallet);
       }
       return this._license;
     }