@story-protocol/core-sdk 0.0.1-beta-rc.11 → 0.0.1-beta-rc.13

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

@@ -1,6 +1,6 @@
-import { getAddress, encodeAbiParameters, parseAbiParameters, decodeEventLog, encodeFunctionData, zeroAddress, stringToHex, createPublicClient, createWalletClient } from 'viem';
+import { defineChain, decodeEventLog, getAddress, encodeFunctionData, zeroAddress, stringToHex, createPublicClient, createWalletClient } from 'viem';
 import * as dotenv from 'dotenv';
-import { polygonMumbai, sepolia as sepolia$1, mainnet } from 'viem/chains';
+import { sepolia as sepolia$1 } from 'viem/chains';
 import axios from 'axios';
 
 function toPrimitive(t, r) {
@@ -413,31 +413,12 @@ function _asyncToGenerator(fn) {
   };
 }
 
-function handleError(error, msg) {
-  if (error instanceof Error) {
-    throw new Error("".concat(msg, ": ").concat(error.message));
-  }
-  throw new Error("".concat(msg, ": Unknown error type"));
-}
-
-var AddressZero = "0x0000000000000000000000000000000000000000";
-var HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
-var SepoliaChainId = "11155111";
-
 function _arrayLikeToArray(arr, len) {
   if (len == null || len > arr.length) len = arr.length;
   for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
   return arr2;
 }
 
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-
 function _unsupportedIterableToArray(o, minLen) {
   if (!o) return;
   if (typeof o === "string") return _arrayLikeToArray(o, minLen);
@@ -447,6 +428,215 @@ function _unsupportedIterableToArray(o, minLen) {
   if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
 }
 
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+      var F = function () {};
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var normalCompletion = true,
+    didErr = false,
+    err;
+  return {
+    s: function () {
+      it = it.call(o);
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
+function parseToBigInt(num) {
+  return BigInt(num);
+}
+function waitTxAndFilterLog(_x, _x2, _x3) {
+  return _waitTxAndFilterLog.apply(this, arguments);
+}
+function _waitTxAndFilterLog() {
+  _waitTxAndFilterLog = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(client, txHash, params) {
+    var txReceipt, targetLogs, _iterator, _step, log, currentLog;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return client.waitForTransactionReceipt({
+            hash: txHash,
+            confirmations: params.confirmations,
+            pollingInterval: params.pollingInterval,
+            timeout: params.timeout
+          });
+        case 2:
+          txReceipt = _context.sent;
+          targetLogs = [];
+          _iterator = _createForOfIteratorHelper(txReceipt.logs);
+          _context.prev = 5;
+          _iterator.s();
+        case 7:
+          if ((_step = _iterator.n()).done) {
+            _context.next = 21;
+            break;
+          }
+          log = _step.value;
+          _context.prev = 9;
+          if (!(params.from && log.address !== params.from.toLowerCase())) {
+            _context.next = 12;
+            break;
+          }
+          return _context.abrupt("continue", 19);
+        case 12:
+          currentLog = decodeEventLog({
+            abi: params.abi,
+            eventName: params.eventName,
+            data: log.data,
+            topics: log.topics
+          });
+          targetLogs.push(currentLog);
+          _context.next = 19;
+          break;
+        case 16:
+          _context.prev = 16;
+          _context.t0 = _context["catch"](9);
+          return _context.abrupt("continue", 19);
+        case 19:
+          _context.next = 7;
+          break;
+        case 21:
+          _context.next = 26;
+          break;
+        case 23:
+          _context.prev = 23;
+          _context.t1 = _context["catch"](5);
+          _iterator.e(_context.t1);
+        case 26:
+          _context.prev = 26;
+          _iterator.f();
+          return _context.finish(26);
+        case 29:
+          if (!(targetLogs.length === 0)) {
+            _context.next = 31;
+            break;
+          }
+          throw new Error("not found event ".concat(params.eventName, " in target transaction"));
+        case 31:
+          return _context.abrupt("return", targetLogs);
+        case 32:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[5, 23, 26, 29], [9, 16]]);
+  }));
+  return _waitTxAndFilterLog.apply(this, arguments);
+}
+function waitTx(_x4, _x5, _x6) {
+  return _waitTx.apply(this, arguments);
+}
+function _waitTx() {
+  _waitTx = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(client, txHash, params) {
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return client.waitForTransactionReceipt(_objectSpread2({
+            hash: txHash
+          }, params));
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _waitTx.apply(this, arguments);
+}
+function chainStringToViemChain(chainId) {
+  switch (chainId) {
+    case "11155111":
+    case "sepolia":
+      return sepolia$1;
+    case "1513":
+    case "storyTestnet":
+      return storyTestnet$1;
+    default:
+      throw new Error("chainId ".concat(chainId, " not supported"));
+  }
+}
+var storyTestnet$1 = defineChain({
+  id: 1513,
+  name: "story-network",
+  nativeCurrency: {
+    name: "Ether",
+    symbol: "SEP",
+    decimals: 18
+  },
+  rpcUrls: {
+    "default": {
+      http: ["https://story-network.rpc.caldera.xyz/http"],
+      webSocket: ["wss://story-network.rpc.caldera.xyz/ws"]
+    }
+  },
+  blockExplorers: {
+    "default": {
+      name: "Explorer",
+      url: "https://story-network.explorer.caldera.xyz"
+    }
+  },
+  //TODO: wait for Ze confirm with config information
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 5882
+    }
+  },
+  testnet: true
+});
+var chain = {
+  sepolia: "11155111",
+  storyTestnet: "1513",
+  11155111: "11155111",
+  1513: "1513"
+};
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+
 function _nonIterableSpread() {
   throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
@@ -779,19 +969,19 @@ var IPAssetRegistryABI = [{
     type: "uint256"
   }, {
     indexed: false,
-    internalType: "address",
-    name: "resolver",
-    type: "address"
+    internalType: "string",
+    name: "name",
+    type: "string"
   }, {
     indexed: false,
-    internalType: "address",
-    name: "provider",
-    type: "address"
+    internalType: "string",
+    name: "uri",
+    type: "string"
   }, {
     indexed: false,
-    internalType: "bytes",
-    name: "metadata",
-    type: "bytes"
+    internalType: "uint256",
+    name: "registrationDate",
+    type: "uint256"
   }],
   name: "IPRegistered",
   type: "event"
@@ -831,6 +1021,24 @@ var IPAssetRegistryABI = [{
   }],
   stateMutability: "view",
   type: "function"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "tokenContract",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "tokenId",
+    type: "uint256"
+  }],
+  name: "register",
+  outputs: [{
+    internalType: "address",
+    name: "id",
+    type: "address"
+  }],
+  stateMutability: "nonpayable",
+  type: "function"
 }];
 
 var LicensingModuleABI = [{
@@ -847,11 +1055,16 @@ var LicensingModuleABI = [{
     type: "address"
   }, {
     indexed: false,
-    internalType: "address[]",
-    name: "parentIpIds",
-    type: "address[]"
+    internalType: "address",
+    name: "licenseTemplate",
+    type: "address"
+  }, {
+    indexed: false,
+    internalType: "uint256",
+    name: "licenseTermsId",
+    type: "uint256"
   }],
-  name: "IpIdLinkedToParents",
+  name: "LicenseTermsAttached",
   type: "event"
 }, {
   anonymous: false,
@@ -863,154 +1076,67 @@ var LicensingModuleABI = [{
   }, {
     indexed: true,
     internalType: "address",
-    name: "ipId",
+    name: "licensorIpId",
+    type: "address"
+  }, {
+    indexed: false,
+    internalType: "address",
+    name: "licenseTemplate",
     type: "address"
   }, {
     indexed: true,
     internalType: "uint256",
-    name: "policyId",
+    name: "licenseTermsId",
     type: "uint256"
   }, {
     indexed: false,
     internalType: "uint256",
-    name: "index",
+    name: "amount",
     type: "uint256"
   }, {
     indexed: false,
-    internalType: "bool",
-    name: "isInherited",
-    type: "bool"
+    internalType: "address",
+    name: "receiver",
+    type: "address"
+  }, {
+    indexed: false,
+    internalType: "uint256",
+    name: "startLicenseTokenId",
+    type: "uint256"
   }],
-  name: "PolicyAddedToIpId",
+  name: "LicenseTokensMinted",
   type: "event"
 }, {
-  anonymous: false,
   inputs: [{
-    indexed: true,
-    internalType: "uint256",
-    name: "policyId",
-    type: "uint256"
+    internalType: "address",
+    name: "ipId",
+    type: "address"
   }, {
-    indexed: true,
     internalType: "address",
-    name: "policyFrameworkManager",
-    type: "address"
-  }, {
-    indexed: false,
-    internalType: "bytes",
-    name: "frameworkData",
-    type: "bytes"
-  }, {
-    indexed: false,
-    internalType: "address",
-    name: "royaltyPolicy",
-    type: "address"
-  }, {
-    indexed: false,
-    internalType: "bytes",
-    name: "royaltyData",
-    type: "bytes"
-  }, {
-    indexed: false,
-    internalType: "uint256",
-    name: "mintingFee",
-    type: "uint256"
-  }, {
-    indexed: false,
-    internalType: "address",
-    name: "mintingFeeToken",
-    type: "address"
-  }],
-  name: "PolicyRegistered",
-  type: "event"
-}, {
-  inputs: [{
-    internalType: "address",
-    name: "ipId",
+    name: "licenseTemplate",
     type: "address"
   }, {
     internalType: "uint256",
-    name: "polId",
-    type: "uint256"
-  }],
-  name: "addPolicyToIp",
-  outputs: [{
-    internalType: "uint256",
-    name: "indexOnIpId",
+    name: "licenseTermsId",
     type: "uint256"
   }],
+  name: "attachLicenseTerms",
+  outputs: [],
   stateMutability: "nonpayable",
   type: "function"
 }, {
   inputs: [{
-    components: [{
-      internalType: "bool",
-      name: "isLicenseTransferable",
-      type: "bool"
-    }, {
-      internalType: "address",
-      name: "policyFramework",
-      type: "address"
-    }, {
-      internalType: "bytes",
-      name: "frameworkData",
-      type: "bytes"
-    }, {
-      internalType: "address",
-      name: "royaltyPolicy",
-      type: "address"
-    }, {
-      internalType: "bytes",
-      name: "royaltyData",
-      type: "bytes"
-    }, {
-      internalType: "uint256",
-      name: "mintingFee",
-      type: "uint256"
-    }, {
-      internalType: "address",
-      name: "mintingFeeToken",
-      type: "address"
-    }],
-    internalType: "struct Licensing.Policy",
-    name: "pol",
-    type: "tuple"
-  }],
-  name: "getPolicyId",
-  outputs: [{
-    internalType: "uint256",
-    name: "policyId",
-    type: "uint256"
-  }],
-  stateMutability: "view",
-  type: "function"
-}, {
-  inputs: [{
-    internalType: "uint256[]",
-    name: "licenseIds",
-    type: "uint256[]"
+    internalType: "address",
+    name: "licensorIpId",
+    type: "address"
   }, {
     internalType: "address",
-    name: "childIpId",
+    name: "licenseTemplate",
     type: "address"
   }, {
-    internalType: "bytes",
-    name: "royaltyContext",
-    type: "bytes"
-  }],
-  name: "linkIpToParents",
-  outputs: [],
-  stateMutability: "nonpayable",
-  type: "function"
-}, {
-  inputs: [{
     internalType: "uint256",
-    name: "policyId",
+    name: "licenseTermsId",
     type: "uint256"
-  }, {
-    internalType: "address",
-    name: "licensorIpId",
-    type: "address"
   }, {
     internalType: "uint256",
     name: "amount",
@@ -1024,60 +1150,116 @@ var LicensingModuleABI = [{
     name: "royaltyContext",
     type: "bytes"
   }],
-  name: "mintLicense",
+  name: "mintLicenseTokens",
   outputs: [{
     internalType: "uint256",
-    name: "licenseId",
+    name: "startLicenseTokenId",
     type: "uint256"
   }],
   stateMutability: "nonpayable",
   type: "function"
+}];
+
+var PILicenseTemplateABI = [{
+  anonymous: false,
+  inputs: [{
+    indexed: true,
+    internalType: "uint256",
+    name: "licenseTermsId",
+    type: "uint256"
+  }, {
+    indexed: true,
+    internalType: "address",
+    name: "licenseTemplate",
+    type: "address"
+  }, {
+    indexed: false,
+    internalType: "bytes",
+    name: "licenseTerms",
+    type: "bytes"
+  }],
+  name: "LicenseTermsRegistered",
+  type: "event"
 }, {
   inputs: [{
     components: [{
       internalType: "bool",
-      name: "isLicenseTransferable",
+      name: "transferable",
       type: "bool"
     }, {
       internalType: "address",
-      name: "policyFramework",
+      name: "royaltyPolicy",
       type: "address"
     }, {
-      internalType: "bytes",
-      name: "frameworkData",
-      type: "bytes"
+      internalType: "uint256",
+      name: "mintingFee",
+      type: "uint256"
+    }, {
+      internalType: "uint256",
+      name: "expiration",
+      type: "uint256"
+    }, {
+      internalType: "bool",
+      name: "commercialUse",
+      type: "bool"
+    }, {
+      internalType: "bool",
+      name: "commercialAttribution",
+      type: "bool"
     }, {
       internalType: "address",
-      name: "royaltyPolicy",
+      name: "commercializerChecker",
       type: "address"
     }, {
       internalType: "bytes",
-      name: "royaltyData",
+      name: "commercializerCheckerData",
       type: "bytes"
+    }, {
+      internalType: "uint32",
+      name: "commercialRevShare",
+      type: "uint32"
     }, {
       internalType: "uint256",
-      name: "mintingFee",
+      name: "commercialRevCelling",
+      type: "uint256"
+    }, {
+      internalType: "bool",
+      name: "derivativesAllowed",
+      type: "bool"
+    }, {
+      internalType: "bool",
+      name: "derivativesAttribution",
+      type: "bool"
+    }, {
+      internalType: "bool",
+      name: "derivativesApproval",
+      type: "bool"
+    }, {
+      internalType: "bool",
+      name: "derivativesReciprocal",
+      type: "bool"
+    }, {
+      internalType: "uint256",
+      name: "derivativeRevCelling",
       type: "uint256"
     }, {
       internalType: "address",
-      name: "mintingFeeToken",
+      name: "currency",
       type: "address"
     }],
-    internalType: "struct Licensing.Policy",
-    name: "pol",
+    internalType: "struct PILTerms",
+    name: "terms",
     type: "tuple"
   }],
-  name: "registerPolicy",
+  name: "getLicenseTermsId",
   outputs: [{
     internalType: "uint256",
-    name: "policyId",
+    name: "selectedLicenseTermsId",
     type: "uint256"
   }],
-  stateMutability: "nonpayable",
+  stateMutability: "view",
   type: "function"
-}];
-
-var PILPolicyFrameworkManagerABI = [{
+}, {
   inputs: [{
     components: [{
       internalType: "bool",
@@ -1091,148 +1273,219 @@ var PILPolicyFrameworkManagerABI = [{
       internalType: "uint256",
       name: "mintingFee",
       type: "uint256"
+    }, {
+      internalType: "uint256",
+      name: "expiration",
+      type: "uint256"
+    }, {
+      internalType: "bool",
+      name: "commercialUse",
+      type: "bool"
+    }, {
+      internalType: "bool",
+      name: "commercialAttribution",
+      type: "bool"
     }, {
       internalType: "address",
-      name: "mintingFeeToken",
+      name: "commercializerChecker",
       type: "address"
     }, {
-      components: [{
-        internalType: "bool",
-        name: "attribution",
-        type: "bool"
-      }, {
-        internalType: "bool",
-        name: "commercialUse",
-        type: "bool"
-      }, {
-        internalType: "bool",
-        name: "commercialAttribution",
-        type: "bool"
-      }, {
-        internalType: "address",
-        name: "commercializerChecker",
-        type: "address"
-      }, {
-        internalType: "bytes",
-        name: "commercializerCheckerData",
-        type: "bytes"
-      }, {
-        internalType: "uint32",
-        name: "commercialRevShare",
-        type: "uint32"
-      }, {
-        internalType: "bool",
-        name: "derivativesAllowed",
-        type: "bool"
-      }, {
-        internalType: "bool",
-        name: "derivativesAttribution",
-        type: "bool"
-      }, {
-        internalType: "bool",
-        name: "derivativesApproval",
-        type: "bool"
-      }, {
-        internalType: "bool",
-        name: "derivativesReciprocal",
-        type: "bool"
-      }, {
-        internalType: "string[]",
-        name: "territories",
-        type: "string[]"
-      }, {
-        internalType: "string[]",
-        name: "distributionChannels",
-        type: "string[]"
-      }, {
-        internalType: "string[]",
-        name: "contentRestrictions",
-        type: "string[]"
-      }],
-      internalType: "struct PILPolicy",
-      name: "policy",
-      type: "tuple"
+      internalType: "bytes",
+      name: "commercializerCheckerData",
+      type: "bytes"
+    }, {
+      internalType: "uint32",
+      name: "commercialRevShare",
+      type: "uint32"
+    }, {
+      internalType: "uint256",
+      name: "commercialRevCelling",
+      type: "uint256"
+    }, {
+      internalType: "bool",
+      name: "derivativesAllowed",
+      type: "bool"
+    }, {
+      internalType: "bool",
+      name: "derivativesAttribution",
+      type: "bool"
+    }, {
+      internalType: "bool",
+      name: "derivativesApproval",
+      type: "bool"
+    }, {
+      internalType: "bool",
+      name: "derivativesReciprocal",
+      type: "bool"
+    }, {
+      internalType: "uint256",
+      name: "derivativeRevCelling",
+      type: "uint256"
+    }, {
+      internalType: "address",
+      name: "currency",
+      type: "address"
     }],
-    internalType: "struct RegisterPILPolicyParams",
-    name: "params",
+    internalType: "struct PILTerms",
+    name: "terms",
     type: "tuple"
   }],
-  name: "registerPolicy",
+  name: "registerLicenseTerms",
   outputs: [{
     internalType: "uint256",
-    name: "policyId",
+    name: "selectedLicenseTermsId",
     type: "uint256"
   }],
   stateMutability: "nonpayable",
   type: "function"
 }];
 
-var RegistrationModuleABI = [{
+var IRoyaltyPolicyLAPABI = [{
   inputs: [{
-    internalType: "uint256[]",
-    name: "licenseIds",
-    type: "uint256[]"
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }],
+  name: "getRoyaltyData",
+  outputs: [{
+    internalType: "bool",
+    name: "",
+    type: "bool"
   }, {
     internalType: "address",
-    name: "tokenContract",
+    name: "",
     type: "address"
   }, {
-    internalType: "uint256",
-    name: "tokenId",
-    type: "uint256"
+    internalType: "uint32",
+    name: "",
+    type: "uint32"
   }, {
-    internalType: "string",
-    name: "ipName",
-    type: "string"
+    internalType: "address[]",
+    name: "",
+    type: "address[]"
   }, {
-    internalType: "bytes32",
-    name: "contentHash",
-    type: "bytes32"
+    internalType: "uint32[]",
+    name: "",
+    type: "uint32[]"
+  }],
+  stateMutability: "view",
+  type: "function"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "caller",
+    type: "address"
   }, {
-    internalType: "string",
-    name: "externalURL",
-    type: "string"
+    internalType: "address",
+    name: "ipId",
+    type: "address"
   }, {
-    internalType: "bytes",
-    name: "royaltyContext",
-    type: "bytes"
+    internalType: "address",
+    name: "token",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "amount",
+    type: "uint256"
   }],
-  name: "registerDerivativeIp",
+  name: "onRoyaltyPayment",
+  outputs: [],
+  stateMutability: "nonpayable",
+  type: "function"
+}];
+
+var IpRoyaltyVaultABI = [{
+  inputs: [{
+    internalType: "uint256[]",
+    name: "snapshotIds",
+    type: "uint256[]"
+  }, {
+    internalType: "address",
+    name: "token",
+    type: "address"
+  }],
+  name: "claimRevenueBySnapshotBatch",
   outputs: [],
   stateMutability: "nonpayable",
   type: "function"
 }, {
   inputs: [{
     internalType: "uint256",
-    name: "policyId",
+    name: "snapshotId",
     type: "uint256"
   }, {
+    internalType: "address[]",
+    name: "tokens",
+    type: "address[]"
+  }],
+  name: "claimRevenueByTokenBatch",
+  outputs: [],
+  stateMutability: "nonpayable",
+  type: "function"
+}, {
+  inputs: [{
     internalType: "address",
-    name: "tokenContract",
+    name: "account",
     type: "address"
   }, {
     internalType: "uint256",
-    name: "tokenId",
+    name: "snapshotId",
     type: "uint256"
   }, {
-    internalType: "string",
-    name: "ipName",
-    type: "string"
-  }, {
-    internalType: "bytes32",
-    name: "contentHash",
-    type: "bytes32"
-  }, {
-    internalType: "string",
-    name: "externalURL",
-    type: "string"
+    internalType: "address",
+    name: "token",
+    type: "address"
   }],
-  name: "registerRootIp",
+  name: "claimableRevenue",
+  outputs: [{
+    internalType: "uint256",
+    name: "",
+    type: "uint256"
+  }],
+  stateMutability: "view",
+  type: "function"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "ancestorIpId",
+    type: "address"
+  }],
+  name: "collectRoyaltyTokens",
+  outputs: [],
+  stateMutability: "nonpayable",
+  type: "function"
+}, {
+  inputs: [],
+  name: "ipId",
   outputs: [{
     internalType: "address",
     name: "",
     type: "address"
   }],
+  stateMutability: "view",
+  type: "function"
+}];
+
+var IRoyaltyModuleABI = [{
+  inputs: [{
+    internalType: "address",
+    name: "receiverIpId",
+    type: "address"
+  }, {
+    internalType: "address",
+    name: "payerIpId",
+    type: "address"
+  }, {
+    internalType: "address",
+    name: "token",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "amount",
+    type: "uint256"
+  }],
+  name: "payRoyaltyOnBehalf",
+  outputs: [],
   stateMutability: "nonpayable",
   type: "function"
 }];
@@ -1257,6 +1510,18 @@ var ErrorsABI = [{
   inputs: [],
   name: "AccessControlled__ZeroAddress",
   type: "error"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "signer",
+    type: "address"
+  }, {
+    internalType: "address",
+    name: "to",
+    type: "address"
+  }],
+  name: "AccessController__BothCallerAndRecipientAreNotRegisteredModule",
+  type: "error"
 }, {
   inputs: [],
   name: "AccessController__CallerIsNotIPAccount",
@@ -1297,241 +1562,485 @@ var ErrorsABI = [{
   inputs: [],
   name: "AccessController__PermissionIsNotValid",
   type: "error"
+}, {
+  inputs: [],
+  name: "AccessController__SignerIsZeroAddress",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ArbitrationPolicySP__NotDisputeModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ArbitrationPolicySP__ZeroDisputeModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ArbitrationPolicySP__ZeroPaymentToken",
+  type: "error"
+}, {
+  inputs: [],
+  name: "BasePolicyFrameworkManager__CallerNotLicensingModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "CoreMetadataModule__MetadataAlreadyFrozen",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotAbleToResolve",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotDisputeInitiator",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotInDisputeState",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotRegisteredIpId",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotWhitelistedArbitrationPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotWhitelistedArbitrationRelayer",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotWhitelistedDisputeTag",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__ZeroArbitrationPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__ZeroArbitrationRelayer",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__ZeroDisputeTag",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__ZeroLinkToDisputeEvidence",
+  type: "error"
+}, {
+  inputs: [],
+  name: "Governance__InconsistentState",
+  type: "error"
+}, {
+  inputs: [],
+  name: "Governance__NewStateIsTheSameWithOldState",
+  type: "error"
+}, {
+  inputs: [],
+  name: "Governance__OnlyProtocolAdmin",
+  type: "error"
+}, {
+  inputs: [],
+  name: "Governance__ProtocolPaused",
+  type: "error"
 }, {
   inputs: [{
-    internalType: "address",
-    name: "to",
-    type: "address"
+    internalType: "string",
+    name: "interfaceName",
+    type: "string"
   }],
-  name: "AccessController__RecipientIsNotRegisteredModule",
+  name: "Governance__UnsupportedInterface",
   type: "error"
 }, {
   inputs: [],
-  name: "AccessController__SignerIsZeroAddress",
+  name: "Governance__ZeroAddress",
   type: "error"
 }, {
   inputs: [],
-  name: "AncestorsVaultLAP__AlreadyClaimed",
+  name: "IPAccountRegistry_InvalidIpAccountImpl",
   type: "error"
 }, {
   inputs: [],
-  name: "AncestorsVaultLAP__ClaimerNotAnAncestor",
+  name: "IPAccount__ExpiredSignature",
   type: "error"
 }, {
   inputs: [],
-  name: "AncestorsVaultLAP__ERC20BalanceNotZero",
+  name: "IPAccount__InvalidAccessController",
   type: "error"
 }, {
   inputs: [],
-  name: "AncestorsVaultLAP__ETHBalanceNotZero",
+  name: "IPAccount__InvalidCalldata",
   type: "error"
 }, {
   inputs: [],
-  name: "AncestorsVaultLAP__InvalidAncestorsHash",
+  name: "IPAccount__InvalidSignature",
   type: "error"
 }, {
   inputs: [],
-  name: "AncestorsVaultLAP__InvalidClaimer",
+  name: "IPAccount__InvalidSigner",
   type: "error"
 }, {
   inputs: [],
-  name: "AncestorsVaultLAP__TransferFailed",
+  name: "IPAssetRegistry__AlreadyRegistered",
   type: "error"
 }, {
   inputs: [],
-  name: "AncestorsVaultLAP__ZeroRoyaltyPolicyLAP",
+  name: "IPAssetRegistry__IPAccountAlreadyCreated",
   type: "error"
 }, {
   inputs: [],
-  name: "ArbitrationPolicySP__NotDisputeModule",
+  name: "IPAssetRegistry__InvalidAccount",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAssetRegistry__InvalidMetadataProvider",
+  type: "error"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "contractAddress",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "tokenId",
+    type: "uint256"
+  }],
+  name: "IPAssetRegistry__InvalidToken",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAssetRegistry__NotYetRegistered",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAssetRegistry__RegistrantUnauthorized",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAssetRegistry__ResolverInvalid",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAssetRegistry__Unauthorized",
   type: "error"
 }, {
-  inputs: [],
-  name: "ArbitrationPolicySP__ZeroDisputeModule",
+  inputs: [{
+    internalType: "address",
+    name: "contractAddress",
+    type: "address"
+  }],
+  name: "IPAssetRegistry__UnsupportedIERC721",
   type: "error"
 }, {
-  inputs: [],
-  name: "ArbitrationPolicySP__ZeroPaymentToken",
+  inputs: [{
+    internalType: "address",
+    name: "contractAddress",
+    type: "address"
+  }],
+  name: "IPAssetRegistry__UnsupportedIERC721Metadata",
   type: "error"
 }, {
   inputs: [],
-  name: "DisputeModule__NotAbleToResolve",
+  name: "IPResolver_InvalidIP",
   type: "error"
 }, {
   inputs: [],
-  name: "DisputeModule__NotDisputeInitiator",
+  name: "IPResolver_Unauthorized",
   type: "error"
 }, {
   inputs: [],
-  name: "DisputeModule__NotInDisputeState",
+  name: "IpRoyaltyVault__AlreadyClaimed",
   type: "error"
 }, {
   inputs: [],
-  name: "DisputeModule__NotRegisteredIpId",
+  name: "IpRoyaltyVault__ClaimerNotAnAncestor",
   type: "error"
 }, {
   inputs: [],
-  name: "DisputeModule__NotWhitelistedArbitrationPolicy",
+  name: "IpRoyaltyVault__IpTagged",
   type: "error"
 }, {
   inputs: [],
-  name: "DisputeModule__NotWhitelistedArbitrationRelayer",
+  name: "IpRoyaltyVault__NotRoyaltyPolicyLAP",
   type: "error"
 }, {
   inputs: [],
-  name: "DisputeModule__NotWhitelistedDisputeTag",
+  name: "IpRoyaltyVault__SnapshotIntervalTooShort",
   type: "error"
 }, {
   inputs: [],
-  name: "DisputeModule__UnauthorizedAccess",
+  name: "IpRoyaltyVault__ZeroDisputeModule",
   type: "error"
 }, {
   inputs: [],
-  name: "DisputeModule__ZeroArbitrationPolicy",
+  name: "IpRoyaltyVault__ZeroIpId",
   type: "error"
 }, {
   inputs: [],
-  name: "DisputeModule__ZeroArbitrationRelayer",
+  name: "IpRoyaltyVault__ZeroRoyaltyPolicyLAP",
   type: "error"
 }, {
   inputs: [],
-  name: "DisputeModule__ZeroDisputeTag",
+  name: "LicenseRegistry__CallerNotLicensingModule",
   type: "error"
 }, {
-  inputs: [],
-  name: "DisputeModule__ZeroLinkToDisputeEvidence",
+  inputs: [{
+    internalType: "address",
+    name: "childIpId",
+    type: "address"
+  }],
+  name: "LicenseRegistry__DerivativeAlreadyRegistered",
   type: "error"
 }, {
-  inputs: [],
-  name: "Governance__InconsistentState",
+  inputs: [{
+    internalType: "address",
+    name: "childIpId",
+    type: "address"
+  }],
+  name: "LicenseRegistry__DerivativeIpAlreadyHasLicense",
   type: "error"
 }, {
-  inputs: [],
-  name: "Governance__NewStateIsTheSameWithOldState",
+  inputs: [{
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }],
+  name: "LicenseRegistry__DerivativeIsParent",
   type: "error"
 }, {
-  inputs: [],
-  name: "Governance__OnlyProtocolAdmin",
+  inputs: [{
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "index",
+    type: "uint256"
+  }, {
+    internalType: "uint256",
+    name: "length",
+    type: "uint256"
+  }],
+  name: "LicenseRegistry__IndexOutOfBounds",
   type: "error"
 }, {
-  inputs: [],
-  name: "Governance__ProtocolPaused",
+  inputs: [{
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }],
+  name: "LicenseRegistry__IpExpired",
   type: "error"
 }, {
   inputs: [{
-    internalType: "string",
-    name: "interfaceName",
-    type: "string"
+    internalType: "address",
+    name: "licenseTemplate",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "licenseTermsId",
+    type: "uint256"
   }],
-  name: "Governance__UnsupportedInterface",
+  name: "LicenseRegistry__LicenseTermsNotExists",
   type: "error"
 }, {
   inputs: [],
-  name: "Governance__ZeroAddress",
+  name: "LicenseRegistry__NoParentIp",
   type: "error"
 }, {
-  inputs: [],
-  name: "IPAccountRegistry_InvalidIpAccountImpl",
+  inputs: [{
+    internalType: "address",
+    name: "licenseTemplate",
+    type: "address"
+  }],
+  name: "LicenseRegistry__NotLicenseTemplate",
   type: "error"
 }, {
   inputs: [],
-  name: "IPAccount__ExpiredSignature",
+  name: "LicenseRegistry__NotTransferable",
   type: "error"
 }, {
-  inputs: [],
-  name: "IPAccount__InvalidAccessController",
+  inputs: [{
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }],
+  name: "LicenseRegistry__ParentIpExpired",
   type: "error"
 }, {
-  inputs: [],
-  name: "IPAccount__InvalidCalldata",
+  inputs: [{
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "licenseTermsId",
+    type: "uint256"
+  }],
+  name: "LicenseRegistry__ParentIpHasNoLicenseTerms",
   type: "error"
 }, {
-  inputs: [],
-  name: "IPAccount__InvalidSignature",
+  inputs: [{
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }],
+  name: "LicenseRegistry__ParentIpTagged",
   type: "error"
 }, {
-  inputs: [],
-  name: "IPAccount__InvalidSigner",
+  inputs: [{
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }, {
+    internalType: "address",
+    name: "licenseTemplate",
+    type: "address"
+  }],
+  name: "LicenseRegistry__ParentIpUnmachedLicenseTemplate",
   type: "error"
 }, {
-  inputs: [],
-  name: "IPAssetRegistry__AlreadyRegistered",
+  inputs: [{
+    internalType: "address",
+    name: "licenseTemplate",
+    type: "address"
+  }],
+  name: "LicenseRegistry__UnregisteredLicenseTemplate",
   type: "error"
 }, {
   inputs: [],
-  name: "IPAssetRegistry__IPAccountAlreadyCreated",
+  name: "LicenseRegistry__ZeroDisputeModule",
   type: "error"
 }, {
   inputs: [],
-  name: "IPAssetRegistry__InvalidAccount",
+  name: "LicenseRegistry__ZeroLicensingModule",
   type: "error"
 }, {
-  inputs: [],
-  name: "IPAssetRegistry__InvalidMetadataProvider",
+  inputs: [{
+    internalType: "address",
+    name: "licenseTemplate",
+    type: "address"
+  }, {
+    internalType: "address",
+    name: "anotherLicenseTemplate",
+    type: "address"
+  }],
+  name: "LicenseToken__AllLicenseTokensMustFromSameLicenseTemplate",
   type: "error"
 }, {
   inputs: [],
-  name: "IPAssetRegistry__NotYetRegistered",
+  name: "LicenseToken__CallerNotLicensingModule",
   type: "error"
 }, {
-  inputs: [],
-  name: "IPAssetRegistry__RegistrantUnauthorized",
+  inputs: [{
+    internalType: "uint256",
+    name: "tokenId",
+    type: "uint256"
+  }, {
+    internalType: "uint256",
+    name: "expiredAt",
+    type: "uint256"
+  }, {
+    internalType: "uint256",
+    name: "currentTimestamp",
+    type: "uint256"
+  }],
+  name: "LicenseToken__LicenseTokenExpired",
   type: "error"
 }, {
-  inputs: [],
-  name: "IPAssetRegistry__ResolverInvalid",
+  inputs: [{
+    internalType: "uint256",
+    name: "tokenId",
+    type: "uint256"
+  }, {
+    internalType: "address",
+    name: "iPowner",
+    type: "address"
+  }, {
+    internalType: "address",
+    name: "tokenOwner",
+    type: "address"
+  }],
+  name: "LicenseToken__NotLicenseTokenOwner",
   type: "error"
 }, {
   inputs: [],
-  name: "IPAssetRegistry__Unauthorized",
+  name: "LicenseToken__NotTransferable",
   type: "error"
 }, {
-  inputs: [],
-  name: "IPResolver_InvalidIP",
+  inputs: [{
+    internalType: "uint256",
+    name: "tokenId",
+    type: "uint256"
+  }],
+  name: "LicenseToken__RevokedLicense",
   type: "error"
 }, {
   inputs: [],
-  name: "IPResolver_Unauthorized",
+  name: "LicenseToken__ZeroDisputeModule",
   type: "error"
 }, {
   inputs: [],
-  name: "LicenseRegistry__CallerNotLicensingModule",
+  name: "LicenseToken__ZeroLicensingModule",
   type: "error"
 }, {
   inputs: [],
-  name: "LicenseRegistry__NotTransferable",
+  name: "LicensingModule__CallerNotLicenseRegistry",
   type: "error"
 }, {
-  inputs: [],
-  name: "LicenseRegistry__RevokedLicense",
+  inputs: [{
+    internalType: "address",
+    name: "caller",
+    type: "address"
+  }, {
+    internalType: "address",
+    name: "licensorIpId",
+    type: "address"
+  }, {
+    internalType: "address",
+    name: "licenseTemplate",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "licenseTermsId",
+    type: "uint256"
+  }],
+  name: "LicensingModule__CallerNotLicensorAndIpHasNotAttachedLicenseTerms",
   type: "error"
 }, {
   inputs: [],
-  name: "LicenseRegistry__ZeroDisputeModule",
+  name: "LicensingModule__CallerNotLicensorAndPolicyNotSet",
   type: "error"
 }, {
   inputs: [],
-  name: "LicenseRegistry__ZeroLicensingModule",
+  name: "LicensingModule__CommercialTermInNonCommercialPolicy",
   type: "error"
 }, {
-  inputs: [],
-  name: "LicensingModuleAware__CallerNotLicensingModule",
+  inputs: [{
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }],
+  name: "LicensingModule__DerivativeAlreadyHasLicenseTerms",
   type: "error"
 }, {
   inputs: [],
-  name: "LicensingModule__CallerNotLicenseRegistry",
+  name: "LicensingModule__DerivativeAlreadyRegistered",
   type: "error"
 }, {
   inputs: [],
-  name: "LicensingModule__CallerNotLicensorAndPolicyNotSet",
+  name: "LicensingModule__DerivativeIsParent",
   type: "error"
 }, {
   inputs: [],
-  name: "LicensingModule__CommercialTermInNonCommercialPolicy",
+  name: "LicensingModule__DerivativeRevShareSumExceedsMaxRNFTSupply",
   type: "error"
 }, {
   inputs: [],
-  name: "LicensingModule__DerivativeRevShareSumExceedsMaxRNFTSupply",
+  name: "LicensingModule__DerivativesCannotAddLicenseTerms",
   type: "error"
 }, {
   inputs: [],
@@ -1555,11 +2064,19 @@ var ErrorsABI = [{
   type: "error"
 }, {
   inputs: [],
-  name: "LicensingModule__IncompatibleLicensorCommercialPolicy",
+  name: "LicensingModule__IncompatibleLicensorRoyaltyDerivativeRevShare",
   type: "error"
 }, {
-  inputs: [],
-  name: "LicensingModule__IncompatibleLicensorRoyaltyDerivativeRevShare",
+  inputs: [{
+    internalType: "address",
+    name: "royaltyPolicy",
+    type: "address"
+  }, {
+    internalType: "address",
+    name: "anotherRoyaltyPolicy",
+    type: "address"
+  }],
+  name: "LicensingModule__IncompatibleRoyaltyPolicy",
   type: "error"
 }, {
   inputs: [],
@@ -1577,6 +2094,54 @@ var ErrorsABI = [{
   inputs: [],
   name: "LicensingModule__InvalidPolicyFramework",
   type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__IpAlreadyLinked",
+  type: "error"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "childIpId",
+    type: "address"
+  }],
+  name: "LicensingModule__LicenseNotCompatibleForDerivative",
+  type: "error"
+}, {
+  inputs: [{
+    internalType: "uint256",
+    name: "ipLength",
+    type: "uint256"
+  }, {
+    internalType: "uint256",
+    name: "licenseTermsLength",
+    type: "uint256"
+  }],
+  name: "LicensingModule__LicenseTermsLengthMismatch",
+  type: "error"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "licenseTemplate",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "licenseTermsId",
+    type: "uint256"
+  }],
+  name: "LicensingModule__LicenseTermsNotFound",
+  type: "error"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "childIpId",
+    type: "address"
+  }, {
+    internalType: "uint256[]",
+    name: "licenseTokenIds",
+    type: "uint256[]"
+  }],
+  name: "LicensingModule__LicenseTokenNotCompatibleForDerivative",
+  type: "error"
 }, {
   inputs: [],
   name: "LicensingModule__LicensorDoesntHaveThisPolicy",
@@ -1593,6 +2158,10 @@ var ErrorsABI = [{
   inputs: [],
   name: "LicensingModule__LinkingRevokedLicense",
   type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__MintAmountZero",
+  type: "error"
 }, {
   inputs: [],
   name: "LicensingModule__MintLicenseParamFailed",
@@ -1605,6 +2174,14 @@ var ErrorsABI = [{
   inputs: [],
   name: "LicensingModule__MismatchBetweenRoyaltyPolicy",
   type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__NoLicenseToken",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__NoParentIp",
+  type: "error"
 }, {
   inputs: [],
   name: "LicensingModule__NotLicensee",
@@ -1621,6 +2198,14 @@ var ErrorsABI = [{
   inputs: [],
   name: "LicensingModule__ParentIdEqualThanChild",
   type: "error"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }],
+  name: "LicensingModule__ParentIpHasNoLicenseTerms",
+  type: "error"
 }, {
   inputs: [],
   name: "LicensingModule__PolicyAlreadySetForIpId",
@@ -1629,6 +2214,18 @@ var ErrorsABI = [{
   inputs: [],
   name: "LicensingModule__PolicyNotFound",
   type: "error"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "receiver",
+    type: "address"
+  }],
+  name: "LicensingModule__ReceiverCheckFailed",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__ReceiverZeroAddress",
+  type: "error"
 }, {
   inputs: [],
   name: "LicensingModule__RegisterPolicyFrameworkMismatch",
@@ -1759,15 +2356,15 @@ var ErrorsABI = [{
   type: "error"
 }, {
   inputs: [],
-  name: "RegistrationModule__InvalidOwner",
+  name: "RoyaltyModule__CanOnlyMintSelectedPolicy",
   type: "error"
 }, {
   inputs: [],
-  name: "RoyaltyModule__CanOnlyMintSelectedPolicy",
+  name: "RoyaltyModule__IncompatibleRoyaltyPolicy",
   type: "error"
 }, {
   inputs: [],
-  name: "RoyaltyModule__IncompatibleRoyaltyPolicy",
+  name: "RoyaltyModule__IpIsTagged",
   type: "error"
 }, {
   inputs: [],
@@ -1783,15 +2380,15 @@ var ErrorsABI = [{
   type: "error"
 }, {
   inputs: [],
-  name: "RoyaltyModule__NotRegisteredIpId",
+  name: "RoyaltyModule__NotWhitelistedRoyaltyPolicy",
   type: "error"
 }, {
   inputs: [],
-  name: "RoyaltyModule__NotWhitelistedRoyaltyPolicy",
+  name: "RoyaltyModule__NotWhitelistedRoyaltyToken",
   type: "error"
 }, {
   inputs: [],
-  name: "RoyaltyModule__NotWhitelistedRoyaltyToken",
+  name: "RoyaltyModule__ZeroDisputeModule",
   type: "error"
 }, {
   inputs: [],
@@ -1821,30 +2418,10 @@ var ErrorsABI = [{
   inputs: [],
   name: "RoyaltyPolicyLAP__ImplementationAlreadySet",
   type: "error"
-}, {
-  inputs: [],
-  name: "RoyaltyPolicyLAP__InvalidAncestors",
-  type: "error"
-}, {
-  inputs: [],
-  name: "RoyaltyPolicyLAP__InvalidAncestorsHash",
-  type: "error"
-}, {
-  inputs: [],
-  name: "RoyaltyPolicyLAP__InvalidAncestorsLength",
-  type: "error"
-}, {
-  inputs: [],
-  name: "RoyaltyPolicyLAP__InvalidAncestorsRoyalty",
-  type: "error"
 }, {
   inputs: [],
   name: "RoyaltyPolicyLAP__InvalidParentRoyaltiesLength",
   type: "error"
-}, {
-  inputs: [],
-  name: "RoyaltyPolicyLAP__InvalidRoyaltyAmountLength",
-  type: "error"
 }, {
   inputs: [],
   name: "RoyaltyPolicyLAP__LastPositionNotAbleToMintLicense",
@@ -1859,15 +2436,15 @@ var ErrorsABI = [{
   type: "error"
 }, {
   inputs: [],
-  name: "RoyaltyPolicyLAP__TransferFailed",
+  name: "RoyaltyPolicyLAP__UnlinkableToParents",
   type: "error"
 }, {
   inputs: [],
-  name: "RoyaltyPolicyLAP__UnlinkableToParents",
+  name: "RoyaltyPolicyLAP__ZeroAncestorsVaultImpl",
   type: "error"
 }, {
   inputs: [],
-  name: "RoyaltyPolicyLAP__ZeroAncestorsVaultImpl",
+  name: "RoyaltyPolicyLAP__ZeroIpRoyaltyVaultBeacon",
   type: "error"
 }, {
   inputs: [],
@@ -1905,544 +2482,238 @@ var sepolia = {
   MockERC721: "0x16d50f333B264b153B7BF1DD9fe65A2707B3281b",
   MockTokenGatedHook: "0x28C32a4B5B3E186d7f658C051d3Bb4a95243209a",
   ModuleRegistry: "0x5Aac3177F496F503Ac724A0D0A697f6ba9dA2C27",
-  PILPolicyFrameworkManager: "0xeAABf2b80B7e069EE449B5629590A1cc0F9bC9C2",
+  PILicenseTemplate: "0xeAABf2b80B7e069EE449B5629590A1cc0F9bC9C2",
   RegistrationModule: "0x613128e88b568768764824f898C8135efED97fA6",
   RoyaltyModule: "0xA6bEf9CC650A16939566c1da5d5088f3F028a865",
   RoyaltyPolicyLAP: "0x16eF58e959522727588921A92e9084d36E5d3855",
   TokenWithdrawalModule: "0x66738a5722e9Cd91B694bA39146CFEcE95457F04"
 };
-
-var IPAccountABI = [].concat(_toConsumableArray(IPAccountImplABI), _toConsumableArray(ErrorsABI));
-var IPAssetRegistryConfig = {
-  abi: IPAssetRegistryABI,
-  address: getAddress(sepolia.IPAssetRegistry)
+var storyTestnet = {
+  AccessController: "0x7e253Df9b0fC872746877Fa362b2cAf32712d770",
+  ArbitrationPolicySP: "0xA25bc70932282b35407e0DC08cc9C91f6b00CEf0",
+  CoreMetadataModule: "0x8A8FBAaEB6A0B7736ebde31c6F49CccD808232bA",
+  CoreMetadataViewModule: "0x8A8FBAaEB6A0B7736ebde31c6F49CccD808232bA",
+  DisputeModule: "0x6d54456Ae5DCbDC0C9E2713cC8E650fE4f445c7C",
+  Governance: "0x63F4A670A8b518ef5eb291559BdAbea4b31c1AC4",
+  IPAccountImpl: "0x38cAfD16502B1d61c6399A18d6Fa1Ea8CEca3678",
+  IPAccountRegistry: "0x8448d0F77D7e67e0814f83D988aB3344D46bb1E4",
+  IPAssetRegistry: "0x862de97662a1231FFc14038eC1BE93aB129D2169",
+  IpRoyaltyVaultBeacon: "0xE92Cdf428f07D92248b6b15ce59a9d5597428F21",
+  IpRoyaltyVaultImpl: "0x8Be22cc2D13ADF496a417D9C616dA4a253c68Af8",
+  LicenseRegistry: "0x0c3D467537FAd845a78728CEdc3D9447338c5422",
+  LicenseToken: "0xD40b7bCA204f96a346021e31c9ad54FF495226e7",
+  LicensingModule: "0xEeDDE5529122b621105798860F235c28FD3aBA40",
+  MockERC20: "0xA36F2A4A02f5C215d1b3630f71A4Ff55B5492AAE",
+  MockERC721: "0x83DD606d14CcEb629dE9Bf8Aad7aE63767dB476f",
+  MockTokenGatedHook: "0x80519d82FBE474AB9E863A066AC32E3eeAFc8F11",
+  ModuleRegistry: "0xf2965E3B6251905Dd1E8671077760D07b0408cf2",
+  PILicenseTemplate: "0xd0Be223ae9719bBD93447ecf5289319CCf8cA227",
+  RoyaltyModule: "0x551AD8CD7893003cE00500aC2aCF1E327763D9f6",
+  RoyaltyPolicyLAP: "0x2EcdB5bD12a037dCb9De0Ab7957f35FEeF758eA6",
+  TokenWithdrawalModule: "0xC573E5c36B8FA5108b78f7357947972D030699d5"
 };
-var AccessControllerConfig = {
-  abi: [].concat(_toConsumableArray(AccessControllerABI), _toConsumableArray(ErrorsABI)),
-  address: getAddress(sepolia.AccessController)
+var contractAddress = {
+  sepolia: sepolia,
+  11155111: sepolia,
+  storyTestnet: storyTestnet,
+  1513: storyTestnet
 };
-var DisputeModuleConfig = {
-  abi: [].concat(_toConsumableArray(DisputeModuleABI), _toConsumableArray(ErrorsABI)),
-  address: getAddress(sepolia.DisputeModule)
+
+var IPAccountABI = [].concat(_toConsumableArray(IPAccountImplABI), _toConsumableArray(ErrorsABI));
+var getIPAssetRegistryConfig = function getIPAssetRegistryConfig(chain) {
+  return {
+    abi: IPAssetRegistryABI,
+    address: getAddress(contractAddress[chain].IPAssetRegistry)
+  };
 };
-var LicenseRegistryConfig = {
-  abi: IERC1155ABI,
-  address: getAddress(sepolia.LicenseRegistry)
+var getAccessControllerConfig = function getAccessControllerConfig(chain) {
+  return {
+    abi: [].concat(_toConsumableArray(AccessControllerABI), _toConsumableArray(ErrorsABI)),
+    address: getAddress(contractAddress[chain].AccessController)
+  };
 };
-var LicensingModuleConfig = {
-  abi: [].concat(_toConsumableArray(LicensingModuleABI), _toConsumableArray(ErrorsABI)),
-  address: getAddress(sepolia.LicensingModule)
+var getDisputeModuleConfig = function getDisputeModuleConfig(chain) {
+  return {
+    abi: [].concat(_toConsumableArray(DisputeModuleABI), _toConsumableArray(ErrorsABI)),
+    address: getAddress(contractAddress[chain].DisputeModule)
+  };
 };
-var RegistrationModuleConfig = {
-  abi: [].concat(_toConsumableArray(RegistrationModuleABI), _toConsumableArray(ErrorsABI)),
-  address: getAddress(sepolia.RegistrationModule)
+var getLicenseRegistryConfig = function getLicenseRegistryConfig(chain) {
+  return {
+    abi: IERC1155ABI,
+    address: getAddress(contractAddress[chain].LicenseRegistry)
+  };
 };
-var PILPolicyFrameworkManagerConfig = {
-  abi: [].concat(_toConsumableArray(PILPolicyFrameworkManagerABI), _toConsumableArray(ErrorsABI)),
-  address: getAddress(sepolia.PILPolicyFrameworkManager)
+var getLicensingModuleConfig = function getLicensingModuleConfig(chain) {
+  return {
+    abi: [].concat(_toConsumableArray(LicensingModuleABI), _toConsumableArray(ErrorsABI)),
+    address: getAddress(contractAddress[chain].LicensingModule)
+  };
 };
-var RoyaltyPolicyLAPConfig = {
-  address: getAddress(sepolia.RoyaltyPolicyLAP)
+var getRoyaltyPolicyLAPConfig = function getRoyaltyPolicyLAPConfig(chain) {
+  return {
+    abi: [].concat(_toConsumableArray(IRoyaltyPolicyLAPABI), _toConsumableArray(ErrorsABI)),
+    address: getAddress(contractAddress[chain].RoyaltyPolicyLAP)
+  };
 };
-
-function _createForOfIteratorHelper(o, allowArrayLike) {
-  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-  if (!it) {
-    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-      if (it) o = it;
-      var i = 0;
-      var F = function () {};
-      return {
-        s: F,
-        n: function () {
-          if (i >= o.length) return {
-            done: true
-          };
-          return {
-            done: false,
-            value: o[i++]
-          };
-        },
-        e: function (e) {
-          throw e;
-        },
-        f: F
-      };
-    }
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-  var normalCompletion = true,
-    didErr = false,
-    err;
+var getRoyaltyVaultImplConfig = function getRoyaltyVaultImplConfig(chain) {
   return {
-    s: function () {
-      it = it.call(o);
-    },
-    n: function () {
-      var step = it.next();
-      normalCompletion = step.done;
-      return step;
-    },
-    e: function (e) {
-      didErr = true;
-      err = e;
-    },
-    f: function () {
-      try {
-        if (!normalCompletion && it.return != null) it.return();
-      } finally {
-        if (didErr) throw err;
-      }
-    }
+    abi: [].concat(_toConsumableArray(IpRoyaltyVaultABI), _toConsumableArray(ErrorsABI)),
+    address: getAddress(contractAddress[chain].IpRoyaltyVaultImpl)
   };
-}
-
-function parseToBigInt(num) {
-  return BigInt(num);
-}
-function waitTxAndFilterLog(_x, _x2, _x3) {
-  return _waitTxAndFilterLog.apply(this, arguments);
-}
-function _waitTxAndFilterLog() {
-  _waitTxAndFilterLog = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(client, txHash, params) {
-    var txReceipt, targetLogs, _iterator, _step, log, currentLog;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          _context.next = 2;
-          return client.waitForTransactionReceipt({
-            hash: txHash,
-            confirmations: params.confirmations,
-            pollingInterval: params.pollingInterval,
-            timeout: params.timeout
-          });
-        case 2:
-          txReceipt = _context.sent;
-          targetLogs = [];
-          _iterator = _createForOfIteratorHelper(txReceipt.logs);
-          _context.prev = 5;
-          _iterator.s();
-        case 7:
-          if ((_step = _iterator.n()).done) {
-            _context.next = 21;
-            break;
-          }
-          log = _step.value;
-          _context.prev = 9;
-          if (!(params.from && log.address !== params.from.toLowerCase())) {
-            _context.next = 12;
-            break;
-          }
-          return _context.abrupt("continue", 19);
-        case 12:
-          currentLog = decodeEventLog({
-            abi: params.abi,
-            eventName: params.eventName,
-            data: log.data,
-            topics: log.topics
-          });
-          targetLogs.push(currentLog);
-          _context.next = 19;
-          break;
-        case 16:
-          _context.prev = 16;
-          _context.t0 = _context["catch"](9);
-          return _context.abrupt("continue", 19);
-        case 19:
-          _context.next = 7;
-          break;
-        case 21:
-          _context.next = 26;
-          break;
-        case 23:
-          _context.prev = 23;
-          _context.t1 = _context["catch"](5);
-          _iterator.e(_context.t1);
-        case 26:
-          _context.prev = 26;
-          _iterator.f();
-          return _context.finish(26);
-        case 29:
-          if (!(targetLogs.length === 0)) {
-            _context.next = 31;
-            break;
-          }
-          throw new Error("not found event ".concat(params.eventName, " in target transaction"));
-        case 31:
-          return _context.abrupt("return", targetLogs);
-        case 32:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee, null, [[5, 23, 26, 29], [9, 16]]);
-  }));
-  return _waitTxAndFilterLog.apply(this, arguments);
-}
-function waitTx(_x4, _x5, _x6) {
-  return _waitTx.apply(this, arguments);
-}
-function _waitTx() {
-  _waitTx = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(client, txHash, params) {
-    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
-        case 0:
-          _context2.next = 2;
-          return client.waitForTransactionReceipt(_objectSpread2({
-            hash: txHash
-          }, params));
-        case 2:
-        case "end":
-          return _context2.stop();
-      }
-    }, _callee2);
-  }));
-  return _waitTx.apply(this, arguments);
-}
-function typedDataToBytes(typedData) {
-  return encodeAbiParameters(parseAbiParameters(typedData["interface"]), typedData.data);
-}
-function chainStringToViemChain(chainId) {
-  switch (chainId) {
-    case "1":
-    case "mainnet":
-      return mainnet;
-    case "11155111":
-    case "sepolia":
-      return sepolia$1;
-    case "80001":
-    case "mumbai":
-    case "polygonMumbai":
-      return polygonMumbai;
-    default:
-      throw new Error("chainId ".concat(chainId, " not supported"));
-  }
-}
-
-function computeRoyaltyContext(_x, _x2) {
-  return _computeRoyaltyContext.apply(this, arguments);
-}
-function _computeRoyaltyContext() {
-  _computeRoyaltyContext = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(licenseIds, storyClient) {
-    var royaltyContext, i, licenseData, royaltyPolicy, policy, targetRoyaltyAmount;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          royaltyContext = {
-            targetAncestors: [],
-            targetRoyaltyAmount: [],
-            parentAncestors1: [],
-            parentAncestors2: [],
-            parentAncestorsRoyalties1: [],
-            parentAncestorsRoyalties2: []
-          };
-          i = 0;
-        case 2:
-          if (!(i < licenseIds.length)) {
-            _context.next = 16;
-            break;
-          }
-          _context.next = 5;
-          return storyClient.getLicense(licenseIds[i]);
-        case 5:
-          licenseData = _context.sent;
-          _context.next = 8;
-          return storyClient.getRoyaltyPolicy(licenseData.licensorIpId);
-        case 8:
-          royaltyPolicy = _context.sent;
-          _context.next = 11;
-          return storyClient.getPolicy(licenseData.policyId);
-        case 11:
-          policy = _context.sent;
-          if (royaltyPolicy) {
-            targetRoyaltyAmount = royaltyPolicy.targetRoyaltyAmount.map(function (e) {
-              return parseInt(e);
-            });
-            if (i === 0) {
-              royaltyContext.parentAncestors1 = royaltyPolicy.targetAncestors;
-              royaltyContext.parentAncestorsRoyalties1 = targetRoyaltyAmount;
-            } else {
-              royaltyContext.parentAncestors2 = royaltyPolicy.targetAncestors;
-              royaltyContext.parentAncestorsRoyalties2 = targetRoyaltyAmount;
-            }
-            updateRoyaltyContext(royaltyContext, [licenseData.licensorIpId], [parseInt(policy.pil.commercialRevShare)]);
-            updateRoyaltyContext(royaltyContext, royaltyPolicy.targetAncestors, targetRoyaltyAmount);
-          }
-        case 13:
-          i++;
-          _context.next = 2;
-          break;
-        case 16:
-          return _context.abrupt("return", royaltyContext);
-        case 17:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  }));
-  return _computeRoyaltyContext.apply(this, arguments);
-}
-function encodeRoyaltyContext(royaltyContext) {
-  return typedDataToBytes({
-    "interface": "(address[], uint32[], address[], address[], uint32[], uint32[])",
-    data: [[royaltyContext.targetAncestors, royaltyContext.targetRoyaltyAmount, royaltyContext.parentAncestors1, royaltyContext.parentAncestors2, royaltyContext.parentAncestorsRoyalties1, royaltyContext.parentAncestorsRoyalties2]]
-  });
-}
-function updateRoyaltyContext(royaltyContext, targetAncestors, targetRoyaltyAccounts) {
-  for (var i = 0; i < targetAncestors.length; i++) {
-    var index = royaltyContext.targetAncestors.indexOf(targetAncestors[i]);
-    if (index === -1) {
-      royaltyContext.targetAncestors.push(targetAncestors[i]);
-      royaltyContext.targetRoyaltyAmount.push(targetRoyaltyAccounts[i]);
-    } else {
-      royaltyContext.targetRoyaltyAmount[index] += targetRoyaltyAccounts[i];
-    }
+};
+var getRoyaltyModuleConfig = function getRoyaltyModuleConfig(chain) {
+  return {
+    abi: [].concat(_toConsumableArray(IRoyaltyModuleABI), _toConsumableArray(ErrorsABI)),
+    address: getAddress(contractAddress[chain].RoyaltyModule)
+  };
+};
+var getLicenseTemplateConfig = function getLicenseTemplateConfig(chain) {
+  return {
+    abi: [].concat(_toConsumableArray(PILicenseTemplateABI), _toConsumableArray(ErrorsABI)),
+    address: getAddress(contractAddress[chain].PILicenseTemplate)
+  };
+};
+
+function handleError(error, msg) {
+  if (error instanceof Error) {
+    throw new Error("".concat(msg, ": ").concat(error.message));
   }
+  throw new Error("".concat(msg, ": Unknown error type"));
 }
 
 var IPAssetClient = /*#__PURE__*/function () {
-  function IPAssetClient(rpcClient, wallet, storyClient) {
+  function IPAssetClient(rpcClient, wallet, chainId) {
     _classCallCheck(this, IPAssetClient);
-    _defineProperty(this, "ipAssetRegistryConfig", IPAssetRegistryConfig);
-    _defineProperty(this, "registrationModuleConfig", RegistrationModuleConfig);
     this.wallet = wallet;
     this.rpcClient = rpcClient;
-    this.storyClient = storyClient;
+    this.chainId = chainId;
+    this.ipAssetRegistryConfig = getIPAssetRegistryConfig(chainId);
   }
-
-  /**
-   *  Registers a root-level IP into the protocol. Root-level IPs can be thought of as organizational hubs
-   *  for encapsulating policies that actual IPs can use to register through. As such, a root-level IP is not an
-   *  actual IP, but a container for IP policy management for their child IP assets.
-   * @param request The request object that contains all data needed to register a root IP.
-   *   @param request.policyId The policy that identifies the licensing terms of the IP.
-   *   @param request.tokenContract The address of the NFT bound to the root-level IP.
-   *   @param request.tokenId The token id of the NFT bound to the root-level IP.
-   *   @param request.ipName [Optional] The name assigned to the new IP.
-   *   @param request.contentHash [Optional] The content hash of the IP being registered.
-   *   @param request.uri [Optional] An external URI to link to the IP.
-   *   @param request.txOptions [Optional] The transaction options.
-   * @returns A Promise that resolves to an object containing the transaction hash and optional IP ID if waitForTxn is set to true.
-   * @emits RootIPRegistered (msg.sender, ipId, policyId)
-   */
   return _createClass(IPAssetClient, [{
-    key: "registerRootIp",
-    value: (function () {
-      var _registerRootIp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$txOptions, ipId, _yield$this$rpcClient, call, txHash, targetLogs;
+    key: "isNFTRegistered",
+    value: function () {
+      var _isNFTRegistered = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(tokenAddress, tokenId) {
+        var ipId, isRegistered;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              _context.prev = 0;
-              _context.next = 3;
-              return this.isNFTRegistered(SepoliaChainId, request.tokenContractAddress, request.tokenId);
-            case 3:
-              ipId = _context.sent;
-              if (!(ipId !== "0x")) {
-                _context.next = 6;
-                break;
-              }
-              return _context.abrupt("return", {
-                ipId: ipId
-              });
-            case 6:
-              _context.next = 8;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.registrationModuleConfig), {}, {
-                functionName: "registerRootIp",
-                args: [parseToBigInt(request.policyId || "0"), getAddress(request.tokenContractAddress),
-                // 0x Address
-                parseToBigInt(request.tokenId), request.ipName || "", request.contentHash || HashZero, request.uri || ""],
-                account: this.wallet.account
+              _context.next = 2;
+              return this.rpcClient.readContract(_objectSpread2(_objectSpread2({}, this.ipAssetRegistryConfig), {}, {
+                functionName: "ipId",
+                args: [parseToBigInt(chain[this.chainId]), tokenAddress, tokenId]
               }));
-            case 8:
-              _yield$this$rpcClient = _context.sent;
-              call = _yield$this$rpcClient.request;
-              _context.next = 12;
-              return this.wallet.writeContract(call);
-            case 12:
-              txHash = _context.sent;
-              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 20;
-                break;
-              }
-              _context.next = 16;
-              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.ipAssetRegistryConfig), {}, {
-                eventName: "IPRegistered"
+            case 2:
+              ipId = _context.sent;
+              _context.next = 5;
+              return this.rpcClient.readContract(_objectSpread2(_objectSpread2({}, this.ipAssetRegistryConfig), {}, {
+                functionName: "isRegistered",
+                args: [ipId]
               }));
-            case 16:
-              targetLogs = _context.sent;
-              return _context.abrupt("return", {
-                txHash: txHash,
-                ipId: targetLogs[0].args.ipId
-              });
-            case 20:
-              return _context.abrupt("return", {
-                txHash: txHash
-              });
-            case 21:
-              _context.next = 26;
-              break;
-            case 23:
-              _context.prev = 23;
-              _context.t0 = _context["catch"](0);
-              handleError(_context.t0, "Failed to register root IP");
-            case 26:
+            case 5:
+              isRegistered = _context.sent;
+              return _context.abrupt("return", isRegistered ? ipId : "0x");
+            case 7:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 23]]);
+        }, _callee, this);
       }));
-      function registerRootIp(_x) {
-        return _registerRootIp.apply(this, arguments);
+      function isNFTRegistered(_x, _x2) {
+        return _isNFTRegistered.apply(this, arguments);
       }
-      return registerRootIp;
+      return isNFTRegistered;
     }()
     /**
-     *  Registers derivative IPs into the protocol. Derivative IPs are IP assets that inherit policies from
-     *  parent IPs by burning acquired license NFTs.
-     * @param request The request object that contains all data needed to register a root IP.
-     *   @param request.licenseIds The policy that identifies the licensing terms of the IP.
-     *   @param request.tokenContract The address of the NFT bound to the derivative IP.
-     *   @param request.tokenId The token id of the NFT bound to the derivative IP.
-     *   @param request.ipName [Optional] The name assigned to the new IP.
-     *   @param request.contentHash [Optional] The content hash of the IP being registered.
-     *   @param request.uri [Optional] An external URI to link to the IP.
-     *   @param request.txOptions [Optional] The transaction options.
+     * 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.
      * @returns A Promise that resolves to an object containing the transaction hash and optional IP ID if waitForTxn is set to true.
-     * @emits RootIPRegistered (msg.sender, ipId, policyId)
+     * @emits IPRegistered (ipId, chainId, tokenContract, tokenId, resolverAddr, metadataProviderAddress, metadata)
      */
-    )
   }, {
-    key: "registerDerivativeIp",
+    key: "register",
     value: (function () {
-      var _registerDerivativeIp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, ipId, licenseIds, royaltyContext, _yield$this$rpcClient2, call, txHash, targetLogs;
+      var _register = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
+        var tokenId, _request$txOptions, ipId, _yield$this$rpcClient, call, txHash, targetLogs;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
-              _context2.prev = 0;
-              _context2.next = 3;
-              return this.isNFTRegistered(SepoliaChainId, request.tokenContractAddress, request.tokenId);
-            case 3:
+              tokenId = parseToBigInt(request.tokenId);
+              _context2.prev = 1;
+              _context2.next = 4;
+              return this.isNFTRegistered(request.tokenContract, tokenId);
+            case 4:
               ipId = _context2.sent;
               if (!(ipId !== "0x")) {
-                _context2.next = 6;
+                _context2.next = 7;
                 break;
               }
               return _context2.abrupt("return", {
                 ipId: ipId
               });
-            case 6:
-              licenseIds = [];
-              request.licenseIds.forEach(function (licenseId) {
-                licenseIds.push(parseToBigInt(licenseId));
-              });
-              _context2.next = 10;
-              return computeRoyaltyContext(request.licenseIds, this.storyClient);
-            case 10:
-              royaltyContext = _context2.sent;
-              _context2.next = 13;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.registrationModuleConfig), {}, {
-                functionName: "registerDerivativeIp",
-                args: [licenseIds, getAddress(request.tokenContractAddress),
-                // 0x Address
-                parseToBigInt(request.tokenId), request.ipName || "", request.contentHash || HashZero, request.uri || "", encodeRoyaltyContext(royaltyContext)],
+            case 7:
+              _context2.next = 9;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.ipAssetRegistryConfig), {}, {
+                functionName: "register",
+                args: [getAddress(request.tokenContract), tokenId],
                 account: this.wallet.account
               }));
-            case 13:
-              _yield$this$rpcClient2 = _context2.sent;
-              call = _yield$this$rpcClient2.request;
-              _context2.next = 17;
+            case 9:
+              _yield$this$rpcClient = _context2.sent;
+              call = _yield$this$rpcClient.request;
+              _context2.next = 13;
               return this.wallet.writeContract(call);
-            case 17:
+            case 13:
               txHash = _context2.sent;
-              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context2.next = 25;
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
+                _context2.next = 21;
                 break;
               }
-              _context2.next = 21;
+              _context2.next = 17;
               return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.ipAssetRegistryConfig), {}, {
                 eventName: "IPRegistered"
               }));
-            case 21:
+            case 17:
               targetLogs = _context2.sent;
               return _context2.abrupt("return", {
                 txHash: txHash,
                 ipId: targetLogs[0].args.ipId
               });
-            case 25:
+            case 21:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 26:
-              _context2.next = 31;
+            case 22:
+              _context2.next = 27;
               break;
-            case 28:
-              _context2.prev = 28;
-              _context2.t0 = _context2["catch"](0);
-              handleError(_context2.t0, "Failed to register derivative IP");
-            case 31:
+            case 24:
+              _context2.prev = 24;
+              _context2.t0 = _context2["catch"](1);
+              handleError(_context2.t0, "Failed to register IP");
+            case 27:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this, [[0, 28]]);
-      }));
-      function registerDerivativeIp(_x2) {
-        return _registerDerivativeIp.apply(this, arguments);
-      }
-      return registerDerivativeIp;
-    }()
-    /**
-     *  Checks if an NFT is already registered in the protocol.
-     * @param chainId The chain ID of the NFT.
-     * @param tokenAddress The address of the NFT.
-     * @param tokenId The token ID of the NFT.
-     * @returns A Promise that resolves to the IP ID if the NFT is already registered, otherwise it resolves to 0x.
-     */
-    )
-  }, {
-    key: "isNFTRegistered",
-    value: (function () {
-      var _isNFTRegistered = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(chainId, tokenAddress, tokenId) {
-        var ipId, isRegistered;
-        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              _context3.next = 2;
-              return this.rpcClient.readContract(_objectSpread2(_objectSpread2({}, this.ipAssetRegistryConfig), {}, {
-                functionName: "ipId",
-                args: [parseToBigInt(chainId), tokenAddress, parseToBigInt(tokenId)]
-              }));
-            case 2:
-              ipId = _context3.sent;
-              _context3.next = 5;
-              return this.rpcClient.readContract(_objectSpread2(_objectSpread2({}, this.ipAssetRegistryConfig), {}, {
-                functionName: "isRegistered",
-                args: [ipId]
-              }));
-            case 5:
-              isRegistered = _context3.sent;
-              return _context3.abrupt("return", isRegistered ? ipId : "0x");
-            case 7:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this);
+        }, _callee2, this, [[1, 24]]);
       }));
-      function isNFTRegistered(_x3, _x4, _x5) {
-        return _isNFTRegistered.apply(this, arguments);
+      function register(_x3) {
+        return _register.apply(this, arguments);
       }
-      return isNFTRegistered;
+      return register;
     }())
   }]);
 }();
 
 var PermissionClient = /*#__PURE__*/function () {
-  function PermissionClient(rpcClient, wallet) {
+  function PermissionClient(rpcClient, wallet, chainId) {
     _classCallCheck(this, PermissionClient);
     _defineProperty(this, "ipAccountABI", IPAccountABI);
-    _defineProperty(this, "accessControllerConfig", AccessControllerConfig);
     this.rpcClient = rpcClient;
     this.wallet = wallet;
+    this.accessControllerConfig = getAccessControllerConfig(chainId);
   }
 
   /**
@@ -2542,417 +2813,116 @@ var PermissionClient = /*#__PURE__*/function () {
 }();
 
 var LicenseClient = /*#__PURE__*/function () {
-  function LicenseClient(rpcClient, wallet, storyClient) {
+  function LicenseClient(rpcClient, wallet, storyClient, chainId) {
     _classCallCheck(this, LicenseClient);
     _defineProperty(this, "ipAccountABI", IPAccountABI);
-    _defineProperty(this, "licenseRegistryConfig", LicenseRegistryConfig);
-    _defineProperty(this, "licensingModuleConfig", LicensingModuleConfig);
     this.wallet = wallet;
     this.rpcClient = rpcClient;
     this.storyClient = storyClient;
+    this.licenseRegistryConfig = getLicenseRegistryConfig(chainId);
+    this.licensingModuleConfig = getLicensingModuleConfig(chainId);
+    this.licenseTemplateConfig = getLicenseTemplateConfig(chainId);
+    this.royaltyPolicyLAPConfig = getRoyaltyPolicyLAPConfig(chainId);
   }
-
-  /**
-   * Mints license NFTs representing a policy granted by a set of ipIds (licensors). This NFT needs to be
-   * burned in order to link a derivative IP with its parents. If this is the first combination of policy and
-   * licensors, a new licenseId will be created. If not, the license is fungible and an id will be reused.
-   * @dev Only callable by the licensing module.
-   * @param request The request object containing necessary data to mint a license.
-   *   @param request.policyId The ID of the policy to be minted
-   *   @param request.licensorIpId_ The ID of the IP granting the license (ie. licensor)
-   *   @param request.mintAmount Number of licenses to mint. License NFT is fungible for same policy and same licensors
-   *   @param request.receiver Receiver address of the minted license NFT(s).
-   * @returns licenseId The ID of the minted license NFT(s).
-   */
   return _createClass(LicenseClient, [{
-    key: "mintLicense",
-    value: (function () {
-      var _mintLicense = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$txOptions, royaltyContext, royaltyPolicy, _royaltyContext$targe, _royaltyContext$targe2, targetRoyaltyAmount, _yield$this$rpcClient, call, txHash, targetLogs;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              _context.prev = 0;
-              royaltyContext = {
-                targetAncestors: [],
-                targetRoyaltyAmount: [],
-                parentAncestors1: [],
-                parentAncestors2: [],
-                parentAncestorsRoyalties1: [],
-                parentAncestorsRoyalties2: []
-              };
-              _context.next = 4;
-              return this.storyClient.getRoyaltyPolicy(request.licensorIpId);
-            case 4:
-              royaltyPolicy = _context.sent;
-              if (royaltyPolicy) {
-                (_royaltyContext$targe = royaltyContext.targetAncestors).push.apply(_royaltyContext$targe, _toConsumableArray(royaltyPolicy.targetAncestors));
-                targetRoyaltyAmount = royaltyPolicy.targetRoyaltyAmount.map(function (e) {
-                  return parseInt(e);
-                });
-                (_royaltyContext$targe2 = royaltyContext.targetRoyaltyAmount).push.apply(_royaltyContext$targe2, _toConsumableArray(targetRoyaltyAmount));
-              }
-              _context.next = 8;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
-                functionName: "mintLicense",
-                args: [parseToBigInt(request.policyId), request.licensorIpId, parseToBigInt(request.mintAmount), getAddress(request.receiverAddress), encodeRoyaltyContext(royaltyContext)],
-                account: this.wallet.account
-              }));
-            case 8:
-              _yield$this$rpcClient = _context.sent;
-              call = _yield$this$rpcClient.request;
-              _context.next = 12;
-              return this.wallet.writeContract(call);
-            case 12:
-              txHash = _context.sent;
-              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 20;
-                break;
-              }
-              _context.next = 16;
-              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licenseRegistryConfig), {}, {
-                eventName: "TransferSingle",
-                from: this.licenseRegistryConfig.address
-              }));
-            case 16:
-              targetLogs = _context.sent;
-              return _context.abrupt("return", {
-                txHash: txHash,
-                licenseId: targetLogs[0].args.id.toString()
-              });
-            case 20:
-              return _context.abrupt("return", {
-                txHash: txHash
-              });
-            case 21:
-              _context.next = 26;
-              break;
-            case 23:
-              _context.prev = 23;
-              _context.t0 = _context["catch"](0);
-              handleError(_context.t0, "Failed to mint license");
-            case 26:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this, [[0, 23]]);
-      }));
-      function mintLicense(_x) {
-        return _mintLicense.apply(this, arguments);
-      }
-      return mintLicense;
-    }())
-  }, {
-    key: "linkIpToParent",
+    key: "getLicenseTermsId",
     value: function () {
-      var _linkIpToParent = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, IPAccountConfig, licenseIds, royaltyContext, _yield$this$rpcClient2, call, txHash;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              _context2.prev = 0;
-              IPAccountConfig = {
-                abi: this.ipAccountABI,
-                address: getAddress(request.childIpId)
-              };
-              licenseIds = [];
-              request.licenseIds.forEach(function (licenseId) {
-                licenseIds.push(parseToBigInt(licenseId));
-              });
-              _context2.next = 6;
-              return computeRoyaltyContext(request.licenseIds, this.storyClient);
-            case 6:
-              royaltyContext = _context2.sent;
-              _context2.next = 9;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, IPAccountConfig), {}, {
-                functionName: "execute",
-                args: [this.licensingModuleConfig.address, parseToBigInt(0), encodeFunctionData({
-                  abi: this.licensingModuleConfig.abi,
-                  functionName: "linkIpToParents",
-                  args: [licenseIds, getAddress(request.childIpId), encodeRoyaltyContext(royaltyContext)]
-                })],
-                account: this.wallet.account
-              }));
-            case 9:
-              _yield$this$rpcClient2 = _context2.sent;
-              call = _yield$this$rpcClient2.request;
-              _context2.next = 13;
-              return this.wallet.writeContract(call);
-            case 13:
-              txHash = _context2.sent;
-              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context2.next = 20;
-                break;
-              }
-              _context2.next = 17;
-              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, LicenseRegistryConfig), {}, {
-                eventName: "TransferBatch"
-              }));
-            case 17:
-              return _context2.abrupt("return", {
-                txHash: txHash,
-                success: true
-              });
-            case 20:
-              return _context2.abrupt("return", {
-                txHash: txHash
-              });
-            case 21:
-              _context2.next = 26;
-              break;
-            case 23:
-              _context2.prev = 23;
-              _context2.t0 = _context2["catch"](0);
-              handleError(_context2.t0, "Failed to link IP to parents");
-            case 26:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this, [[0, 23]]);
-      }));
-      function linkIpToParent(_x2) {
-        return _linkIpToParent.apply(this, arguments);
-      }
-      return linkIpToParent;
-    }()
-  }]);
-}();
-
-var PolicyClient = /*#__PURE__*/function () {
-  function PolicyClient(rpcClient, wallet) {
-    _classCallCheck(this, PolicyClient);
-    _defineProperty(this, "ipAccountABI", IPAccountABI);
-    _defineProperty(this, "licensingModuleConfig", LicensingModuleConfig);
-    _defineProperty(this, "pilPolicyFrameworkManagerConfig", PILPolicyFrameworkManagerConfig);
-    _defineProperty(this, "royaltyPolicyLAPConfig", RoyaltyPolicyLAPConfig);
-    this.wallet = wallet;
-    this.rpcClient = rpcClient;
-  }
-
-  /**
-   * Registers a PIL policy to the registry
-   * Internally, this function must generate a Licensing.Policy struct and call registerPolicy.
-   * @param request - the licensing parameters for the Programmable IP License v1 (PIL) standard.
-   *   @param request.transferable Whether or not the license is transferable
-   *   @param request.attribution Whether or not attribution is required when reproducing the work
-   *   @param request.commercialUse Whether or not the work can be used commercially
-   *   @param request.commercialAttribution Whether or not attribution is required when reproducing the work commercially
-   *   @param request.commercializerChecker commericializers that are allowed to commercially exploit the work. If zero address, then no restrictions is enforced.
-   *   @param request.commercialRevShare Percentage of revenue that must be shared with the licensor
-   *   @param request.derivativesAllowed Whether or not the licensee can create derivatives of his work
-   *   @param request.derivativesAttribution Whether or not attribution is required for derivatives of the work
-   *   @param request.derivativesApproval Whether or not the licensor must approve derivatives of the work before they can be linked to the licensor IP ID
-   *   @param request.derivativesReciprocal Whether or not the licensee must license derivatives of the work under the same terms.
-   *   @param request.territories List of territories where the license is valid. If empty, global.
-   *   @param request.distributionChannels List of distribution channels where the license is valid. Empty if no restrictions.
-   *   @param request.royaltyPolicy Address of a royalty policy contract (e.g. RoyaltyPolicyLS) that will handle royalty payments
-   * @returns the transaction hash and the policy ID if the txOptions.waitForTransaction is set to true
-   */
-  return _createClass(PolicyClient, [{
-    key: "registerPILPolicy",
-    value: (function () {
-      var _registerPILPolicy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _request$txOptions, frameworkData, policyId, _yield$this$rpcClient, call, txHash, targetLogs;
+      var _getLicenseTermsId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
+        var selectedLicenseTermsId;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              _context.prev = 0;
-              // First check if the policy exists
-              frameworkData = {
-                attribution: request.attribution || false,
-                commercialUse: request.commercialUse || false,
-                commercialAttribution: request.commercialAttribution || false,
-                commercializerChecker: request.commercializerChecker || zeroAddress,
-                commercializerCheckerData: request.commercializerCheckerData || "0x",
-                commercialRevShare: request.commercialRevShare || 0,
-                derivativesAllowed: request.derivativesAllowed || false,
-                derivativesAttribution: request.derivativesAttribution || false,
-                derivativesApproval: request.derivativesApproval || false,
-                derivativesReciprocal: request.derivativesReciprocal || false,
-                territories: request.territories || [],
-                distributionChannels: request.distributionChannels || [],
-                contentRestrictions: request.contentRestrictions || []
-              };
-              _context.next = 4;
-              return this.getPolicyId(request.transferable, this.encodeFrameworkData(frameworkData), typedDataToBytes({
-                "interface": "uint32",
-                data: [request.commercialRevShare || 0]
-              }), request.mintingFee || "0", request.mintingFeeToken || zeroAddress, request.royaltyPolicy || zeroAddress);
-            case 4:
-              policyId = _context.sent;
-              if (!(policyId !== 0)) {
-                _context.next = 7;
-                break;
-              }
-              return _context.abrupt("return", {
-                policyId: policyId.toString()
-              });
-            case 7:
-              _context.next = 9;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.pilPolicyFrameworkManagerConfig), {}, {
-                functionName: "registerPolicy",
-                args: [{
-                  transferable: request.transferable,
-                  royaltyPolicy: request.royaltyPolicy || zeroAddress,
-                  mintingFee: parseToBigInt(request.mintingFee || "0"),
-                  mintingFeeToken: request.mintingFeeToken || zeroAddress,
-                  policy: {
-                    attribution: request.attribution || false,
-                    commercialUse: request.commercialUse || false,
-                    commercialAttribution: request.commercialAttribution || false,
-                    commercialRevShare: request.commercialRevShare || 0,
-                    derivativesAllowed: request.derivativesAllowed || false,
-                    derivativesAttribution: request.derivativesAttribution || false,
-                    derivativesApproval: request.derivativesApproval || false,
-                    derivativesReciprocal: request.derivativesReciprocal || false,
-                    commercializerChecker: request.commercializerChecker || zeroAddress,
-                    commercializerCheckerData: request.commercializerCheckerData || "0x",
-                    territories: request.territories || [],
-                    distributionChannels: request.distributionChannels || [],
-                    contentRestrictions: request.contentRestrictions || []
-                  }
-                }],
-                account: this.wallet.account
-              }));
-            case 9:
-              _yield$this$rpcClient = _context.sent;
-              call = _yield$this$rpcClient.request;
-              _context.next = 13;
-              return this.wallet.writeContract(call);
-            case 13:
-              txHash = _context.sent;
-              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
-                _context.next = 21;
-                break;
-              }
-              _context.next = 17;
-              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
-                eventName: "PolicyRegistered"
+              _context.next = 2;
+              return this.rpcClient.readContract(_objectSpread2(_objectSpread2({}, this.licenseTemplateConfig), {}, {
+                functionName: "getLicenseTermsId",
+                args: [request]
               }));
-            case 17:
-              targetLogs = _context.sent;
-              return _context.abrupt("return", {
-                txHash: txHash,
-                policyId: targetLogs[0].args.policyId.toString()
-              });
-            case 21:
-              return _context.abrupt("return", {
-                txHash: txHash
-              });
-            case 22:
-              _context.next = 27;
-              break;
-            case 24:
-              _context.prev = 24;
-              _context.t0 = _context["catch"](0);
-              handleError(_context.t0, "Failed to register policy");
-            case 27:
+            case 2:
+              selectedLicenseTermsId = _context.sent;
+              return _context.abrupt("return", Number(selectedLicenseTermsId));
+            case 4:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 24]]);
+        }, _callee, this);
       }));
-      function registerPILPolicy(_x) {
-        return _registerPILPolicy.apply(this, arguments);
+      function getLicenseTermsId(_x) {
+        return _getLicenseTermsId.apply(this, arguments);
       }
-      return registerPILPolicy;
+      return getLicenseTermsId;
     }()
     /**
-     * Convenient function to register a PIL social remix policy to the registry
-     * Internally, this function must generate a Licensing.Policy struct and call registerPolicy.
-     * @param request - the licensing parameters for the Programmable IP License v1 (PIL) standard.
-     *   @param request.territories List of territories where the license is valid. If empty, global.
-     *   @param request.distributionChannels List of distribution channels where the license is valid. Empty if no restrictions.
-     *   @param request.contentRestrictions List of content restrictions where the license is valid. Empty if no restrictions.
-     * @returns the transaction hash and the policy ID if the txOptions.waitForTransaction is set to true
+     * 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.
+     * @returns A Promise that resolves to an object containing the optional transaction hash and optional license ID.
+     * @emits LicenseTermsRegistered (licenseTermsId, licenseTemplate, licenseTerms);
      */
-    )
   }, {
-    key: "registerPILSocialRemixPolicy",
+    key: "registerNonComSocialRemixingPIL",
     value: (function () {
-      var _registerPILSocialRemixPolicy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, frameworkData, policyId, _yield$this$rpcClient2, call, txHash, targetLog;
+      var _registerNonComSocialRemixingPIL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
+        var _request$txOptions, licenseTerms, licenseTermsId, _yield$this$rpcClient, call, txHash, targetLogs;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
               _context2.prev = 0;
-              // First check if the policy exists
-              frameworkData = {
-                attribution: true,
+              licenseTerms = {
+                transferable: true,
+                royaltyPolicy: zeroAddress,
+                mintingFee: BigInt(0),
+                expiration: BigInt(0),
                 commercialUse: false,
                 commercialAttribution: false,
                 commercializerChecker: zeroAddress,
-                commercializerCheckerData: "0x",
+                commercializerCheckerData: zeroAddress,
                 commercialRevShare: 0,
+                commercialRevCelling: BigInt(0),
                 derivativesAllowed: true,
                 derivativesAttribution: true,
                 derivativesApproval: false,
                 derivativesReciprocal: true,
-                territories: request.territories || [],
-                distributionChannels: request.distributionChannels || [],
-                contentRestrictions: request.contentRestrictions || []
+                derivativeRevCelling: BigInt(0),
+                currency: zeroAddress
               };
               _context2.next = 4;
-              return this.getPolicyId(true, this.encodeFrameworkData(frameworkData), typedDataToBytes({
-                "interface": "uint32",
-                data: [0]
-              }), "0", zeroAddress, zeroAddress);
+              return this.getLicenseTermsId(licenseTerms);
             case 4:
-              policyId = _context2.sent;
-              if (!(policyId !== 0)) {
+              licenseTermsId = _context2.sent;
+              if (!(licenseTermsId !== 0)) {
                 _context2.next = 7;
                 break;
               }
               return _context2.abrupt("return", {
-                policyId: policyId.toString()
+                licenseId: licenseTermsId.toString()
               });
             case 7:
               _context2.next = 9;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.pilPolicyFrameworkManagerConfig), {}, {
-                functionName: "registerPolicy",
-                args: [{
-                  transferable: true,
-                  royaltyPolicy: zeroAddress,
-                  mintingFee: parseToBigInt(0),
-                  mintingFeeToken: zeroAddress,
-                  policy: {
-                    attribution: true,
-                    commercialUse: false,
-                    commercialAttribution: false,
-                    commercialRevShare: 0,
-                    derivativesAllowed: true,
-                    derivativesAttribution: true,
-                    derivativesApproval: false,
-                    derivativesReciprocal: true,
-                    commercializerChecker: zeroAddress,
-                    commercializerCheckerData: "0x",
-                    territories: request.territories || [],
-                    distributionChannels: request.distributionChannels || [],
-                    contentRestrictions: request.contentRestrictions || []
-                  }
-                }],
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.licenseTemplateConfig), {}, {
+                functionName: "registerLicenseTerms",
+                args: [licenseTerms],
                 account: this.wallet.account
               }));
             case 9:
-              _yield$this$rpcClient2 = _context2.sent;
-              call = _yield$this$rpcClient2.request;
+              _yield$this$rpcClient = _context2.sent;
+              call = _yield$this$rpcClient.request;
               _context2.next = 13;
               return this.wallet.writeContract(call);
             case 13:
               txHash = _context2.sent;
-              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
                 _context2.next = 21;
                 break;
               }
               _context2.next = 17;
-              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
-                eventName: "PolicyRegistered"
+              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licenseTemplateConfig), {}, {
+                eventName: "LicenseTermsRegistered"
               }));
             case 17:
-              targetLog = _context2.sent;
+              targetLogs = _context2.sent;
               return _context2.abrupt("return", {
                 txHash: txHash,
-                policyId: targetLog[0].args.policyId.toString()
+                licenseId: targetLogs[0].args.licenseTermsId.toString()
               });
             case 21:
               return _context2.abrupt("return", {
@@ -2964,117 +2934,95 @@ var PolicyClient = /*#__PURE__*/function () {
             case 24:
               _context2.prev = 24;
               _context2.t0 = _context2["catch"](0);
-              handleError(_context2.t0, "Failed to register social remix policy");
+              handleError(_context2.t0, "Failed to register non commercial social remixing PIL");
             case 27:
             case "end":
               return _context2.stop();
           }
         }, _callee2, this, [[0, 24]]);
       }));
-      function registerPILSocialRemixPolicy(_x2) {
-        return _registerPILSocialRemixPolicy.apply(this, arguments);
+      function registerNonComSocialRemixingPIL(_x2) {
+        return _registerNonComSocialRemixingPIL.apply(this, arguments);
       }
-      return registerPILSocialRemixPolicy;
+      return registerNonComSocialRemixingPIL;
     }()
     /**
-     * Convenient function to register a PIL social remix policy to the registry
-     * Internally, this function must generate a Licensing.Policy struct and call registerPolicy.
-     * @param request - the licensing parameters for the Programmable IP License v1 (PIL) standard.
-     *   @param request.commercialRevShare Percentage of revenue that must be shared with the licensor
-     *   @param mintingFee Fee to be paid when minting a license
-     *   @param mintingFeeToken Token to be used to pay the minting fee
-     *   @param request.territories List of territories where the license is valid. If empty, global.
-     *   @param request.distributionChannels List of distribution channels where the license is valid. Empty if no restrictions.
-     *   @param request.contentRestrictions List of content restrictions where the license is valid. Empty if no restrictions.
-     * @returns the transaction hash and the policy ID if the txOptions.waitForTransaction is set to true
+     * 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.
+     * @returns A Promise that resolves to an object containing the optional transaction hash and optional license ID.
+     * @emits LicenseTermsRegistered (licenseTermsId, licenseTemplate, licenseTerms);
      */
     )
   }, {
-    key: "registerPILCommercialUsePolicy",
+    key: "registerCommercialUsePIL",
     value: (function () {
-      var _registerPILCommercialUsePolicy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(request) {
-        var _request$txOptions3, frameworkData, policyId, _yield$this$rpcClient3, call, txHash, targetLogs;
+      var _registerCommercialUsePIL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(request) {
+        var _request$txOptions2, licenseTerms, licenseTermsId, _yield$this$rpcClient2, call, txHash, targetLogs;
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
               _context3.prev = 0;
-              // First check if the policy exists
-              frameworkData = {
-                attribution: true,
+              licenseTerms = {
+                transferable: true,
+                royaltyPolicy: this.royaltyPolicyLAPConfig.address,
+                mintingFee: BigInt(request.mintingFee),
+                expiration: BigInt(0),
                 commercialUse: true,
                 commercialAttribution: true,
                 commercializerChecker: zeroAddress,
-                commercializerCheckerData: "0x",
-                commercialRevShare: request.commercialRevShare,
+                commercializerCheckerData: zeroAddress,
+                commercialRevShare: 0,
+                commercialRevCelling: BigInt(0),
                 derivativesAllowed: true,
                 derivativesAttribution: true,
                 derivativesApproval: false,
-                derivativesReciprocal: true,
-                territories: request.territories || [],
-                distributionChannels: request.distributionChannels || [],
-                contentRestrictions: request.contentRestrictions || []
+                derivativesReciprocal: false,
+                derivativeRevCelling: BigInt(0),
+                currency: request.currency
               };
               _context3.next = 4;
-              return this.getPolicyId(true, this.encodeFrameworkData(frameworkData), typedDataToBytes({
-                "interface": "uint32",
-                data: [request.commercialRevShare]
-              }), request.mintingFee || "0", request.mintingFeeToken || zeroAddress, this.royaltyPolicyLAPConfig.address);
+              return this.getLicenseTermsId(licenseTerms);
             case 4:
-              policyId = _context3.sent;
-              if (!(policyId !== 0)) {
+              licenseTermsId = _context3.sent;
+              if (!(licenseTermsId !== 0)) {
                 _context3.next = 7;
                 break;
               }
               return _context3.abrupt("return", {
-                policyId: policyId.toString()
+                licenseId: licenseTermsId.toString()
               });
             case 7:
               _context3.next = 9;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.pilPolicyFrameworkManagerConfig), {}, {
-                functionName: "registerPolicy",
-                args: [{
-                  transferable: true,
-                  royaltyPolicy: this.royaltyPolicyLAPConfig.address,
-                  mintingFee: parseToBigInt(request.mintingFee || "0"),
-                  mintingFeeToken: request.mintingFeeToken || zeroAddress,
-                  policy: {
-                    attribution: true,
-                    commercialUse: true,
-                    commercialAttribution: true,
-                    commercialRevShare: request.commercialRevShare,
-                    derivativesAllowed: true,
-                    derivativesAttribution: true,
-                    derivativesApproval: false,
-                    derivativesReciprocal: true,
-                    commercializerChecker: zeroAddress,
-                    commercializerCheckerData: "0x",
-                    territories: request.territories || [],
-                    distributionChannels: request.distributionChannels || [],
-                    contentRestrictions: request.contentRestrictions || []
-                  }
-                }],
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.licenseTemplateConfig), {}, {
+                functionName: "registerLicenseTerms",
+                args: [licenseTerms],
                 account: this.wallet.account
               }));
             case 9:
-              _yield$this$rpcClient3 = _context3.sent;
-              call = _yield$this$rpcClient3.request;
+              _yield$this$rpcClient2 = _context3.sent;
+              call = _yield$this$rpcClient2.request;
               _context3.next = 13;
               return this.wallet.writeContract(call);
             case 13:
               txHash = _context3.sent;
-              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.waitForTransaction)) {
+              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
                 _context3.next = 21;
                 break;
               }
               _context3.next = 17;
-              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
-                eventName: "PolicyRegistered"
+              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licenseTemplateConfig), {}, {
+                eventName: "LicenseTermsRegistered"
               }));
             case 17:
               targetLogs = _context3.sent;
               return _context3.abrupt("return", {
                 txHash: txHash,
-                policyId: targetLogs[0].args.policyId.toString()
+                licenseId: targetLogs[0].args.licenseTermsId.toString()
               });
             case 21:
               return _context3.abrupt("return", {
@@ -3086,144 +3034,266 @@ var PolicyClient = /*#__PURE__*/function () {
             case 24:
               _context3.prev = 24;
               _context3.t0 = _context3["catch"](0);
-              handleError(_context3.t0, "Failed to register commercial use policy");
+              handleError(_context3.t0, "Failed to register commercial use PIL");
             case 27:
             case "end":
               return _context3.stop();
           }
         }, _callee3, this, [[0, 24]]);
       }));
-      function registerPILCommercialUsePolicy(_x3) {
-        return _registerPILCommercialUsePolicy.apply(this, arguments);
+      function registerCommercialUsePIL(_x3) {
+        return _registerCommercialUsePIL.apply(this, arguments);
       }
-      return registerPILCommercialUsePolicy;
-    }())
+      return registerCommercialUsePIL;
+    }()
+    /**
+     * 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.
+     * @returns A Promise that resolves to an object containing the optional transaction hash and optional license ID.
+     * @emits LicenseTermsRegistered (licenseTermsId, licenseTemplate, licenseTerms);
+     */
+    )
   }, {
-    key: "getPolicyId",
-    value: function () {
-      var _getPolicyId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(transferable, frameworkData, royaltyData, mintingFee, mintingFeeToken, royaltyPolicy, policyFramework) {
-        var data;
+    key: "registerCommercialRemixPIL",
+    value: (function () {
+      var _registerCommercialRemixPIL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(request) {
+        var _request$txOptions3, licenseTerms, licenseTermsId, _yield$this$rpcClient3, call, txHash, targetLogs;
         return _regeneratorRuntime().wrap(function _callee4$(_context4) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
-              _context4.next = 2;
-              return this.rpcClient.readContract(_objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
-                functionName: "getPolicyId",
-                args: [{
-                  isLicenseTransferable: transferable,
-                  policyFramework: policyFramework || this.pilPolicyFrameworkManagerConfig.address,
-                  frameworkData: frameworkData,
-                  royaltyPolicy: royaltyPolicy,
-                  royaltyData: royaltyData,
-                  mintingFee: parseToBigInt(mintingFee),
-                  mintingFeeToken: mintingFeeToken
-                }]
-              }));
-            case 2:
-              data = _context4.sent;
-              return _context4.abrupt("return", Number(data));
+              _context4.prev = 0;
+              licenseTerms = {
+                transferable: true,
+                royaltyPolicy: this.royaltyPolicyLAPConfig.address,
+                mintingFee: BigInt(request.mintingFee),
+                expiration: BigInt(0),
+                commercialUse: true,
+                commercialAttribution: true,
+                commercializerChecker: zeroAddress,
+                commercializerCheckerData: zeroAddress,
+                commercialRevShare: request.commercialRevShare,
+                commercialRevCelling: BigInt(0),
+                derivativesAllowed: true,
+                derivativesAttribution: true,
+                derivativesApproval: false,
+                derivativesReciprocal: true,
+                derivativeRevCelling: BigInt(0),
+                currency: request.currency
+              };
+              _context4.next = 4;
+              return this.getLicenseTermsId(licenseTerms);
             case 4:
+              licenseTermsId = _context4.sent;
+              if (!(licenseTermsId !== 0)) {
+                _context4.next = 7;
+                break;
+              }
+              return _context4.abrupt("return", {
+                licenseId: licenseTermsId.toString()
+              });
+            case 7:
+              _context4.next = 9;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.licenseTemplateConfig), {}, {
+                functionName: "registerLicenseTerms",
+                args: [licenseTerms],
+                account: this.wallet.account
+              }));
+            case 9:
+              _yield$this$rpcClient3 = _context4.sent;
+              call = _yield$this$rpcClient3.request;
+              _context4.next = 13;
+              return this.wallet.writeContract(call);
+            case 13:
+              txHash = _context4.sent;
+              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.waitForTransaction)) {
+                _context4.next = 21;
+                break;
+              }
+              _context4.next = 17;
+              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licenseTemplateConfig), {}, {
+                eventName: "LicenseTermsRegistered"
+              }));
+            case 17:
+              targetLogs = _context4.sent;
+              return _context4.abrupt("return", {
+                txHash: txHash,
+                licenseId: targetLogs[0].args.licenseTermsId.toString()
+              });
+            case 21:
+              return _context4.abrupt("return", {
+                txHash: txHash
+              });
+            case 22:
+              _context4.next = 27;
+              break;
+            case 24:
+              _context4.prev = 24;
+              _context4.t0 = _context4["catch"](0);
+              handleError(_context4.t0, "Failed to register commercial remix PIL");
+            case 27:
             case "end":
               return _context4.stop();
           }
-        }, _callee4, this);
+        }, _callee4, this, [[0, 24]]);
       }));
-      function getPolicyId(_x4, _x5, _x6, _x7, _x8, _x9, _x10) {
-        return _getPolicyId.apply(this, arguments);
+      function registerCommercialRemixPIL(_x4) {
+        return _registerCommercialRemixPIL.apply(this, arguments);
       }
-      return getPolicyId;
+      return registerCommercialRemixPIL;
     }()
-  }, {
-    key: "encodeFrameworkData",
-    value: function encodeFrameworkData(data) {
-      return typedDataToBytes({
-        "interface": "(bool, bool, bool, address, bytes, uint32, bool, bool, bool, bool, string[], string[], string[])",
-        data: [[data.attribution, data.commercialUse, data.commercialAttribution, data.commercializerChecker, data.commercializerCheckerData, data.commercialRevShare, data.derivativesAllowed, data.derivativesAttribution, data.derivativesApproval, data.derivativesReciprocal, data.territories, data.distributionChannels, data.contentRestrictions]]
-      });
-    }
-
     /**
-     * Adds a policy to the set of policies of an IP
-     * @param request The request object containing details to add a policy to an IP
-     *   @param request.ipId The id of the IP
-     *   @param request.polId The id of the policy
-     * @return the transaction hash and the index of the policy in the IP's policy set if the txOptions.waitForTransaction is set to true
+     * Attaches license terms to an IP, and the function must be called by the IP owner or an authorized operator.
+     * @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.txOptions [Optional] The transaction options.
+     * @returns A Promise that resolves to an object containing the transaction hash.
      */
+    )
   }, {
-    key: "addPolicyToIp",
+    key: "attachLicenseTerms",
     value: (function () {
-      var _addPolicyToIp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(request) {
-        var _request$txOptions4, IPAccountConfig, _yield$this$rpcClient4, call, txHash, targetLogs;
+      var _attachLicenseTerms = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(request) {
+        var _request$txOptions4;
+        var _yield$this$rpcClient4, call, txHash;
         return _regeneratorRuntime().wrap(function _callee5$(_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
-              _context5.prev = 0;
-              IPAccountConfig = {
-                abi: this.ipAccountABI,
-                address: getAddress(request.ipId)
-              };
-              _context5.next = 4;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, IPAccountConfig), {}, {
-                functionName: "execute",
-                args: [this.licensingModuleConfig.address, parseToBigInt(0), encodeFunctionData({
-                  abi: this.licensingModuleConfig.abi,
-                  functionName: "addPolicyToIp",
-                  args: [getAddress(request.ipId), parseToBigInt(request.policyId)]
-                })],
+              _context5.next = 2;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
+                functionName: "attachLicenseTerms",
+                args: [request.ipId, request.licenseTemplate || this.licenseTemplateConfig.address, BigInt(request.licenseTermsId)],
                 account: this.wallet.account
               }));
-            case 4:
+            case 2:
               _yield$this$rpcClient4 = _context5.sent;
               call = _yield$this$rpcClient4.request;
-              _context5.next = 8;
+              _context5.next = 6;
               return this.wallet.writeContract(call);
-            case 8:
+            case 6:
               txHash = _context5.sent;
               if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.waitForTransaction)) {
-                _context5.next = 16;
+                _context5.next = 13;
+                break;
+              }
+              _context5.next = 10;
+              return waitTx(this.rpcClient, txHash);
+            case 10:
+              return _context5.abrupt("return", {
+                txHash: txHash
+              });
+            case 13:
+              return _context5.abrupt("return", {
+                txHash: txHash
+              });
+            case 14:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function attachLicenseTerms(_x5) {
+        return _attachLicenseTerms.apply(this, arguments);
+      }
+      return attachLicenseTerms;
+    }()
+    /**
+     * Mints license tokens for the license terms attached to an IP.
+     * The license tokens are minted to the receiver.
+     * The license terms must be attached to the IP before calling this function.
+     * But it can mint license token of default license terms without attaching the default license terms,
+     * since it is attached to all IPs by default.
+     * IP owners can mint license tokens for their IPs for arbitrary license terms
+     * without attaching the license terms to IP.
+     * It might require the caller pay the minting fee, depending on the license terms or configured by the iP owner.
+     * The minting fee is paid in the minting fee token specified in the license terms or configured by the IP owner.
+     * IP owners can configure the minting fee of their IPs or
+     * configure the minting fee module to determine the minting fee.
+     * @param request The request object that contains all data needed to mint license tokens.
+     *  @param request.licensorIpId The licensor IP ID.
+     *  @param request.licenseTemplate The address of the license template.
+     *  @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);
+     */
+    )
+  }, {
+    key: "mintLicenseTokens",
+    value: (function () {
+      var _mintLicenseTokens = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(request) {
+        var _request$txOptions5, _yield$this$rpcClient5, call, txHash, targetLogs;
+        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              _context6.prev = 0;
+              _context6.next = 3;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
+                functionName: "mintLicenseTokens",
+                args: [request.licensorIpId, request.licenseTemplate || this.licenseTemplateConfig.address, BigInt(request.licenseTermsId), BigInt(request.amount || 1), request.receiver || this.wallet.account.address, zeroAddress],
+                account: this.wallet.account
+              }));
+            case 3:
+              _yield$this$rpcClient5 = _context6.sent;
+              call = _yield$this$rpcClient5.request;
+              _context6.next = 7;
+              return this.wallet.writeContract(call);
+            case 7:
+              txHash = _context6.sent;
+              if (!((_request$txOptions5 = request.txOptions) !== null && _request$txOptions5 !== void 0 && _request$txOptions5.waitForTransaction)) {
+                _context6.next = 15;
                 break;
               }
-              _context5.next = 12;
+              _context6.next = 11;
               return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
-                eventName: "PolicyAddedToIpId"
+                eventName: "LicenseTokensMinted"
               }));
-            case 12:
-              targetLogs = _context5.sent;
-              return _context5.abrupt("return", {
+            case 11:
+              targetLogs = _context6.sent;
+              return _context6.abrupt("return", {
                 txHash: txHash,
-                index: targetLogs[0].args.index.toString()
+                licenseTokenId: targetLogs[0].args.startLicenseTokenId.toString()
               });
-            case 16:
-              return _context5.abrupt("return", {
+            case 15:
+              return _context6.abrupt("return", {
                 txHash: txHash
               });
-            case 17:
-              _context5.next = 22;
+            case 16:
+              _context6.next = 21;
               break;
-            case 19:
-              _context5.prev = 19;
-              _context5.t0 = _context5["catch"](0);
-              handleError(_context5.t0, "Failed to add policy to IP");
-            case 22:
+            case 18:
+              _context6.prev = 18;
+              _context6.t0 = _context6["catch"](0);
+              handleError(_context6.t0, "Failed to mint license tokens");
+            case 21:
             case "end":
-              return _context5.stop();
+              return _context6.stop();
           }
-        }, _callee5, this, [[0, 19]]);
+        }, _callee6, this, [[0, 18]]);
       }));
-      function addPolicyToIp(_x11) {
-        return _addPolicyToIp.apply(this, arguments);
+      function mintLicenseTokens(_x6) {
+        return _mintLicenseTokens.apply(this, arguments);
       }
-      return addPolicyToIp;
+      return mintLicenseTokens;
     }())
   }]);
 }();
 
 var DisputeClient = /*#__PURE__*/function () {
-  function DisputeClient(rpcClient, wallet) {
+  function DisputeClient(rpcClient, wallet, chainId) {
     _classCallCheck(this, DisputeClient);
-    _defineProperty(this, "disputeModuleConfig", DisputeModuleConfig);
     this.rpcClient = rpcClient;
     this.wallet = wallet;
+    this.disputeModuleConfig = getDisputeModuleConfig(chainId);
   }
 
   /**
@@ -3609,30 +3679,166 @@ var StoryAPIClient = /*#__PURE__*/function () {
       }
       return getLicense;
     }()
+  }]);
+}();
+
+var RoyaltyClient = /*#__PURE__*/function () {
+  function RoyaltyClient(rpcClient, wallet, chainId) {
+    _classCallCheck(this, RoyaltyClient);
+    this.rpcClient = rpcClient;
+    this.wallet = wallet;
+    this.royaltyVaultImplConfig = getRoyaltyVaultImplConfig(chainId);
+    this.royaltyPolicyLAPConfig = getRoyaltyPolicyLAPConfig(chainId);
+    this.royaltyModuleConfig = getRoyaltyModuleConfig(chainId);
+  }
+  /**
+   * Allows ancestors to claim the royalty tokens and any accrued revenue tokens
+   * @param request - the licensing parameters for the Programmable IP License v1 (PIL) standard.
+   *   @param request.ancestorIpId The ip id of the ancestor to whom the royalty tokens belong to.
+   *   @param request.txOptions [Optional] The transaction options.
+   * @returns Tx hash for the transaction.
+   * @emits RoyaltyTokensCollected (ancestorIpId, ancestorsRoyalty)
+   */
+  return _createClass(RoyaltyClient, [{
+    key: "collectRoyaltyTokens",
+    value: (function () {
+      var _collectRoyaltyTokens = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
+        var proxyAddress, _yield$this$rpcClient, call, txHash;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              _context.next = 3;
+              return this.getProxyAddress(request.derivativeId);
+            case 3:
+              proxyAddress = _context.sent;
+              if (proxyAddress) {
+                _context.next = 6;
+                break;
+              }
+              throw new Error("Proxy address not found");
+            case 6:
+              _context.next = 8;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.royaltyVaultImplConfig), {}, {
+                address: proxyAddress,
+                functionName: "collectRoyaltyTokens",
+                args: [request.ancestorIpId],
+                account: this.wallet.account
+              }));
+            case 8:
+              _yield$this$rpcClient = _context.sent;
+              call = _yield$this$rpcClient.request;
+              _context.next = 12;
+              return this.wallet.writeContract(call);
+            case 12:
+              txHash = _context.sent;
+              return _context.abrupt("return", {
+                txHash: txHash
+              });
+            case 16:
+              _context.prev = 16;
+              _context.t0 = _context["catch"](0);
+              handleError(_context.t0, "Failed to collect royalty tokens");
+            case 19:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[0, 16]]);
+      }));
+      function collectRoyaltyTokens(_x) {
+        return _collectRoyaltyTokens.apply(this, arguments);
+      }
+      return collectRoyaltyTokens;
+    }())
   }, {
-    key: "getPolicy",
+    key: "getProxyAddress",
     value: function () {
-      var _getPolicy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(policyId) {
-        var policyResp;
+      var _getProxyAddress = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(derivativeID) {
+        var data;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this.rpcClient.readContract(_objectSpread2(_objectSpread2({}, this.royaltyPolicyLAPConfig), {}, {
+                functionName: "getRoyaltyData",
+                args: [derivativeID]
+              }));
+            case 2:
+              data = _context2.sent;
+              if (!(Array.isArray(data) && data[1])) {
+                _context2.next = 5;
+                break;
+              }
+              return _context2.abrupt("return", data[1]);
+            case 5:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function getProxyAddress(_x2) {
+        return _getProxyAddress.apply(this, arguments);
+      }
+      return getProxyAddress;
+    }()
+    /**
+     * Allows the function caller to pay royalties to the receiver IP asset on behalf of the payer IP asset.
+     * @param request - The request object that contains all data needed to pay royalty on behalf.
+     *   @param request.receiverIpId The ipId that receives the royalties.
+     *   @param request.payerIpId The ID of the IP asset that pays the royalties.
+     *   @param request.token The token to use to pay the royalties.
+     *   @param request.amount The amount to pay.
+     *   @param request.txOptions [Optional] The transaction options.
+     * @returns A Promise that resolves to an object containing the transaction hash.
+     * @emits RoyaltyPaid (receiverIpId, payerIpId, msg.sender, token, amount)
+     */
+  }, {
+    key: "payRoyaltyOnBehalf",
+    value: (function () {
+      var _payRoyaltyOnBehalf = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(request) {
+        var _request$txOptions, _yield$this$rpcClient2, call, txHash;
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
-              _context3.next = 2;
-              return this.httpClient.get("/api/v1/policies/".concat(policyId));
-            case 2:
-              policyResp = _context3.sent;
-              return _context3.abrupt("return", policyResp.data.data);
-            case 4:
+              _context3.prev = 0;
+              _context3.next = 3;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.royaltyModuleConfig), {}, {
+                functionName: "payRoyaltyOnBehalf",
+                args: [request.receiverIpId, request.payerIpId, request.token, request.amount],
+                account: this.wallet.account
+              }));
+            case 3:
+              _yield$this$rpcClient2 = _context3.sent;
+              call = _yield$this$rpcClient2.request;
+              _context3.next = 7;
+              return this.wallet.writeContract(call);
+            case 7:
+              txHash = _context3.sent;
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
+                _context3.next = 11;
+                break;
+              }
+              _context3.next = 11;
+              return waitTx(this.rpcClient, txHash);
+            case 11:
+              return _context3.abrupt("return", {
+                txHash: txHash
+              });
+            case 14:
+              _context3.prev = 14;
+              _context3.t0 = _context3["catch"](0);
+              handleError(_context3.t0, "Failed to pay royalty on behalf");
+            case 17:
             case "end":
               return _context3.stop();
           }
-        }, _callee3, this);
+        }, _callee3, this, [[0, 14]]);
       }));
-      function getPolicy(_x3) {
-        return _getPolicy.apply(this, arguments);
+      function payRoyaltyOnBehalf(_x3) {
+        return _payRoyaltyOnBehalf.apply(this, arguments);
       }
-      return getPolicy;
-    }()
+      return payRoyaltyOnBehalf;
+    }())
   }]);
 }();
 
@@ -3651,15 +3857,17 @@ var StoryClient = /*#__PURE__*/function () {
     _defineProperty(this, "_ipAsset", null);
     _defineProperty(this, "_permission", null);
     _defineProperty(this, "_license", null);
-    _defineProperty(this, "_policy", null);
     _defineProperty(this, "_dispute", null);
     _defineProperty(this, "_ipAccount", null);
-    this.config = config;
+    _defineProperty(this, "_royalty", null);
+    this.config = _objectSpread2(_objectSpread2({}, config), {}, {
+      chainId: config.chainId || "sepolia"
+    });
     if (!this.config.transport) {
       throw new Error("transport is null, please pass in a valid RPC Provider URL as the transport.");
     }
     var clientConfig = {
-      chain: chainStringToViemChain(this.config.chainId || "sepolia"),
+      chain: chainStringToViemChain(this.config.chainId),
       transport: this.config.transport
     };
     this.rpcClient = createPublicClient(clientConfig);
@@ -3668,7 +3876,7 @@ var StoryClient = /*#__PURE__*/function () {
     if (!account) {
       throw new Error("account is null");
     }
-    this.wallet = createWalletClient(_objectSpread2(_objectSpread2({}, clientConfig), {}, {
+    this.wallet = config.wallet || createWalletClient(_objectSpread2(_objectSpread2({}, clientConfig), {}, {
       account: account
     }));
   }
@@ -3689,7 +3897,7 @@ var StoryClient = /*#__PURE__*/function () {
      */
     function get() {
       if (this._ipAsset === null) {
-        this._ipAsset = new IPAssetClient(this.rpcClient, this.wallet, this.storyClient);
+        this._ipAsset = new IPAssetClient(this.rpcClient, this.wallet, this.config.chainId);
       }
       return this._ipAsset;
     }
@@ -3704,7 +3912,7 @@ var StoryClient = /*#__PURE__*/function () {
     key: "permission",
     get: function get() {
       if (this._permission === null) {
-        this._permission = new PermissionClient(this.rpcClient, this.wallet);
+        this._permission = new PermissionClient(this.rpcClient, this.wallet, this.config.chainId);
       }
       return this._permission;
     }
@@ -3719,26 +3927,11 @@ 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, this.storyClient, this.config.chainId);
       }
       return this._license;
     }
 
-    /**
-     * Getter for the policy client. The client is lazily created when
-     * this method is called.
-     *
-     * @returns the PolicyClient instance
-     */
-  }, {
-    key: "policy",
-    get: function get() {
-      if (this._policy === null) {
-        this._policy = new PolicyClient(this.rpcClient, this.wallet);
-      }
-      return this._policy;
-    }
-
     /**
      * Getter for the dispute client. The client is lazily created when
      * this method is called.
@@ -3749,7 +3942,7 @@ var StoryClient = /*#__PURE__*/function () {
     key: "dispute",
     get: function get() {
       if (this._dispute === null) {
-        this._dispute = new DisputeClient(this.rpcClient, this.wallet);
+        this._dispute = new DisputeClient(this.rpcClient, this.wallet, this.config.chainId);
       }
       return this._dispute;
     }
@@ -3768,6 +3961,20 @@ var StoryClient = /*#__PURE__*/function () {
       }
       return this._ipAccount;
     }
+    /**
+     * Getter for the royalty client. The client is lazily created when
+     * this method is called.
+     *
+     * @returns the RoyaltyClient instance
+     */
+  }, {
+    key: "royalty",
+    get: function get() {
+      if (this._royalty === null) {
+        this._royalty = new RoyaltyClient(this.rpcClient, this.wallet, this.config.chainId);
+      }
+      return this._royalty;
+    }
   }], [{
     key: "newClient",
     value: function newClient(config) {
@@ -3776,4 +3983,7 @@ var StoryClient = /*#__PURE__*/function () {
   }]);
 }();
 
-export { AddressZero, DisputeClient, HashZero, IPAssetClient, LicenseClient, PermissionClient, PolicyClient, StoryClient };
+var AddressZero = "0x0000000000000000000000000000000000000000";
+var HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
+
+export { AddressZero, DisputeClient, HashZero, IPAssetClient, LicenseClient, PermissionClient, StoryClient };