@story-protocol/core-sdk 1.4.2 → 1.4.3

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

@@ -1,5 +1,5 @@
 import * as dotenv from 'dotenv';
-import { encodeFunctionData, decodeEventLog, isAddress, formatEther, maxUint256, http, createPublicClient, createWalletClient, stringToHex, encodeAbiParameters, zeroHash, keccak256, toFunctionSelector, zeroAddress, toHex, maxUint32, erc20Abi as erc20Abi$1 } from 'viem';
+import { encodeFunctionData, decodeEventLog, isAddress, formatEther, maxUint256, http, createPublicClient, createWalletClient, stringToHex, encodeAbiParameters, zeroHash, toFunctionSelector, keccak256, zeroAddress, toHex, maxUint32, erc20Abi as erc20Abi$1 } from 'viem';
 import { defineChain } from 'viem/utils';
 import bs58 from 'bs58';
 import { base58btc } from 'multiformats/bases/base58';
@@ -3070,6 +3070,15 @@ var ERC20Client = /*#__PURE__*/function () {
         value: value
       });
     }
+  }, {
+    key: "transferFromEncode",
+    value: function transferFromEncode(from, to, value) {
+      return this.ercClient.transferFromEncode({
+        from: from,
+        to: to,
+        value: value
+      });
+    }
 
     // The method only will work in test environment
   }, {
@@ -3185,6 +3194,15 @@ var WipTokenClient = /*#__PURE__*/function () {
     value: function depositEncode() {
       return this.wipClient.depositEncode();
     }
+  }, {
+    key: "transferFromEncode",
+    value: function transferFromEncode(from, to, value) {
+      return this.wipClient.transferFromEncode({
+        from: from,
+        to: to,
+        amount: value
+      });
+    }
   }, {
     key: "address",
     get: function get() {
@@ -6206,6 +6224,24 @@ var IPAccountClient = /*#__PURE__*/function () {
   }]);
 }();
 
+function _regeneratorValues(e) {
+  if (null != e) {
+    var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"],
+      r = 0;
+    if (t) return t.call(e);
+    if ("function" == typeof e.next) return e;
+    if (!isNaN(e.length)) return {
+      next: function () {
+        return e && r >= e.length && (e = void 0), {
+          value: e && e[r++],
+          done: !e
+        };
+      }
+    };
+  }
+  throw new TypeError(typeof e + " is not iterable");
+}
+
 var SignatureMethodType = /*#__PURE__*/function (SignatureMethodType) {
   SignatureMethodType["REGISTER_IP_AND_MAKE_DERIVATIVE_AND_DEPLOY_ROYALTY_VAULT"] = "registerIpAndMakeDerivativeAndDeployRoyaltyVault";
   SignatureMethodType["DISTRIBUTE_ROYALTY_TOKENS"] = "distributeRoyaltyTokens";
@@ -6548,6 +6584,392 @@ var generateOperationSignature = /*#__PURE__*/function () {
   };
 }();
 
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+
+var _excluded = ["mintFees", "spenderAddress", "encodedTxs"];
+/**
+ * Handles batch transaction execution through IP Account with automatic fee management for ERC20 and WIP tokens.
+ */
+var IpAccountBatchExecutor = /*#__PURE__*/function () {
+  function IpAccountBatchExecutor(rpcClient, wallet, ipId) {
+    _classCallCheck(this, IpAccountBatchExecutor);
+    this.rpcClient = rpcClient;
+    this.wallet = wallet;
+    this.ipId = ipId;
+    //erc20 address only available in aeneid
+    this.erc20Token = new ERC20Client(rpcClient, wallet, erc20Address[aeneid.id]);
+    this.wipToken = new WipTokenClient(rpcClient, wallet);
+    this.walletAddress = wallet.account.address;
+  }
+
+  /**
+   * Executes a batch transaction with automatic fee handling for both ERC20 and WIP tokens.
+   */
+  return _createClass(IpAccountBatchExecutor, [{
+    key: "executeWithFees",
+    value: (function () {
+      var _executeWithFees = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
+        var _options$options;
+        var mintFees, spenderAddress, encodedTxs, options, _groupTokenSpenders, wipSpenders, erc20Spenders, wipTotalFees, erc20TotalFees, wipBalance, callData, depositValue, _yield$this$buildWipD, calls, value, isMulticall, _iterator, _step, _step$value, index, call, _value, _txHash, txHash, _t, _t2, _t3, _t4, _t5, _t6, _t7;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.p = _context.n) {
+            case 0:
+              mintFees = _ref.mintFees, spenderAddress = _ref.spenderAddress, encodedTxs = _ref.encodedTxs, options = _objectWithoutProperties(_ref, _excluded);
+              _groupTokenSpenders = groupTokenSpenders(mintFees.map(function (fee) {
+                return _objectSpread2({
+                  address: spenderAddress
+                }, fee);
+              })), wipSpenders = _groupTokenSpenders.wipSpenders, erc20Spenders = _groupTokenSpenders.erc20Spenders;
+              wipTotalFees = wipSpenders.reduce(function (acc, spender) {
+                return acc + (spender.amount || 0n);
+              }, 0n);
+              erc20TotalFees = erc20Spenders.reduce(function (acc, spender) {
+                return acc + (spender.amount || 0n);
+              }, 0n);
+              _context.n = 1;
+              return this.wipToken.balanceOf(this.walletAddress);
+            case 1:
+              wipBalance = _context.v;
+              callData = [];
+              depositValue = 0n; // Build ERC20 fee call data if needed
+              if (!(erc20TotalFees > 0n)) {
+                _context.n = 3;
+                break;
+              }
+              _t = callData.push;
+              _t2 = callData;
+              _t3 = _toConsumableArray;
+              _context.n = 2;
+              return this.buildErc20FeeCallData(erc20TotalFees, spenderAddress, options);
+            case 2:
+              _t.apply.call(_t, _t2, _t3(_context.v));
+            case 3:
+              if (!(wipTotalFees > 0n)) {
+                _context.n = 7;
+                break;
+              }
+              if (!(wipBalance < wipTotalFees)) {
+                _context.n = 5;
+                break;
+              }
+              _context.n = 4;
+              return this.buildWipDepositCallData(spenderAddress, wipTotalFees, wipBalance, options);
+            case 4:
+              _yield$this$buildWipD = _context.v;
+              calls = _yield$this$buildWipD.calls;
+              value = _yield$this$buildWipD.value;
+              callData.push.apply(callData, _toConsumableArray(calls));
+              depositValue = value;
+              _context.n = 7;
+              break;
+            case 5:
+              _t4 = callData.push;
+              _t5 = callData;
+              _t6 = _toConsumableArray;
+              _context.n = 6;
+              return this.buildWipTransferCallData(wipTotalFees, spenderAddress, options);
+            case 6:
+              _t4.apply.call(_t4, _t5, _t6(_context.v));
+            case 7:
+              // Add the actual transaction call data
+              callData.push({
+                target: encodedTxs.to,
+                value: 0n,
+                data: encodedTxs.data
+              });
+              isMulticall = ((_options$options = options.options) === null || _options$options === void 0 || (_options$options = _options$options.wipOptions) === null || _options$options === void 0 ? void 0 : _options$options.useMulticallWhenPossible) !== false;
+              if (isMulticall) {
+                _context.n = 16;
+                break;
+              }
+              _iterator = _createForOfIteratorHelper(callData.entries());
+              _context.p = 8;
+              _iterator.s();
+            case 9:
+              if ((_step = _iterator.n()).done) {
+                _context.n = 13;
+                break;
+              }
+              _step$value = _slicedToArray(_step.value, 2), index = _step$value[0], call = _step$value[1];
+              _value = call.value;
+              _context.n = 10;
+              return simulateAndWriteContract({
+                rpcClient: this.rpcClient,
+                wallet: this.wallet,
+                data: _objectSpread2({
+                  abi: ipAccountImplAbi,
+                  address: this.ipId,
+                  functionName: "execute",
+                  args: [call.target, call.value, call.data, 0]
+                }, _value > 0n && {
+                  value: _value
+                })
+              });
+            case 10:
+              _txHash = _context.v;
+              _context.n = 11;
+              return waitTx(this.rpcClient, _txHash.txHash);
+            case 11:
+              if (!(index === callData.length - 1)) {
+                _context.n = 12;
+                break;
+              }
+              return _context.a(2, {
+                txHash: _txHash.txHash,
+                receipt: _txHash.receipt
+              });
+            case 12:
+              _context.n = 9;
+              break;
+            case 13:
+              _context.n = 15;
+              break;
+            case 14:
+              _context.p = 14;
+              _t7 = _context.v;
+              _iterator.e(_t7);
+            case 15:
+              _context.p = 15;
+              _iterator.f();
+              return _context.f(15);
+            case 16:
+              _context.n = 17;
+              return simulateAndWriteContract({
+                rpcClient: this.rpcClient,
+                wallet: this.wallet,
+                data: _objectSpread2({
+                  abi: ipAccountImplAbi,
+                  address: this.ipId,
+                  functionName: "executeBatch",
+                  args: [callData, 0]
+                }, depositValue > 0n && {
+                  value: depositValue
+                })
+              });
+            case 17:
+              txHash = _context.v;
+              _context.n = 18;
+              return waitTx(this.rpcClient, txHash.txHash, options.txOptions);
+            case 18:
+              return _context.a(2, {
+                txHash: txHash.txHash,
+                receipt: txHash.receipt
+              });
+          }
+        }, _callee, this, [[8, 14, 15, 16]]);
+      }));
+      function executeWithFees(_x) {
+        return _executeWithFees.apply(this, arguments);
+      }
+      return executeWithFees;
+    }()
+    /**
+     * Builds call data for transferring ERC20 tokens from wallet to IP account and approving spender.
+     */
+    )
+  }, {
+    key: "buildErc20FeeCallData",
+    value: (function () {
+      var _buildErc20FeeCallData = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(totalFee, spenderAddress, options) {
+        var _options$options2;
+        var erc20Balance, autoApprove, erc20ContractAddress, allowance, calls, spenderAllowance, _t8, _t9;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              _context2.n = 1;
+              return this.erc20Token.balanceOf(this.walletAddress);
+            case 1:
+              erc20Balance = _context2.v;
+              if (!(erc20Balance < totalFee)) {
+                _context2.n = 2;
+                break;
+              }
+              throw new Error("Wallet does not have enough ERC20 tokens to pay for fees. " + "Required: ".concat(getTokenAmountDisplay(totalFee), ", ") + "Available: ".concat(getTokenAmountDisplay(erc20Balance), "."));
+            case 2:
+              autoApprove = ((_options$options2 = options.options) === null || _options$options2 === void 0 || (_options$options2 = _options$options2.erc20Options) === null || _options$options2 === void 0 ? void 0 : _options$options2.enableAutoApprove) !== false; // erc20 address only available in aeneid
+              erc20ContractAddress = erc20Address[aeneid.id];
+              _context2.n = 3;
+              return this.erc20Token.allowance(this.walletAddress, this.ipId);
+            case 3:
+              allowance = _context2.v;
+              if (!(autoApprove && allowance < totalFee)) {
+                _context2.n = 5;
+                break;
+              }
+              _t8 = waitTx;
+              _t9 = this.rpcClient;
+              _context2.n = 4;
+              return this.erc20Token.approve(this.ipId, maxUint256);
+            case 4:
+              _context2.n = 5;
+              return _t8(_t9, _context2.v);
+            case 5:
+              calls = [{
+                target: erc20ContractAddress,
+                value: 0n,
+                data: this.erc20Token.transferFromEncode(this.walletAddress, this.ipId, totalFee).data
+              }];
+              _context2.n = 6;
+              return this.erc20Token.allowance(this.ipId, spenderAddress);
+            case 6:
+              spenderAllowance = _context2.v;
+              if (autoApprove && spenderAllowance < totalFee) {
+                calls.push({
+                  target: erc20ContractAddress,
+                  value: 0n,
+                  data: this.erc20Token.approveEncode(spenderAddress, maxUint256).data
+                });
+              }
+              return _context2.a(2, calls);
+          }
+        }, _callee2, this);
+      }));
+      function buildErc20FeeCallData(_x2, _x3, _x4) {
+        return _buildErc20FeeCallData.apply(this, arguments);
+      }
+      return buildErc20FeeCallData;
+    }()
+    /**
+     * Builds call data for depositing IP tokens to WIP and approving spender.
+     */
+    )
+  }, {
+    key: "buildWipDepositCallData",
+    value: (function () {
+      var _buildWipDepositCallData = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(spenderAddress, totalFee, wipBalance, options) {
+        var _options$options3, _options$options4;
+        var calls, autoApprove, autoWrapIp, ipBalance, value, allowance;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              calls = [];
+              autoApprove = ((_options$options3 = options.options) === null || _options$options3 === void 0 || (_options$options3 = _options$options3.wipOptions) === null || _options$options3 === void 0 ? void 0 : _options$options3.enableAutoApprove) !== false;
+              autoWrapIp = ((_options$options4 = options.options) === null || _options$options4 === void 0 || (_options$options4 = _options$options4.wipOptions) === null || _options$options4 === void 0 ? void 0 : _options$options4.enableAutoWrapIp) !== false;
+              _context3.n = 1;
+              return this.rpcClient.getBalance({
+                address: this.walletAddress
+              });
+            case 1:
+              ipBalance = _context3.v;
+              if (autoWrapIp) {
+                _context3.n = 2;
+                break;
+              }
+              throw new Error("Wallet does not have enough WIP to pay for fees. Total fees: ".concat(getTokenAmountDisplay(totalFee), ", balance: ").concat(getTokenAmountDisplay(wipBalance, "WIP"), "."));
+            case 2:
+              if (!(ipBalance < totalFee)) {
+                _context3.n = 3;
+                break;
+              }
+              throw new Error("Wallet does not have enough IP tokens to wrap to WIP and pay for fees. " + "Required: ".concat(getTokenAmountDisplay(totalFee), ", ") + "Available: ".concat(getTokenAmountDisplay(ipBalance), "."));
+            case 3:
+              calls.push({
+                target: WIP_TOKEN_ADDRESS,
+                value: totalFee,
+                data: this.wipToken.depositEncode().data
+              });
+              value = totalFee;
+              _context3.n = 4;
+              return this.wipToken.allowance(this.ipId, spenderAddress);
+            case 4:
+              allowance = _context3.v;
+              if (autoApprove && allowance < totalFee) {
+                calls.push({
+                  target: WIP_TOKEN_ADDRESS,
+                  value: 0n,
+                  data: this.wipToken.approveEncode(spenderAddress, maxUint256).data
+                });
+              }
+              return _context3.a(2, {
+                calls: calls,
+                value: value
+              });
+          }
+        }, _callee3, this);
+      }));
+      function buildWipDepositCallData(_x5, _x6, _x7, _x8) {
+        return _buildWipDepositCallData.apply(this, arguments);
+      }
+      return buildWipDepositCallData;
+    }()
+    /**
+     * Builds call data for transferring existing WIP tokens from wallet to IP account and approving spender.
+     */
+    )
+  }, {
+    key: "buildWipTransferCallData",
+    value: (function () {
+      var _buildWipTransferCallData = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(totalFee, spenderAddress, options) {
+        var _options$options5;
+        var autoApprove, allowance, calls, spenderAllowance, _t0, _t1;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              autoApprove = ((_options$options5 = options.options) === null || _options$options5 === void 0 || (_options$options5 = _options$options5.wipOptions) === null || _options$options5 === void 0 ? void 0 : _options$options5.enableAutoApprove) !== false;
+              _context4.n = 1;
+              return this.wipToken.allowance(this.walletAddress, this.ipId);
+            case 1:
+              allowance = _context4.v;
+              if (!(autoApprove && allowance < totalFee)) {
+                _context4.n = 3;
+                break;
+              }
+              _t0 = waitTx;
+              _t1 = this.rpcClient;
+              _context4.n = 2;
+              return this.wipToken.approve(this.ipId, maxUint256);
+            case 2:
+              _context4.n = 3;
+              return _t0(_t1, _context4.v);
+            case 3:
+              calls = [{
+                target: WIP_TOKEN_ADDRESS,
+                value: 0n,
+                data: this.wipToken.transferFromEncode(this.walletAddress, this.ipId, totalFee).data
+              }];
+              _context4.n = 4;
+              return this.wipToken.allowance(this.ipId, spenderAddress);
+            case 4:
+              spenderAllowance = _context4.v;
+              if (autoApprove && spenderAllowance < totalFee) {
+                calls.push({
+                  target: WIP_TOKEN_ADDRESS,
+                  value: 0n,
+                  data: this.wipToken.approveEncode(spenderAddress, maxUint256).data
+                });
+              }
+              return _context4.a(2, calls);
+          }
+        }, _callee4, this);
+      }));
+      function buildWipTransferCallData(_x9, _x0, _x1) {
+        return _buildWipTransferCallData.apply(this, arguments);
+      }
+      return buildWipTransferCallData;
+    }())
+  }]);
+}();
+
 var _PILFlavor;
 var PIL_URIS = {
   NCSR: "https://github.com/piplabs/pil-document/blob/998c13e6ee1d04eb817aefd1fe16dfe8be3cd7a2/off-chain-terms/NCSR.json",
@@ -6777,24 +7199,6 @@ _defineProperty(PILFlavor, "verifyDerivatives", function (terms) {
   }
 });
 
-function _regeneratorValues(e) {
-  if (null != e) {
-    var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"],
-      r = 0;
-    if (t) return t.call(e);
-    if ("function" == typeof e.next) return e;
-    if (!isNaN(e.length)) return {
-      next: function () {
-        return e && r >= e.length && (e = void 0), {
-          value: e && e[r++],
-          done: !e
-        };
-      }
-    };
-  }
-  throw new TypeError(typeof e + " is not iterable");
-}
-
 function _regeneratorKeys(e) {
   var n = Object(e),
     r = [];
@@ -6825,7 +7229,7 @@ var getPublicMinting = /*#__PURE__*/function () {
 }();
 var validateLicenseTermsData = /*#__PURE__*/function () {
   var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(licenseTermsData, rpcClient, chainId) {
-    var licenseTerms, processedLicenseTermsData, maxLicenseTokens, i, licenseTerm, royaltyModuleReadOnlyClient, isWhitelistedArbitrationPolicy, isWhitelistedRoyaltyToken, licensingConfig, maxLicenseTokensValue;
+    var licenseTerms, processedLicenseTermsData, maxLicenseTokens, i, licenseTerm, licenseTermsDataInput, royaltyModuleReadOnlyClient, isWhitelistedArbitrationPolicy, isWhitelistedRoyaltyToken, piLicenseTemplateReadOnlyClient, isExist, response, licensingConfig, maxLicenseTokensValue;
     return _regenerator().w(function (_context2) {
       while (1) switch (_context2.n) {
         case 0:
@@ -6835,10 +7239,16 @@ var validateLicenseTermsData = /*#__PURE__*/function () {
           i = 0;
         case 1:
           if (!(i < licenseTermsData.length)) {
-            _context2.n = 10;
+            _context2.n = 16;
+            break;
+          }
+          licenseTerm = void 0;
+          licenseTermsDataInput = licenseTermsData[i];
+          if (!licenseTermsDataInput.terms) {
+            _context2.n = 6;
             break;
           }
-          licenseTerm = PILFlavor.validateLicenseTerms(licenseTermsData[i].terms, chainId);
+          licenseTerm = PILFlavor.validateLicenseTerms(licenseTermsDataInput.terms, chainId);
           licenseTerm.commercialRevShare = getRevenueShare(licenseTerm.commercialRevShare);
           royaltyModuleReadOnlyClient = new RoyaltyModuleReadOnlyClient(rpcClient);
           if (!(validateAddress(licenseTerm.royaltyPolicy) !== zeroAddress)) {
@@ -6873,37 +7283,69 @@ var validateLicenseTermsData = /*#__PURE__*/function () {
           }
           throw new Error("The currency token ".concat(licenseTerm.currency, " is not whitelisted."));
         case 5:
-          licensingConfig = validateLicenseConfig(licenseTermsData[i].licensingConfig);
-          if (!(licensingConfig.mintingFee > 0 && licenseTerm.royaltyPolicy === zeroAddress)) {
-            _context2.n = 6;
-            break;
-          }
-          throw new Error("A royalty policy must be provided when the minting fee is greater than 0.");
+          _context2.n = 11;
+          break;
         case 6:
-          maxLicenseTokensValue = licenseTermsData[i].maxLicenseTokens;
-          if (!(maxLicenseTokensValue !== undefined)) {
-            _context2.n = 8;
+          if (!(licenseTermsDataInput.licenseTermsId !== undefined)) {
+            _context2.n = 10;
             break;
           }
-          if (!(maxLicenseTokensValue < 0)) {
-            _context2.n = 7;
+          piLicenseTemplateReadOnlyClient = new PiLicenseTemplateReadOnlyClient(rpcClient);
+          _context2.n = 7;
+          return piLicenseTemplateReadOnlyClient.exists({
+            licenseTermsId: BigInt(licenseTermsDataInput.licenseTermsId)
+          });
+        case 7:
+          isExist = _context2.v;
+          if (isExist) {
+            _context2.n = 8;
             break;
           }
-          throw new Error("The max license tokens must be greater than or equal to 0.");
-        case 7:
+          throw new Error("The license terms id ".concat(licenseTermsDataInput.licenseTermsId, " is not exist."));
+        case 8:
+          _context2.n = 9;
+          return piLicenseTemplateReadOnlyClient.getLicenseTerms({
+            selectedLicenseTermsId: BigInt(licenseTermsDataInput.licenseTermsId)
+          });
+        case 9:
+          response = _context2.v;
+          licenseTerm = response.terms;
+          _context2.n = 11;
+          break;
+        case 10:
+          throw new Error("Either terms or licenseTermsId must be provided.");
+        case 11:
+          licensingConfig = validateLicenseConfig(licenseTermsData[i].licensingConfig);
+          if (!(licensingConfig.mintingFee > 0 && licenseTerm.royaltyPolicy === zeroAddress)) {
+            _context2.n = 12;
+            break;
+          }
+          throw new Error("A royalty policy must be provided when the minting fee is greater than 0.");
+        case 12:
+          maxLicenseTokensValue = licenseTermsData[i].maxLicenseTokens;
+          if (!(maxLicenseTokensValue !== undefined)) {
+            _context2.n = 14;
+            break;
+          }
+          if (!(maxLicenseTokensValue < 0)) {
+            _context2.n = 13;
+            break;
+          }
+          throw new Error("The max license tokens must be greater than or equal to 0.");
+        case 13:
           licensingConfig.licensingHook = totalLicenseTokenLimitHookAddress[chainId];
           maxLicenseTokens[i] = BigInt(maxLicenseTokensValue);
-        case 8:
+        case 14:
           licenseTerms.push(licenseTerm);
           processedLicenseTermsData.push({
             terms: licenseTerm,
             licensingConfig: licensingConfig
           });
-        case 9:
+        case 15:
           i++;
           _context2.n = 1;
           break;
-        case 10:
+        case 16:
           return _context2.a(2, {
             licenseTerms: licenseTerms,
             licenseTermsData: processedLicenseTermsData,
@@ -8344,6 +8786,7 @@ var IPAssetClient = /*#__PURE__*/function () {
     this.spgNftClient = new SpgnftImplReadOnlyClient(rpcClient);
     this.totalLicenseTokenLimitHookClient = new TotalLicenseTokenLimitHookClient(rpcClient, wallet);
     this.licenseTokenClient = new LicenseTokenClient(rpcClient, wallet);
+    this.erc20Client = new Erc20Client(rpcClient, wallet, erc20Address[chainId]);
     this.rpcClient = rpcClient;
     this.wallet = wallet;
     this.chainId = chainId;
@@ -8679,8 +9122,7 @@ var IPAssetClient = /*#__PURE__*/function () {
     key: "registerDerivative",
     value: (function () {
       var _registerDerivative = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(request) {
-        var _this2 = this;
-        var _request$txOptions2, isChildIpIdRegistered, derivativeData, object, encodedTxData, _request$options, contractCall, _t5;
+        var _request$txOptions2, isChildIpIdRegistered, derivativeData, object, encodedTxData, mintFees, batchExecutor, _t5;
         return _regenerator().w(function (_context4) {
           while (1) switch (_context4.p = _context4.n) {
             case 0:
@@ -8716,33 +9158,35 @@ var IPAssetClient = /*#__PURE__*/function () {
                 encodedTxData: encodedTxData
               });
             case 4:
-              contractCall = function contractCall() {
-                return _this2.licensingModuleClient.registerDerivative(object);
-              };
-              return _context4.a(2, this.handleRegistrationWithFees({
-                sender: this.walletAddress,
+              _context4.n = 5;
+              return calculateDerivativeMintingFee({
                 derivData: object,
-                contractCall: contractCall,
-                txOptions: request.txOptions,
-                encodedTxs: [encodedTxData],
-                spgSpenderAddress: this.royaltyModuleEventClient.address,
-                options: _objectSpread2(_objectSpread2({}, request.options), {}, {
-                  wipOptions: _objectSpread2(_objectSpread2({}, (_request$options = request.options) === null || _request$options === void 0 ? void 0 : _request$options.wipOptions), {}, {
-                    useMulticallWhenPossible: false
-                  })
-                })
-              }));
+                rpcClient: this.rpcClient,
+                wallet: this.wallet,
+                chainId: this.chainId,
+                sender: this.walletAddress
+              });
             case 5:
-              _context4.n = 7;
-              break;
+              mintFees = _context4.v;
+              batchExecutor = new IpAccountBatchExecutor(this.rpcClient, this.wallet, request.childIpId);
+              return _context4.a(2, batchExecutor.executeWithFees({
+                mintFees: mintFees,
+                spenderAddress: this.royaltyModuleEventClient.address,
+                encodedTxs: encodedTxData,
+                options: request.options,
+                txOptions: request.txOptions
+              }));
             case 6:
-              _context4.p = 6;
+              _context4.n = 8;
+              break;
+            case 7:
+              _context4.p = 7;
               _t5 = _context4.v;
               return _context4.a(2, handleError(_t5, "Failed to register derivative"));
-            case 7:
+            case 8:
               return _context4.a(2);
           }
-        }, _callee4, this, [[0, 6]]);
+        }, _callee4, this, [[0, 7]]);
       }));
       function registerDerivative(_x5) {
         return _registerDerivative.apply(this, arguments);
@@ -8750,48 +9194,124 @@ var IPAssetClient = /*#__PURE__*/function () {
       return registerDerivative;
     }()
     /**
-     * Batch registers a derivative directly with parent IP's license terms.
+     * Batch registers a derivative directly with parent IP's license terms, without needing license tokens,
+     * and attaches the license terms of the parent IPs to the derivative IP.
+     * The license terms must be attached to the parent IP before calling this function.
+     * All IPs attached default license terms by default.
+     * The derivative IP owner must be the caller or an authorized operator.
+     *
+     * @remarks
+     * This method supports automatic fee handling for both ERC20 and WIP tokens.
+     * The fees are paid from the wallet address.
+     * The transaction will be executed in the same order as the input arguments.
+     * If a request fails, previous transactions will not be reverted.
      */
     )
   }, {
-    key: "batchRegisterDerivative",
+    key: "batchRegisterDerivatives",
     value: (function () {
-      var _batchRegisterDerivative = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(request) {
-        var contracts, licenseModuleAddress, _iterator2, _step2, _arg$maxMintingFee, _arg$maxRevenueShare, arg, calculatedDeadline, ipAccount, data, _yield$ipAccount$stat, state, signature, txHash, _t6, _t7, _t8;
+      var _batchRegisterDerivatives = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(_ref2) {
+        var requests, options, txOptions, txHashes, index, result, _t6;
         return _regenerator().w(function (_context5) {
           while (1) switch (_context5.p = _context5.n) {
             case 0:
-              _context5.p = 0;
+              requests = _ref2.requests, options = _ref2.options, txOptions = _ref2.txOptions;
+              txHashes = [];
+              index = 0;
+            case 1:
+              if (!(index < requests.length)) {
+                _context5.n = 6;
+                break;
+              }
+              _context5.p = 2;
+              _context5.n = 3;
+              return this.registerDerivative(_objectSpread2(_objectSpread2({}, requests[index]), {}, {
+                options: options,
+                txOptions: txOptions
+              }));
+            case 3:
+              result = _context5.v;
+              txHashes.push(result.txHash);
+              index++;
+              _context5.n = 5;
+              break;
+            case 4:
+              _context5.p = 4;
+              _t6 = _context5.v;
+              return _context5.a(2, handleError(_t6, "Failed to batch register derivatives at index ".concat(index)));
+            case 5:
+              _context5.n = 1;
+              break;
+            case 6:
+              return _context5.a(2, txHashes);
+          }
+        }, _callee5, this, [[2, 4]]);
+      }));
+      function batchRegisterDerivatives(_x6) {
+        return _batchRegisterDerivatives.apply(this, arguments);
+      }
+      return batchRegisterDerivatives;
+    }()
+    /**
+     * @deprecated This method is deprecated. Please use the {@link batchRegisterDerivatives} instead.
+     * This method will be removed soon.
+     * Batch registers a derivative directly with parent IP's license terms.
+     *
+     * @example Migration Example
+     * ```typescript
+     * // Before (deprecated):
+     * await client.ipAsset.batchRegisterDerivative({
+     *   args: [{ childIpId: '0x...', parentIpIds: ['0x...'], licenseTermsIds: [1n] }],
+     * });
+     *
+     * // After (recommended):
+     * await client.ipAsset.batchRegisterDerivatives({
+     *   requests: [{ childIpId: '0x...', parentIpIds: ['0x...'], licenseTermsIds: [1n] }],
+     * });
+     * ```
+     *
+     * @remarks This method does not support automatic fee handling for both ERC20 and WIP tokens.
+     */
+    )
+  }, {
+    key: "batchRegisterDerivative",
+    value: (function () {
+      var _batchRegisterDerivative = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(request) {
+        var contracts, licenseModuleAddress, _iterator2, _step2, _arg$maxMintingFee, _arg$maxRevenueShare, arg, calculatedDeadline, ipAccount, data, _yield$ipAccount$stat, state, signature, txHash, _t7, _t8, _t9;
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.p = _context6.n) {
+            case 0:
+              _context6.p = 0;
               contracts = [];
               licenseModuleAddress = validateAddress(this.licensingModuleClient.address);
               _iterator2 = _createForOfIteratorHelper(request.args);
-              _context5.p = 1;
+              _context6.p = 1;
               _iterator2.s();
             case 2:
               if ((_step2 = _iterator2.n()).done) {
-                _context5.n = 11;
+                _context6.n = 11;
                 break;
               }
               arg = _step2.value;
-              _context5.p = 3;
-              _context5.n = 4;
+              _context6.p = 3;
+              _context6.n = 4;
               return this.registerDerivative(_objectSpread2(_objectSpread2({}, arg), {}, {
                 txOptions: {
                   encodedTxDataOnly: true
                 }
               }));
             case 4:
-              _context5.n = 6;
+              _context6.n = 6;
               break;
             case 5:
-              _context5.p = 5;
-              _t6 = _context5.v;
-              throw new Error(_t6.message.replace("Failed to register derivative:", "").trim());
+              _context6.p = 5;
+              _t7 = _context6.v;
+              throw new Error(_t7.message.replace("Failed to register derivative:", "").trim());
             case 6:
-              _context5.n = 7;
+              _context6.n = 7;
               return getCalculatedDeadline(this.rpcClient, request.deadline);
             case 7:
-              calculatedDeadline = _context5.v;
+              calculatedDeadline = _context6.v;
               ipAccount = new IpAccountImplClient(this.rpcClient, this.wallet, validateAddress(arg.childIpId));
               data = encodeFunctionData({
                 abi: licensingModuleAbi,
@@ -8800,12 +9320,12 @@ var IPAssetClient = /*#__PURE__*/function () {
                   return BigInt(id);
                 }), arg.licenseTemplate || this.licenseTemplateAddress, zeroAddress, BigInt((_arg$maxMintingFee = arg.maxMintingFee) !== null && _arg$maxMintingFee !== void 0 ? _arg$maxMintingFee : 0), validateMaxRts(arg.maxRts), getRevenueShare((_arg$maxRevenueShare = arg.maxRevenueShare) !== null && _arg$maxRevenueShare !== void 0 ? _arg$maxRevenueShare : 100, RevShareType.MAX_REVENUE_SHARE)]
               });
-              _context5.n = 8;
+              _context6.n = 8;
               return ipAccount.state();
             case 8:
-              _yield$ipAccount$stat = _context5.v;
+              _yield$ipAccount$stat = _context6.v;
               state = _yield$ipAccount$stat.result;
-              _context5.n = 9;
+              _context6.n = 9;
               return generateOperationSignature({
                 ipIdAddress: arg.childIpId,
                 methodType: SignatureMethodType.BATCH_REGISTER_DERIVATIVE,
@@ -8816,7 +9336,7 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 9:
-              signature = _context5.v;
+              signature = _context6.v;
               contracts.push({
                 target: arg.childIpId,
                 allowFailure: false,
@@ -8827,42 +9347,42 @@ var IPAssetClient = /*#__PURE__*/function () {
                 })
               });
             case 10:
-              _context5.n = 2;
+              _context6.n = 2;
               break;
             case 11:
-              _context5.n = 13;
+              _context6.n = 13;
               break;
             case 12:
-              _context5.p = 12;
-              _t7 = _context5.v;
-              _iterator2.e(_t7);
+              _context6.p = 12;
+              _t8 = _context6.v;
+              _iterator2.e(_t8);
             case 13:
-              _context5.p = 13;
+              _context6.p = 13;
               _iterator2.f();
-              return _context5.f(13);
+              return _context6.f(13);
             case 14:
-              _context5.n = 15;
+              _context6.n = 15;
               return this.multicall3Client.aggregate3({
                 calls: contracts
               });
             case 15:
-              txHash = _context5.v;
-              _context5.n = 16;
+              txHash = _context6.v;
+              _context6.n = 16;
               return this.rpcClient.waitForTransactionReceipt(_objectSpread2(_objectSpread2({}, request.txOptions), {}, {
                 hash: txHash
               }));
             case 16:
-              return _context5.a(2, {
+              return _context6.a(2, {
                 txHash: txHash
               });
             case 17:
-              _context5.p = 17;
-              _t8 = _context5.v;
-              return _context5.a(2, handleError(_t8, "Failed to batch register derivative"));
+              _context6.p = 17;
+              _t9 = _context6.v;
+              return _context6.a(2, handleError(_t9, "Failed to batch register derivative"));
           }
-        }, _callee5, this, [[3, 5], [1, 12, 13, 14], [0, 17]]);
+        }, _callee6, this, [[3, 5], [1, 12, 13, 14], [0, 17]]);
       }));
-      function batchRegisterDerivative(_x6) {
+      function batchRegisterDerivative(_x7) {
         return _batchRegisterDerivative.apply(this, arguments);
       }
       return batchRegisterDerivative;
@@ -8894,12 +9414,12 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "registerDerivativeWithLicenseTokens",
     value: (function () {
-      var _registerDerivativeWithLicenseTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(request) {
-        var _request$txOptions3, req, isChildIpIdRegistered, txHash, _t9;
-        return _regenerator().w(function (_context6) {
-          while (1) switch (_context6.p = _context6.n) {
+      var _registerDerivativeWithLicenseTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(request) {
+        var _request$txOptions3, req, isChildIpIdRegistered, txHash, _t0;
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.p = _context7.n) {
             case 0:
-              _context6.p = 0;
+              _context7.p = 0;
               req = {
                 childIpId: validateAddress(request.childIpId),
                 licenseTokenIds: request.licenseTokenIds.map(function (id) {
@@ -8908,59 +9428,59 @@ var IPAssetClient = /*#__PURE__*/function () {
                 royaltyContext: zeroAddress,
                 maxRts: validateMaxRts(request.maxRts)
               };
-              _context6.n = 1;
+              _context7.n = 1;
               return this.isRegistered(request.childIpId);
             case 1:
-              isChildIpIdRegistered = _context6.v;
+              isChildIpIdRegistered = _context7.v;
               if (isChildIpIdRegistered) {
-                _context6.n = 2;
+                _context7.n = 2;
                 break;
               }
               throw new Error("The child IP with id ".concat(request.childIpId, " is not registered."));
             case 2:
               if (!(request.licenseTokenIds.length === 0)) {
-                _context6.n = 3;
+                _context7.n = 3;
                 break;
               }
               throw new Error("The licenseTokenIds must be provided.");
             case 3:
-              _context6.n = 4;
+              _context7.n = 4;
               return this.validateLicenseTokenIds(request.licenseTokenIds);
             case 4:
-              request.licenseTokenIds = _context6.v;
+              request.licenseTokenIds = _context7.v;
               if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.encodedTxDataOnly)) {
-                _context6.n = 5;
+                _context7.n = 5;
                 break;
               }
-              return _context6.a(2, {
+              return _context7.a(2, {
                 encodedTxData: this.licensingModuleClient.registerDerivativeWithLicenseTokensEncode(req)
               });
             case 5:
-              _context6.n = 6;
+              _context7.n = 6;
               return this.licensingModuleClient.registerDerivativeWithLicenseTokens(req);
             case 6:
-              txHash = _context6.v;
-              _context6.n = 7;
+              txHash = _context7.v;
+              _context7.n = 7;
               return this.rpcClient.waitForTransactionReceipt(_objectSpread2(_objectSpread2({}, request.txOptions), {}, {
                 hash: txHash
               }));
             case 7:
-              return _context6.a(2, {
+              return _context7.a(2, {
                 txHash: txHash
               });
             case 8:
-              _context6.n = 10;
+              _context7.n = 10;
               break;
             case 9:
-              _context6.p = 9;
-              _t9 = _context6.v;
-              return _context6.a(2, handleError(_t9, "Failed to register derivative with license tokens"));
+              _context7.p = 9;
+              _t0 = _context7.v;
+              return _context7.a(2, handleError(_t0, "Failed to register derivative with license tokens"));
             case 10:
-              return _context6.a(2);
+              return _context7.a(2);
           }
-        }, _callee6, this, [[0, 9]]);
+        }, _callee7, this, [[0, 9]]);
       }));
-      function registerDerivativeWithLicenseTokens(_x7) {
+      function registerDerivativeWithLicenseTokens(_x8) {
         return _registerDerivativeWithLicenseTokens.apply(this, arguments);
       }
       return registerDerivativeWithLicenseTokens;
@@ -8992,14 +9512,14 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "mintAndRegisterIpAssetWithPilTerms",
     value: (function () {
-      var _mintAndRegisterIpAssetWithPilTerms = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(request) {
-        var _this3 = this;
-        var _request$txOptions4, _yield$transformRegis, transformRequest, encodedTxData, contractCall, rsp, computedLicenseTermsIds, maxLicenseTokensTxHashes, _t0;
-        return _regenerator().w(function (_context7) {
-          while (1) switch (_context7.p = _context7.n) {
+      var _mintAndRegisterIpAssetWithPilTerms = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8(request) {
+        var _this2 = this;
+        var _request$txOptions4, _yield$transformRegis, transformRequest, encodedTxData, contractCall, rsp, computedLicenseTermsIds, maxLicenseTokensTxHashes, _t1;
+        return _regenerator().w(function (_context8) {
+          while (1) switch (_context8.p = _context8.n) {
             case 0:
-              _context7.p = 0;
-              _context7.n = 1;
+              _context8.p = 0;
+              _context8.n = 1;
               return transformRegistrationRequest({
                 request: request,
                 rpcClient: this.rpcClient,
@@ -9007,21 +9527,21 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 1:
-              _yield$transformRegis = _context7.v;
+              _yield$transformRegis = _context8.v;
               transformRequest = _yield$transformRegis.transformRequest;
               encodedTxData = this.licenseAttachmentWorkflowsClient.mintAndRegisterIpAndAttachPilTermsEncode(transformRequest);
               if (!((_request$txOptions4 = request.txOptions) !== null && _request$txOptions4 !== void 0 && _request$txOptions4.encodedTxDataOnly)) {
-                _context7.n = 2;
+                _context8.n = 2;
                 break;
               }
-              return _context7.a(2, {
+              return _context8.a(2, {
                 encodedTxData: encodedTxData
               });
             case 2:
               contractCall = function contractCall() {
-                return _this3.licenseAttachmentWorkflowsClient.mintAndRegisterIpAndAttachPilTerms(transformRequest);
+                return _this2.licenseAttachmentWorkflowsClient.mintAndRegisterIpAndAttachPilTerms(transformRequest);
               };
-              _context7.n = 3;
+              _context8.n = 3;
               return this.handleRegistrationWithFees({
                 options: request.options,
                 sender: this.walletAddress,
@@ -9032,14 +9552,14 @@ var IPAssetClient = /*#__PURE__*/function () {
                 txOptions: request.txOptions
               });
             case 3:
-              rsp = _context7.v;
-              _context7.n = 4;
+              rsp = _context8.v;
+              _context8.n = 4;
               return this.getLicenseTermsId(transformRequest.licenseTermsData.map(function (data) {
                 return data.terms;
               }));
             case 4:
-              computedLicenseTermsIds = _context7.v;
-              _context7.n = 5;
+              computedLicenseTermsIds = _context8.v;
+              _context8.n = 5;
               return setMaxLicenseTokens({
                 maxLicenseTokensData: request.licenseTermsData,
                 licensorIpId: rsp.ipId,
@@ -9048,20 +9568,20 @@ var IPAssetClient = /*#__PURE__*/function () {
                 templateAddress: this.licenseTemplateAddress
               });
             case 5:
-              maxLicenseTokensTxHashes = _context7.v;
-              return _context7.a(2, _objectSpread2(_objectSpread2({}, rsp), {}, {
+              maxLicenseTokensTxHashes = _context8.v;
+              return _context8.a(2, _objectSpread2(_objectSpread2({}, rsp), {}, {
                 licenseTermsIds: computedLicenseTermsIds
               }, maxLicenseTokensTxHashes.length > 0 && {
                 maxLicenseTokensTxHashes: maxLicenseTokensTxHashes
               }));
             case 6:
-              _context7.p = 6;
-              _t0 = _context7.v;
-              return _context7.a(2, handleError(_t0, "Failed to mint and register IP and attach PIL terms"));
+              _context8.p = 6;
+              _t1 = _context8.v;
+              return _context8.a(2, handleError(_t1, "Failed to mint and register IP and attach PIL terms"));
           }
-        }, _callee7, this, [[0, 6]]);
+        }, _callee8, this, [[0, 6]]);
       }));
-      function mintAndRegisterIpAssetWithPilTerms(_x8) {
+      function mintAndRegisterIpAssetWithPilTerms(_x9) {
         return _mintAndRegisterIpAssetWithPilTerms.apply(this, arguments);
       }
       return mintAndRegisterIpAssetWithPilTerms;
@@ -9069,64 +9589,68 @@ var IPAssetClient = /*#__PURE__*/function () {
     /**
      * Batch mint an NFT from a collection and register it as an IP.
      *
+     * @remark For better gas efficiency, consider using {@link batchRegisterIpAssetsWithOptimizedWorkflows} instead.
+     * The optimized workflows method provides intelligent transaction batching, automatic token handling.
+     *
      * Emits on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} and {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/modules/licensing/ILicensingModule.sol#L19 | `LicenseTermsAttached`} events.
      */
     )
   }, {
     key: "batchMintAndRegisterIpAssetWithPilTerms",
     value: (function () {
-      var _batchMintAndRegisterIpAssetWithPilTerms = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8(request) {
-        var calldata, _iterator3, _step3, arg, result, txHash, txReceipt, results, j, licenseTerms, licenseTermsData, i, licenseTerm, licenseTermsIds, maxLicenseTokensTxHashes, _t1, _t10;
-        return _regenerator().w(function (_context8) {
-          while (1) switch (_context8.p = _context8.n) {
+      var _batchMintAndRegisterIpAssetWithPilTerms = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(request) {
+        var _this3 = this;
+        var calldata, _iterator3, _step3, arg, result, txHash, txReceipt, results, _loop, j, _t10, _t11;
+        return _regenerator().w(function (_context0) {
+          while (1) switch (_context0.p = _context0.n) {
             case 0:
-              _context8.p = 0;
+              _context0.p = 0;
               calldata = [];
               _iterator3 = _createForOfIteratorHelper(request.args);
-              _context8.p = 1;
+              _context0.p = 1;
               _iterator3.s();
             case 2:
               if ((_step3 = _iterator3.n()).done) {
-                _context8.n = 5;
+                _context0.n = 5;
                 break;
               }
               arg = _step3.value;
-              _context8.n = 3;
+              _context0.n = 3;
               return this.mintAndRegisterIpAssetWithPilTerms(_objectSpread2(_objectSpread2({}, arg), {}, {
                 txOptions: {
                   encodedTxDataOnly: true
                 }
               }));
             case 3:
-              result = _context8.v;
+              result = _context0.v;
               calldata.push(result.encodedTxData.data);
             case 4:
-              _context8.n = 2;
+              _context0.n = 2;
               break;
             case 5:
-              _context8.n = 7;
+              _context0.n = 7;
               break;
             case 6:
-              _context8.p = 6;
-              _t1 = _context8.v;
-              _iterator3.e(_t1);
+              _context0.p = 6;
+              _t10 = _context0.v;
+              _iterator3.e(_t10);
             case 7:
-              _context8.p = 7;
+              _context0.p = 7;
               _iterator3.f();
-              return _context8.f(7);
+              return _context0.f(7);
             case 8:
-              _context8.n = 9;
+              _context0.n = 9;
               return this.licenseAttachmentWorkflowsClient.multicall({
                 data: calldata
               });
             case 9:
-              txHash = _context8.v;
-              _context8.n = 10;
+              txHash = _context0.v;
+              _context0.n = 10;
               return this.rpcClient.waitForTransactionReceipt(_objectSpread2(_objectSpread2({}, request.txOptions), {}, {
                 hash: txHash
               }));
             case 10:
-              txReceipt = _context8.v;
+              txReceipt = _context0.v;
               results = this.ipAssetRegistryClient.parseTxIpRegisteredEvent(txReceipt).map(function (log) {
                 return {
                   ipId: log.ipId,
@@ -9134,54 +9658,80 @@ var IPAssetClient = /*#__PURE__*/function () {
                   spgNftContract: log.tokenContract,
                   licenseTermsIds: []
                 };
-              }); // Due to emit event log by sequence, we need to get license terms id from request.args
+              }); // Get license terms id and max license tokens mapping relationship by the sequence of the request.args
+              _loop = /*#__PURE__*/_regenerator().m(function _loop() {
+                var licenseTerms, termsIndexes, licenseTermsData, licenseTermsIds, i, licenseTermsDataInput, validatedTerms, resolvedIds, filteredLicenseTermsIds, maxLicenseTokensTxHashes;
+                return _regenerator().w(function (_context9) {
+                  while (1) switch (_context9.n) {
+                    case 0:
+                      licenseTerms = [];
+                      termsIndexes = [];
+                      licenseTermsData = request.args[j].licenseTermsData;
+                      licenseTermsIds = new Array(licenseTermsData.length).fill(null);
+                      for (i = 0; i < licenseTermsData.length; i++) {
+                        licenseTermsDataInput = licenseTermsData[i];
+                        if (licenseTermsDataInput.terms) {
+                          validatedTerms = PILFlavor.validateLicenseTerms(licenseTermsDataInput.terms, _this3.chainId);
+                          validatedTerms.commercialRevShare = getRevenueShare(validatedTerms.commercialRevShare);
+                          licenseTerms.push(validatedTerms);
+                          termsIndexes.push(i);
+                        } else if (licenseTermsDataInput.licenseTermsId !== undefined) {
+                          licenseTermsIds[i] = BigInt(licenseTermsDataInput.licenseTermsId);
+                        }
+                      }
+                      _context9.n = 1;
+                      return _this3.getLicenseTermsId(licenseTerms);
+                    case 1:
+                      resolvedIds = _context9.v;
+                      termsIndexes.forEach(function (value, index) {
+                        licenseTermsIds[value] = resolvedIds[index];
+                      });
+                      filteredLicenseTermsIds = licenseTermsIds.filter(function (id) {
+                        return id !== null;
+                      });
+                      results[j].licenseTermsIds = filteredLicenseTermsIds;
+                      _context9.n = 2;
+                      return setMaxLicenseTokens({
+                        maxLicenseTokensData: licenseTermsData,
+                        licensorIpId: results[j].ipId,
+                        licenseTermsIds: filteredLicenseTermsIds,
+                        totalLicenseTokenLimitHookClient: _this3.totalLicenseTokenLimitHookClient,
+                        templateAddress: _this3.licenseTemplateAddress
+                      });
+                    case 2:
+                      maxLicenseTokensTxHashes = _context9.v;
+                      if (maxLicenseTokensTxHashes.length > 0) {
+                        results[j].maxLicenseTokensTxHashes = maxLicenseTokensTxHashes;
+                      }
+                    case 3:
+                      return _context9.a(2);
+                  }
+                }, _loop);
+              });
               j = 0;
             case 11:
               if (!(j < request.args.length)) {
-                _context8.n = 15;
+                _context0.n = 13;
                 break;
               }
-              licenseTerms = [];
-              licenseTermsData = request.args[j].licenseTermsData;
-              for (i = 0; i < licenseTermsData.length; i++) {
-                licenseTerm = PILFlavor.validateLicenseTerms(licenseTermsData[i].terms, this.chainId);
-                licenseTerms.push(licenseTerm);
-              }
-              _context8.n = 12;
-              return this.getLicenseTermsId(licenseTerms);
+              return _context0.d(_regeneratorValues(_loop()), 12);
             case 12:
-              licenseTermsIds = _context8.v;
-              results[j].licenseTermsIds = licenseTermsIds;
-              _context8.n = 13;
-              return setMaxLicenseTokens({
-                maxLicenseTokensData: licenseTermsData,
-                licensorIpId: results[j].ipId,
-                licenseTermsIds: licenseTermsIds,
-                totalLicenseTokenLimitHookClient: this.totalLicenseTokenLimitHookClient,
-                templateAddress: this.licenseTemplateAddress
-              });
-            case 13:
-              maxLicenseTokensTxHashes = _context8.v;
-              if (maxLicenseTokensTxHashes.length > 0) {
-                results[j].maxLicenseTokensTxHashes = maxLicenseTokensTxHashes;
-              }
-            case 14:
               j++;
-              _context8.n = 11;
+              _context0.n = 11;
               break;
-            case 15:
-              return _context8.a(2, {
+            case 13:
+              return _context0.a(2, {
                 txHash: txHash,
                 results: results
               });
-            case 16:
-              _context8.p = 16;
-              _t10 = _context8.v;
-              return _context8.a(2, handleError(_t10, "Failed to batch mint and register IP and attach PIL terms"));
+            case 14:
+              _context0.p = 14;
+              _t11 = _context0.v;
+              return _context0.a(2, handleError(_t11, "Failed to batch mint and register IP and attach PIL terms"));
           }
-        }, _callee8, this, [[1, 6, 7, 8], [0, 16]]);
+        }, _callee9, this, [[1, 6, 7, 8], [0, 14]]);
       }));
-      function batchMintAndRegisterIpAssetWithPilTerms(_x9) {
+      function batchMintAndRegisterIpAssetWithPilTerms(_x0) {
         return _batchMintAndRegisterIpAssetWithPilTerms.apply(this, arguments);
       }
       return batchMintAndRegisterIpAssetWithPilTerms;
@@ -9214,14 +9764,14 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "registerIpAndAttachPilTerms",
     value: (function () {
-      var _registerIpAndAttachPilTerms = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(request) {
-        var _request$txOptions5, ipIdAddress, isRegistered, _yield$validateLicens, licenseTerms, _yield$transformRegis2, _transformRequest, txHash, txReceipt, log, licenseTermsIds, maxLicenseTokensTxHashes, _t11;
-        return _regenerator().w(function (_context9) {
-          while (1) switch (_context9.p = _context9.n) {
+      var _registerIpAndAttachPilTerms = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee0(request) {
+        var _request$txOptions5, ipIdAddress, isRegistered, _yield$validateLicens, licenseTerms, _yield$transformRegis2, _transformRequest, txHash, txReceipt, log, licenseTermsIds, maxLicenseTokensTxHashes, _t12;
+        return _regenerator().w(function (_context1) {
+          while (1) switch (_context1.p = _context1.n) {
             case 0:
-              _context9.p = 0;
+              _context1.p = 0;
               request.tokenId = BigInt(request.tokenId);
-              _context9.n = 1;
+              _context1.n = 1;
               return getIpIdAddress({
                 nftContract: request.nftContract,
                 tokenId: request.tokenId,
@@ -9230,23 +9780,23 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 1:
-              ipIdAddress = _context9.v;
-              _context9.n = 2;
+              ipIdAddress = _context1.v;
+              _context1.n = 2;
               return this.isRegistered(ipIdAddress);
             case 2:
-              isRegistered = _context9.v;
+              isRegistered = _context1.v;
               if (!isRegistered) {
-                _context9.n = 3;
+                _context1.n = 3;
                 break;
               }
               throw new Error("The NFT with id ".concat(request.tokenId, " is already registered as IP."));
             case 3:
-              _context9.n = 4;
+              _context1.n = 4;
               return validateLicenseTermsData(request.licenseTermsData, this.rpcClient, this.chainId);
             case 4:
-              _yield$validateLicens = _context9.v;
+              _yield$validateLicens = _context1.v;
               licenseTerms = _yield$validateLicens.licenseTerms;
-              _context9.n = 5;
+              _context1.n = 5;
               return transformRegistrationRequest({
                 request: request,
                 rpcClient: this.rpcClient,
@@ -9254,32 +9804,32 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 5:
-              _yield$transformRegis2 = _context9.v;
+              _yield$transformRegis2 = _context1.v;
               _transformRequest = _yield$transformRegis2.transformRequest;
               if (!((_request$txOptions5 = request.txOptions) !== null && _request$txOptions5 !== void 0 && _request$txOptions5.encodedTxDataOnly)) {
-                _context9.n = 6;
+                _context1.n = 6;
                 break;
               }
-              return _context9.a(2, {
+              return _context1.a(2, {
                 encodedTxData: this.licenseAttachmentWorkflowsClient.registerIpAndAttachPilTermsEncode(_transformRequest)
               });
             case 6:
-              _context9.n = 7;
+              _context1.n = 7;
               return this.licenseAttachmentWorkflowsClient.registerIpAndAttachPilTerms(_transformRequest);
             case 7:
-              txHash = _context9.v;
-              _context9.n = 8;
+              txHash = _context1.v;
+              _context1.n = 8;
               return this.rpcClient.waitForTransactionReceipt(_objectSpread2(_objectSpread2({}, request.txOptions), {}, {
                 hash: txHash
               }));
             case 8:
-              txReceipt = _context9.v;
+              txReceipt = _context1.v;
               log = this.getIpIdAndTokenIdsFromEvent(txReceipt)[0];
-              _context9.n = 9;
+              _context1.n = 9;
               return this.getLicenseTermsId(licenseTerms);
             case 9:
-              licenseTermsIds = _context9.v;
-              _context9.n = 10;
+              licenseTermsIds = _context1.v;
+              _context1.n = 10;
               return setMaxLicenseTokens({
                 maxLicenseTokensData: request.licenseTermsData,
                 licensorIpId: log.ipId,
@@ -9288,26 +9838,26 @@ var IPAssetClient = /*#__PURE__*/function () {
                 templateAddress: this.licenseTemplateAddress
               });
             case 10:
-              maxLicenseTokensTxHashes = _context9.v;
-              return _context9.a(2, _objectSpread2(_objectSpread2({
+              maxLicenseTokensTxHashes = _context1.v;
+              return _context1.a(2, _objectSpread2(_objectSpread2({
                 txHash: txHash,
                 licenseTermsIds: licenseTermsIds
               }, maxLicenseTokensTxHashes.length > 0 && {
                 maxLicenseTokensTxHashes: maxLicenseTokensTxHashes
               }), log));
             case 11:
-              _context9.n = 13;
+              _context1.n = 13;
               break;
             case 12:
-              _context9.p = 12;
-              _t11 = _context9.v;
-              return _context9.a(2, handleError(_t11, "Failed to register IP and attach PIL terms"));
+              _context1.p = 12;
+              _t12 = _context1.v;
+              return _context1.a(2, handleError(_t12, "Failed to register IP and attach PIL terms"));
             case 13:
-              return _context9.a(2);
+              return _context1.a(2);
           }
-        }, _callee9, this, [[0, 12]]);
+        }, _callee0, this, [[0, 12]]);
       }));
-      function registerIpAndAttachPilTerms(_x0) {
+      function registerIpAndAttachPilTerms(_x1) {
         return _registerIpAndAttachPilTerms.apply(this, arguments);
       }
       return registerIpAndAttachPilTerms;
@@ -9340,15 +9890,15 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "registerDerivativeIp",
     value: (function () {
-      var _registerDerivativeIp = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee0(request) {
+      var _registerDerivativeIp = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee1(request) {
         var _this4 = this;
-        var _request$txOptions6, _request$options2, tokenId, ipIdAddress, isRegistered, _yield$transformRegis3, _transformRequest2, encodedTxData, contractCall, _t12;
-        return _regenerator().w(function (_context0) {
-          while (1) switch (_context0.p = _context0.n) {
+        var _request$txOptions6, _request$options, tokenId, ipIdAddress, isRegistered, _yield$transformRegis3, _transformRequest2, encodedTxData, contractCall, _t13;
+        return _regenerator().w(function (_context10) {
+          while (1) switch (_context10.p = _context10.n) {
             case 0:
-              _context0.p = 0;
+              _context10.p = 0;
               tokenId = BigInt(request.tokenId);
-              _context0.n = 1;
+              _context10.n = 1;
               return getIpIdAddress({
                 nftContract: request.nftContract,
                 tokenId: tokenId,
@@ -9357,18 +9907,18 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 1:
-              ipIdAddress = _context0.v;
-              _context0.n = 2;
+              ipIdAddress = _context10.v;
+              _context10.n = 2;
               return this.isRegistered(ipIdAddress);
             case 2:
-              isRegistered = _context0.v;
+              isRegistered = _context10.v;
               if (!isRegistered) {
-                _context0.n = 3;
+                _context10.n = 3;
                 break;
               }
               throw new Error("The NFT with id ".concat(tokenId, " is already registered as IP."));
             case 3:
-              _context0.n = 4;
+              _context10.n = 4;
               return transformRegistrationRequest({
                 request: request,
                 rpcClient: this.rpcClient,
@@ -9376,23 +9926,23 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 4:
-              _yield$transformRegis3 = _context0.v;
+              _yield$transformRegis3 = _context10.v;
               _transformRequest2 = _yield$transformRegis3.transformRequest;
               encodedTxData = this.derivativeWorkflowsClient.registerIpAndMakeDerivativeEncode(_transformRequest2);
               if (!((_request$txOptions6 = request.txOptions) !== null && _request$txOptions6 !== void 0 && _request$txOptions6.encodedTxDataOnly)) {
-                _context0.n = 5;
+                _context10.n = 5;
                 break;
               }
-              return _context0.a(2, {
+              return _context10.a(2, {
                 encodedTxData: encodedTxData
               });
             case 5:
               contractCall = function contractCall() {
                 return _this4.derivativeWorkflowsClient.registerIpAndMakeDerivative(_transformRequest2);
               };
-              return _context0.a(2, this.handleRegistrationWithFees({
+              return _context10.a(2, this.handleRegistrationWithFees({
                 options: _objectSpread2(_objectSpread2({}, request.options), {}, {
-                  wipOptions: _objectSpread2(_objectSpread2({}, (_request$options2 = request.options) === null || _request$options2 === void 0 ? void 0 : _request$options2.wipOptions), {}, {
+                  wipOptions: _objectSpread2(_objectSpread2({}, (_request$options = request.options) === null || _request$options === void 0 ? void 0 : _request$options.wipOptions), {}, {
                     useMulticallWhenPossible: false
                   })
                 }),
@@ -9404,13 +9954,13 @@ var IPAssetClient = /*#__PURE__*/function () {
                 txOptions: request.txOptions
               }));
             case 6:
-              _context0.p = 6;
-              _t12 = _context0.v;
-              return _context0.a(2, handleError(_t12, "Failed to register derivative IP"));
+              _context10.p = 6;
+              _t13 = _context10.v;
+              return _context10.a(2, handleError(_t13, "Failed to register derivative IP"));
           }
-        }, _callee0, this, [[0, 6]]);
+        }, _callee1, this, [[0, 6]]);
       }));
-      function registerDerivativeIp(_x1) {
+      function registerDerivativeIp(_x10) {
         return _registerDerivativeIp.apply(this, arguments);
       }
       return registerDerivativeIp;
@@ -9442,15 +9992,15 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "mintAndRegisterIpAndMakeDerivative",
     value: (function () {
-      var _mintAndRegisterIpAndMakeDerivative = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee1(request) {
+      var _mintAndRegisterIpAndMakeDerivative = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee10(request) {
         var _this5 = this;
-        var _request$txOptions7, spgNftContract, _yield$transformRegis4, _transformRequest3, encodedTxData, contractCall, _t13;
-        return _regenerator().w(function (_context1) {
-          while (1) switch (_context1.p = _context1.n) {
+        var _request$txOptions7, spgNftContract, _yield$transformRegis4, _transformRequest3, encodedTxData, contractCall, _t14;
+        return _regenerator().w(function (_context11) {
+          while (1) switch (_context11.p = _context11.n) {
             case 0:
-              _context1.p = 0;
+              _context11.p = 0;
               spgNftContract = validateAddress(request.spgNftContract);
-              _context1.n = 1;
+              _context11.n = 1;
               return transformRegistrationRequest({
                 request: request,
                 rpcClient: this.rpcClient,
@@ -9458,21 +10008,21 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 1:
-              _yield$transformRegis4 = _context1.v;
+              _yield$transformRegis4 = _context11.v;
               _transformRequest3 = _yield$transformRegis4.transformRequest;
               encodedTxData = this.derivativeWorkflowsClient.mintAndRegisterIpAndMakeDerivativeEncode(_transformRequest3);
               if (!((_request$txOptions7 = request.txOptions) !== null && _request$txOptions7 !== void 0 && _request$txOptions7.encodedTxDataOnly)) {
-                _context1.n = 2;
+                _context11.n = 2;
                 break;
               }
-              return _context1.a(2, {
+              return _context11.a(2, {
                 encodedTxData: encodedTxData
               });
             case 2:
               contractCall = function contractCall() {
                 return _this5.derivativeWorkflowsClient.mintAndRegisterIpAndMakeDerivative(_transformRequest3);
               };
-              return _context1.a(2, this.handleRegistrationWithFees({
+              return _context11.a(2, this.handleRegistrationWithFees({
                 options: request.options,
                 sender: this.walletAddress,
                 spgSpenderAddress: this.derivativeWorkflowsClient.address,
@@ -9483,13 +10033,13 @@ var IPAssetClient = /*#__PURE__*/function () {
                 txOptions: request.txOptions
               }));
             case 3:
-              _context1.p = 3;
-              _t13 = _context1.v;
-              return _context1.a(2, handleError(_t13, "Failed to mint and register IP and make derivative"));
+              _context11.p = 3;
+              _t14 = _context11.v;
+              return _context11.a(2, handleError(_t14, "Failed to mint and register IP and make derivative"));
           }
-        }, _callee1, this, [[0, 3]]);
+        }, _callee10, this, [[0, 3]]);
       }));
-      function mintAndRegisterIpAndMakeDerivative(_x10) {
+      function mintAndRegisterIpAndMakeDerivative(_x11) {
         return _mintAndRegisterIpAndMakeDerivative.apply(this, arguments);
       }
       return mintAndRegisterIpAndMakeDerivative;
@@ -9497,83 +10047,86 @@ var IPAssetClient = /*#__PURE__*/function () {
     /**
      * Batch mint an NFT from a collection and register it as a derivative IP without license tokens.
      *
+     * @remark For better gas efficiency, consider using {@link batchRegisterIpAssetsWithOptimizedWorkflows} instead.
+     * The optimized workflows method provides intelligent transaction batching, automatic token handling.
+     *
      * Emits an on-chain {@link https://github.com/storyprotocol/protocol-core-v1/blob/v1.3.1/contracts/interfaces/registries/IIPAssetRegistry.sol#L17 | `IPRegistered`} event.
      */
     )
   }, {
     key: "batchMintAndRegisterIpAndMakeDerivative",
     value: (function () {
-      var _batchMintAndRegisterIpAndMakeDerivative = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee10(request) {
-        var calldata, _iterator4, _step4, arg, result, txHash, txReceipt, _t14, _t15, _t16;
-        return _regenerator().w(function (_context10) {
-          while (1) switch (_context10.p = _context10.n) {
+      var _batchMintAndRegisterIpAndMakeDerivative = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee11(request) {
+        var calldata, _iterator4, _step4, arg, result, txHash, txReceipt, _t15, _t16, _t17;
+        return _regenerator().w(function (_context12) {
+          while (1) switch (_context12.p = _context12.n) {
             case 0:
-              _context10.p = 0;
+              _context12.p = 0;
               calldata = [];
               _iterator4 = _createForOfIteratorHelper(request.args);
-              _context10.p = 1;
+              _context12.p = 1;
               _iterator4.s();
             case 2:
               if ((_step4 = _iterator4.n()).done) {
-                _context10.n = 7;
+                _context12.n = 7;
                 break;
               }
               arg = _step4.value;
-              _context10.p = 3;
-              _context10.n = 4;
+              _context12.p = 3;
+              _context12.n = 4;
               return this.mintAndRegisterIpAndMakeDerivative(_objectSpread2(_objectSpread2({}, arg), {}, {
                 txOptions: {
                   encodedTxDataOnly: true
                 }
               }));
             case 4:
-              result = _context10.v;
+              result = _context12.v;
               calldata.push(result.encodedTxData.data);
-              _context10.n = 6;
+              _context12.n = 6;
               break;
             case 5:
-              _context10.p = 5;
-              _t14 = _context10.v;
-              throw new Error(_t14.message.replace("Failed to mint and register IP and make derivative: ", "").trim());
+              _context12.p = 5;
+              _t15 = _context12.v;
+              throw new Error(_t15.message.replace("Failed to mint and register IP and make derivative: ", "").trim());
             case 6:
-              _context10.n = 2;
+              _context12.n = 2;
               break;
             case 7:
-              _context10.n = 9;
+              _context12.n = 9;
               break;
             case 8:
-              _context10.p = 8;
-              _t15 = _context10.v;
-              _iterator4.e(_t15);
+              _context12.p = 8;
+              _t16 = _context12.v;
+              _iterator4.e(_t16);
             case 9:
-              _context10.p = 9;
+              _context12.p = 9;
               _iterator4.f();
-              return _context10.f(9);
+              return _context12.f(9);
             case 10:
-              _context10.n = 11;
+              _context12.n = 11;
               return this.derivativeWorkflowsClient.multicall({
                 data: calldata
               });
             case 11:
-              txHash = _context10.v;
-              _context10.n = 12;
+              txHash = _context12.v;
+              _context12.n = 12;
               return this.rpcClient.waitForTransactionReceipt(_objectSpread2(_objectSpread2({}, request.txOptions), {}, {
                 hash: txHash
               }));
             case 12:
-              txReceipt = _context10.v;
-              return _context10.a(2, {
+              txReceipt = _context12.v;
+              return _context12.a(2, {
                 txHash: txHash,
                 results: this.getIpIdAndTokenIdsFromEvent(txReceipt, "spgNftContract")
               });
             case 13:
-              _context10.p = 13;
-              _t16 = _context10.v;
-              return _context10.a(2, handleError(_t16, "Failed to batch mint and register IP and make derivative"));
+              _context12.p = 13;
+              _t17 = _context12.v;
+              return _context12.a(2, handleError(_t17, "Failed to batch mint and register IP and make derivative"));
           }
-        }, _callee10, this, [[3, 5], [1, 8, 9, 10], [0, 13]]);
+        }, _callee11, this, [[3, 5], [1, 8, 9, 10], [0, 13]]);
       }));
-      function batchMintAndRegisterIpAndMakeDerivative(_x11) {
+      function batchMintAndRegisterIpAndMakeDerivative(_x12) {
         return _batchMintAndRegisterIpAndMakeDerivative.apply(this, arguments);
       }
       return batchMintAndRegisterIpAndMakeDerivative;
@@ -9604,52 +10157,52 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "mintAndRegisterIp",
     value: (function () {
-      var _mintAndRegisterIp = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee11(request) {
+      var _mintAndRegisterIp = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee12(request) {
         var _this6 = this;
-        var _request$txOptions8, _request$options3, _object, encodedTxData, contractCall, _t17;
-        return _regenerator().w(function (_context11) {
-          while (1) switch (_context11.p = _context11.n) {
+        var _request$txOptions8, _request$options2, object, encodedTxData, contractCall, _t18;
+        return _regenerator().w(function (_context13) {
+          while (1) switch (_context13.p = _context13.n) {
             case 0:
-              _context11.p = 0;
-              _object = {
+              _context13.p = 0;
+              object = {
                 spgNftContract: validateAddress(request.spgNftContract),
                 recipient: validateAddress(request.recipient || this.walletAddress),
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata),
                 allowDuplicates: request.allowDuplicates || true
               };
-              encodedTxData = this.registrationWorkflowsClient.mintAndRegisterIpEncode(_object);
+              encodedTxData = this.registrationWorkflowsClient.mintAndRegisterIpEncode(object);
               if (!((_request$txOptions8 = request.txOptions) !== null && _request$txOptions8 !== void 0 && _request$txOptions8.encodedTxDataOnly)) {
-                _context11.n = 1;
+                _context13.n = 1;
                 break;
               }
-              return _context11.a(2, {
+              return _context13.a(2, {
                 encodedTxData: encodedTxData
               });
             case 1:
               contractCall = function contractCall() {
-                return _this6.registrationWorkflowsClient.mintAndRegisterIp(_object);
+                return _this6.registrationWorkflowsClient.mintAndRegisterIp(object);
               };
-              return _context11.a(2, this.handleRegistrationWithFees({
+              return _context13.a(2, this.handleRegistrationWithFees({
                 sender: this.walletAddress,
                 spgSpenderAddress: this.registrationWorkflowsClient.address,
                 encodedTxs: [encodedTxData],
                 contractCall: contractCall,
-                spgNftContract: _object.spgNftContract,
+                spgNftContract: object.spgNftContract,
                 txOptions: request.txOptions,
                 options: _objectSpread2(_objectSpread2({}, request.options), {}, {
-                  wipOptions: _objectSpread2(_objectSpread2({}, (_request$options3 = request.options) === null || _request$options3 === void 0 ? void 0 : _request$options3.wipOptions), {}, {
+                  wipOptions: _objectSpread2(_objectSpread2({}, (_request$options2 = request.options) === null || _request$options2 === void 0 ? void 0 : _request$options2.wipOptions), {}, {
                     useMulticallWhenPossible: false
                   })
                 })
               }));
             case 2:
-              _context11.p = 2;
-              _t17 = _context11.v;
-              return _context11.a(2, handleError(_t17, "Failed to mint and register IP"));
+              _context13.p = 2;
+              _t18 = _context13.v;
+              return _context13.a(2, handleError(_t18, "Failed to mint and register IP"));
           }
-        }, _callee11, this, [[0, 2]]);
+        }, _callee12, this, [[0, 2]]);
       }));
-      function mintAndRegisterIp(_x12) {
+      function mintAndRegisterIp(_x13) {
         return _mintAndRegisterIp.apply(this, arguments);
       }
       return mintAndRegisterIp;
@@ -9673,23 +10226,23 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "batchMintAndRegisterIp",
     value: (function () {
-      var _batchMintAndRegisterIp = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee14(request) {
+      var _batchMintAndRegisterIp = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee15(request) {
         var _this7 = this;
-        var publicMintEncodedTxs, publicMintSpenders, privateMintEncodedTxs, privateMintSpenders, _iterator5, _step5, req, registrationRequest, isPublicMinting, nftMintFee, encodeTx, isMinterRole, handlePublicMintTransactions, handlePrivateMintTransactions, transactionResponses, publicMintResponse, privateMintResponse, _t18, _t19, _t20, _t21;
-        return _regenerator().w(function (_context14) {
-          while (1) switch (_context14.p = _context14.n) {
+        var publicMintEncodedTxs, publicMintSpenders, privateMintEncodedTxs, privateMintSpenders, _iterator5, _step5, req, registrationRequest, isPublicMinting, nftMintFee, encodeTx, isMinterRole, handlePublicMintTransactions, handlePrivateMintTransactions, transactionResponses, publicMintResponse, privateMintResponse, _t19, _t20, _t21, _t22;
+        return _regenerator().w(function (_context16) {
+          while (1) switch (_context16.p = _context16.n) {
             case 0:
-              _context14.p = 0;
+              _context16.p = 0;
               publicMintEncodedTxs = [];
               publicMintSpenders = [];
               privateMintEncodedTxs = [];
               privateMintSpenders = [];
               _iterator5 = _createForOfIteratorHelper(request.requests);
-              _context14.p = 1;
+              _context16.p = 1;
               _iterator5.s();
             case 2:
               if ((_step5 = _iterator5.n()).done) {
-                _context14.n = 9;
+                _context16.n = 9;
                 break;
               }
               req = _step5.value;
@@ -9699,14 +10252,14 @@ var IPAssetClient = /*#__PURE__*/function () {
                 ipMetadata: getIpMetadataForWorkflow(req.ipMetadata),
                 allowDuplicates: req.allowDuplicates || true
               };
-              _context14.n = 3;
+              _context16.n = 3;
               return getPublicMinting(req.spgNftContract, this.rpcClient);
             case 3:
-              isPublicMinting = _context14.v;
-              _context14.n = 4;
+              isPublicMinting = _context16.v;
+              _context16.n = 4;
               return calculateSPGMintFee(new SpgnftImplReadOnlyClient(this.rpcClient, registrationRequest.spgNftContract));
             case 4:
-              nftMintFee = _context14.v;
+              nftMintFee = _context16.v;
               encodeTx = {
                 to: this.registrationWorkflowsClient.address,
                 data: encodeFunctionData({
@@ -9716,22 +10269,22 @@ var IPAssetClient = /*#__PURE__*/function () {
                 })
               };
               if (!isPublicMinting) {
-                _context14.n = 5;
+                _context16.n = 5;
                 break;
               }
               publicMintSpenders = mergeSpenders(publicMintSpenders, nftMintFee ? [_objectSpread2({
                 address: registrationRequest.spgNftContract
               }, nftMintFee)] : []);
               publicMintEncodedTxs.push(encodeTx);
-              _context14.n = 8;
+              _context16.n = 8;
               break;
             case 5:
-              _context14.n = 6;
+              _context16.n = 6;
               return hasMinterRole(registrationRequest.spgNftContract, this.rpcClient, this.walletAddress);
             case 6:
-              isMinterRole = _context14.v;
+              isMinterRole = _context16.v;
               if (isMinterRole) {
-                _context14.n = 7;
+                _context16.n = 7;
                 break;
               }
               throw new Error("Caller ".concat(this.walletAddress, " does not have the minter role for ").concat(registrationRequest.spgNftContract));
@@ -9741,26 +10294,26 @@ var IPAssetClient = /*#__PURE__*/function () {
               }, nftMintFee)] : []);
               privateMintEncodedTxs.push(encodeTx);
             case 8:
-              _context14.n = 2;
+              _context16.n = 2;
               break;
             case 9:
-              _context14.n = 11;
+              _context16.n = 11;
               break;
             case 10:
-              _context14.p = 10;
-              _t18 = _context14.v;
-              _iterator5.e(_t18);
+              _context16.p = 10;
+              _t19 = _context16.v;
+              _iterator5.e(_t19);
             case 11:
-              _context14.p = 11;
+              _context16.p = 11;
               _iterator5.f();
-              return _context14.f(11);
+              return _context16.f(11);
             case 12:
               handlePublicMintTransactions = /*#__PURE__*/function () {
-                var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee12() {
-                  return _regenerator().w(function (_context12) {
-                    while (1) switch (_context12.n) {
+                var _ref3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee13() {
+                  return _regenerator().w(function (_context14) {
+                    while (1) switch (_context14.n) {
                       case 0:
-                        _context12.n = 1;
+                        _context14.n = 1;
                         return contractCallWithFees({
                           options: {
                             wipOptions: request.wipOptions,
@@ -9782,20 +10335,20 @@ var IPAssetClient = /*#__PURE__*/function () {
                           encodedTxs: publicMintEncodedTxs
                         });
                       case 1:
-                        return _context12.a(2, _context12.v);
+                        return _context14.a(2, _context14.v);
                     }
-                  }, _callee12);
+                  }, _callee13);
                 }));
                 return function handlePublicMintTransactions() {
-                  return _ref2.apply(this, arguments);
+                  return _ref3.apply(this, arguments);
                 };
               }();
               handlePrivateMintTransactions = /*#__PURE__*/function () {
-                var _ref3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee13() {
-                  return _regenerator().w(function (_context13) {
-                    while (1) switch (_context13.n) {
+                var _ref4 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee14() {
+                  return _regenerator().w(function (_context15) {
+                    while (1) switch (_context15.n) {
                       case 0:
-                        _context13.n = 1;
+                        _context15.n = 1;
                         return contractCallWithFees({
                           options: {
                             wipOptions: _objectSpread2(_objectSpread2({}, request.wipOptions), {}, {
@@ -9819,50 +10372,50 @@ var IPAssetClient = /*#__PURE__*/function () {
                           encodedTxs: privateMintEncodedTxs
                         });
                       case 1:
-                        return _context13.a(2, _context13.v);
+                        return _context15.a(2, _context15.v);
                     }
-                  }, _callee13);
+                  }, _callee14);
                 }));
                 return function handlePrivateMintTransactions() {
-                  return _ref3.apply(this, arguments);
+                  return _ref4.apply(this, arguments);
                 };
               }();
               transactionResponses = [];
               if (!(privateMintEncodedTxs.length === 0)) {
-                _context14.n = 14;
+                _context16.n = 14;
                 break;
               }
-              _context14.n = 13;
+              _context16.n = 13;
               return handlePublicMintTransactions();
             case 13:
-              _t19 = _context14.v;
-              transactionResponses = [_t19];
-              _context14.n = 19;
+              _t20 = _context16.v;
+              transactionResponses = [_t20];
+              _context16.n = 19;
               break;
             case 14:
               if (!(publicMintEncodedTxs.length === 0)) {
-                _context14.n = 16;
+                _context16.n = 16;
                 break;
               }
-              _context14.n = 15;
+              _context16.n = 15;
               return handlePrivateMintTransactions();
             case 15:
-              _t20 = _context14.v;
-              transactionResponses = [_t20];
-              _context14.n = 19;
+              _t21 = _context16.v;
+              transactionResponses = [_t21];
+              _context16.n = 19;
               break;
             case 16:
-              _context14.n = 17;
+              _context16.n = 17;
               return handlePublicMintTransactions();
             case 17:
-              publicMintResponse = _context14.v;
-              _context14.n = 18;
+              publicMintResponse = _context16.v;
+              _context16.n = 18;
               return handlePrivateMintTransactions();
             case 18:
-              privateMintResponse = _context14.v;
+              privateMintResponse = _context16.v;
               transactionResponses = [publicMintResponse, privateMintResponse];
             case 19:
-              return _context14.a(2, {
+              return _context16.a(2, {
                 registrationResults: transactionResponses.map(function (r) {
                   return {
                     txHash: r.txHash,
@@ -9872,13 +10425,13 @@ var IPAssetClient = /*#__PURE__*/function () {
                 })
               });
             case 20:
-              _context14.p = 20;
-              _t21 = _context14.v;
-              return _context14.a(2, handleError(_t21, "Failed to batch mint and register IP"));
+              _context16.p = 20;
+              _t22 = _context16.v;
+              return _context16.a(2, handleError(_t22, "Failed to batch mint and register IP"));
           }
-        }, _callee14, this, [[1, 10, 11, 12], [0, 20]]);
+        }, _callee15, this, [[1, 10, 11, 12], [0, 20]]);
       }));
-      function batchMintAndRegisterIp(_x13) {
+      function batchMintAndRegisterIp(_x14) {
         return _batchMintAndRegisterIp.apply(this, arguments);
       }
       return batchMintAndRegisterIp;
@@ -9911,18 +10464,18 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "mintAndRegisterIpAndMakeDerivativeWithLicenseTokens",
     value: (function () {
-      var _mintAndRegisterIpAndMakeDerivativeWithLicenseTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee16(request) {
+      var _mintAndRegisterIpAndMakeDerivativeWithLicenseTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee17(request) {
         var _this8 = this;
-        var _request$txOptions9, _request$options4, licenseTokenIds, _object2, encodedTxData, contractCall, _t22;
-        return _regenerator().w(function (_context16) {
-          while (1) switch (_context16.p = _context16.n) {
+        var _request$txOptions9, _request$options3, licenseTokenIds, _object, encodedTxData, contractCall, _t23;
+        return _regenerator().w(function (_context18) {
+          while (1) switch (_context18.p = _context18.n) {
             case 0:
-              _context16.p = 0;
-              _context16.n = 1;
+              _context18.p = 0;
+              _context18.n = 1;
               return this.validateLicenseTokenIds(request.licenseTokenIds);
             case 1:
-              licenseTokenIds = _context16.v;
-              _object2 = {
+              licenseTokenIds = _context18.v;
+              _object = {
                 spgNftContract: validateAddress(request.spgNftContract),
                 recipient: validateAddress(request.recipient || this.walletAddress),
                 ipMetadata: getIpMetadataForWorkflow(request.ipMetadata),
@@ -9931,54 +10484,54 @@ var IPAssetClient = /*#__PURE__*/function () {
                 maxRts: validateMaxRts(request.maxRts),
                 allowDuplicates: request.allowDuplicates || true
               };
-              encodedTxData = this.derivativeWorkflowsClient.mintAndRegisterIpAndMakeDerivativeWithLicenseTokensEncode(_object2);
+              encodedTxData = this.derivativeWorkflowsClient.mintAndRegisterIpAndMakeDerivativeWithLicenseTokensEncode(_object);
               if (!((_request$txOptions9 = request.txOptions) !== null && _request$txOptions9 !== void 0 && _request$txOptions9.encodedTxDataOnly)) {
-                _context16.n = 2;
+                _context18.n = 2;
                 break;
               }
-              return _context16.a(2, {
+              return _context18.a(2, {
                 encodedTxData: encodedTxData
               });
             case 2:
-              _context16.n = 3;
+              _context18.n = 3;
               return this.approveLicenseTokensForDerivativeWorkflows(request.licenseTokenIds, request.autoApproveLicenseTokens);
             case 3:
               contractCall = /*#__PURE__*/function () {
-                var _ref4 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee15() {
-                  return _regenerator().w(function (_context15) {
-                    while (1) switch (_context15.n) {
+                var _ref5 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee16() {
+                  return _regenerator().w(function (_context17) {
+                    while (1) switch (_context17.n) {
                       case 0:
-                        return _context15.a(2, _this8.derivativeWorkflowsClient.mintAndRegisterIpAndMakeDerivativeWithLicenseTokens(_object2));
+                        return _context17.a(2, _this8.derivativeWorkflowsClient.mintAndRegisterIpAndMakeDerivativeWithLicenseTokens(_object));
                     }
-                  }, _callee15);
+                  }, _callee16);
                 }));
                 return function contractCall() {
-                  return _ref4.apply(this, arguments);
+                  return _ref5.apply(this, arguments);
                 };
               }();
-              return _context16.a(2, this.handleRegistrationWithFees({
+              return _context18.a(2, this.handleRegistrationWithFees({
                 options: _objectSpread2(_objectSpread2({}, request.options), {}, {
-                  wipOptions: _objectSpread2(_objectSpread2({}, (_request$options4 = request.options) === null || _request$options4 === void 0 ? void 0 : _request$options4.wipOptions), {}, {
+                  wipOptions: _objectSpread2(_objectSpread2({}, (_request$options3 = request.options) === null || _request$options3 === void 0 ? void 0 : _request$options3.wipOptions), {}, {
                     // need to disable multicall to avoid needing to transfer the license
                     // token to the multicall contract.
                     useMulticallWhenPossible: false
                   })
                 }),
                 sender: this.walletAddress,
-                spgNftContract: _object2.spgNftContract,
+                spgNftContract: _object.spgNftContract,
                 spgSpenderAddress: this.derivativeWorkflowsClient.address,
                 encodedTxs: [encodedTxData],
                 contractCall: contractCall,
                 txOptions: request.txOptions
               }));
             case 4:
-              _context16.p = 4;
-              _t22 = _context16.v;
-              return _context16.a(2, handleError(_t22, "Failed to mint and register IP and make derivative with license tokens"));
+              _context18.p = 4;
+              _t23 = _context18.v;
+              return _context18.a(2, handleError(_t23, "Failed to mint and register IP and make derivative with license tokens"));
           }
-        }, _callee16, this, [[0, 4]]);
+        }, _callee17, this, [[0, 4]]);
       }));
-      function mintAndRegisterIpAndMakeDerivativeWithLicenseTokens(_x14) {
+      function mintAndRegisterIpAndMakeDerivativeWithLicenseTokens(_x15) {
         return _mintAndRegisterIpAndMakeDerivativeWithLicenseTokens.apply(this, arguments);
       }
       return mintAndRegisterIpAndMakeDerivativeWithLicenseTokens;
@@ -10011,14 +10564,14 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "registerIpAndMakeDerivativeWithLicenseTokens",
     value: (function () {
-      var _registerIpAndMakeDerivativeWithLicenseTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee17(request) {
-        var _request$txOptions0, tokenId, ipIdAddress, isRegistered, licenseTokenIds, calculatedDeadline, signature, _object3, txHash, receipt, log, _t23;
-        return _regenerator().w(function (_context17) {
-          while (1) switch (_context17.p = _context17.n) {
+      var _registerIpAndMakeDerivativeWithLicenseTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee18(request) {
+        var _request$txOptions0, tokenId, ipIdAddress, isRegistered, licenseTokenIds, calculatedDeadline, signature, _object2, txHash, receipt, log, _t24;
+        return _regenerator().w(function (_context19) {
+          while (1) switch (_context19.p = _context19.n) {
             case 0:
-              _context17.p = 0;
+              _context19.p = 0;
               tokenId = BigInt(request.tokenId);
-              _context17.n = 1;
+              _context19.n = 1;
               return getIpIdAddress({
                 nftContract: request.nftContract,
                 tokenId: tokenId,
@@ -10027,26 +10580,26 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 1:
-              ipIdAddress = _context17.v;
-              _context17.n = 2;
+              ipIdAddress = _context19.v;
+              _context19.n = 2;
               return this.isRegistered(ipIdAddress);
             case 2:
-              isRegistered = _context17.v;
+              isRegistered = _context19.v;
               if (!isRegistered) {
-                _context17.n = 3;
+                _context19.n = 3;
                 break;
               }
               throw new Error("The NFT with id ".concat(tokenId, " is already registered as IP."));
             case 3:
-              _context17.n = 4;
+              _context19.n = 4;
               return this.validateLicenseTokenIds(request.licenseTokenIds);
             case 4:
-              licenseTokenIds = _context17.v;
-              _context17.n = 5;
+              licenseTokenIds = _context19.v;
+              _context19.n = 5;
               return getCalculatedDeadline(this.rpcClient, request.deadline);
             case 5:
-              calculatedDeadline = _context17.v;
-              _context17.n = 6;
+              calculatedDeadline = _context19.v;
+              _context19.n = 6;
               return generateOperationSignature({
                 ipIdAddress: ipIdAddress,
                 methodType: SignatureMethodType.REGISTER_IP_AND_MAKE_DERIVATIVE_WITH_LICENSE_TOKENS,
@@ -10055,11 +10608,11 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 6:
-              signature = _context17.v;
-              _context17.n = 7;
+              signature = _context19.v;
+              _context19.n = 7;
               return this.approveLicenseTokensForDerivativeWorkflows(licenseTokenIds, request.autoApproveLicenseTokens);
             case 7:
-              _object3 = _objectSpread2(_objectSpread2({}, request), {}, {
+              _object2 = _objectSpread2(_objectSpread2({}, request), {}, {
                 tokenId: tokenId,
                 licenseTokenIds: licenseTokenIds,
                 royaltyContext: zeroAddress,
@@ -10072,40 +10625,40 @@ var IPAssetClient = /*#__PURE__*/function () {
                 maxRts: validateMaxRts(request.maxRts)
               });
               if (!((_request$txOptions0 = request.txOptions) !== null && _request$txOptions0 !== void 0 && _request$txOptions0.encodedTxDataOnly)) {
-                _context17.n = 8;
+                _context19.n = 8;
                 break;
               }
-              return _context17.a(2, {
-                encodedTxData: this.derivativeWorkflowsClient.registerIpAndMakeDerivativeWithLicenseTokensEncode(_object3)
+              return _context19.a(2, {
+                encodedTxData: this.derivativeWorkflowsClient.registerIpAndMakeDerivativeWithLicenseTokensEncode(_object2)
               });
             case 8:
-              _context17.n = 9;
-              return this.derivativeWorkflowsClient.registerIpAndMakeDerivativeWithLicenseTokens(_object3);
+              _context19.n = 9;
+              return this.derivativeWorkflowsClient.registerIpAndMakeDerivativeWithLicenseTokens(_object2);
             case 9:
-              txHash = _context17.v;
-              _context17.n = 10;
+              txHash = _context19.v;
+              _context19.n = 10;
               return this.rpcClient.waitForTransactionReceipt(_objectSpread2(_objectSpread2({}, request.txOptions), {}, {
                 hash: txHash
               }));
             case 10:
-              receipt = _context17.v;
+              receipt = _context19.v;
               log = this.getIpIdAndTokenIdsFromEvent(receipt)[0];
-              return _context17.a(2, _objectSpread2({
+              return _context19.a(2, _objectSpread2({
                 txHash: txHash
               }, log));
             case 11:
-              _context17.n = 13;
+              _context19.n = 13;
               break;
             case 12:
-              _context17.p = 12;
-              _t23 = _context17.v;
-              return _context17.a(2, handleError(_t23, "Failed to register IP and make derivative with license tokens"));
+              _context19.p = 12;
+              _t24 = _context19.v;
+              return _context19.a(2, handleError(_t24, "Failed to register IP and make derivative with license tokens"));
             case 13:
-              return _context17.a(2);
+              return _context19.a(2);
           }
-        }, _callee17, this, [[0, 12]]);
+        }, _callee18, this, [[0, 12]]);
       }));
-      function registerIpAndMakeDerivativeWithLicenseTokens(_x15) {
+      function registerIpAndMakeDerivativeWithLicenseTokens(_x16) {
         return _registerIpAndMakeDerivativeWithLicenseTokens.apply(this, arguments);
       }
       return registerIpAndMakeDerivativeWithLicenseTokens;
@@ -10142,23 +10695,23 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "registerIPAndAttachLicenseTermsAndDistributeRoyaltyTokens",
     value: (function () {
-      var _registerIPAndAttachLicenseTermsAndDistributeRoyaltyTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee18(request) {
-        var _getRoyaltyShares, royaltyShares, totalAmount, _yield$validateLicens2, licenseTerms, calculatedDeadline, ipIdAddress, isRegistered, _yield$transformRegis5, _transformRequest4, registerIpAndAttachPilTermsAndDeployRoyaltyVaultTxHash, txReceipt, ipId, licenseTermsIds, ipRoyaltyVault, distributeRoyaltyTokensTxHash, maxLicenseTokensTxHashes, _t24;
-        return _regenerator().w(function (_context18) {
-          while (1) switch (_context18.p = _context18.n) {
+      var _registerIPAndAttachLicenseTermsAndDistributeRoyaltyTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee19(request) {
+        var _getRoyaltyShares, royaltyShares, totalAmount, _yield$validateLicens2, licenseTerms, calculatedDeadline, ipIdAddress, isRegistered, _yield$transformRegis5, _transformRequest4, registerIpAndAttachPilTermsAndDeployRoyaltyVaultTxHash, txReceipt, ipId, licenseTermsIds, ipRoyaltyVault, distributeRoyaltyTokensTxHash, maxLicenseTokensTxHashes, _t25;
+        return _regenerator().w(function (_context20) {
+          while (1) switch (_context20.p = _context20.n) {
             case 0:
-              _context18.p = 0;
+              _context20.p = 0;
               _getRoyaltyShares = getRoyaltyShares(request.royaltyShares), royaltyShares = _getRoyaltyShares.royaltyShares, totalAmount = _getRoyaltyShares.totalAmount;
-              _context18.n = 1;
+              _context20.n = 1;
               return validateLicenseTermsData(request.licenseTermsData, this.rpcClient, this.chainId);
             case 1:
-              _yield$validateLicens2 = _context18.v;
+              _yield$validateLicens2 = _context20.v;
               licenseTerms = _yield$validateLicens2.licenseTerms;
-              _context18.n = 2;
+              _context20.n = 2;
               return getCalculatedDeadline(this.rpcClient, request.deadline);
             case 2:
-              calculatedDeadline = _context18.v;
-              _context18.n = 3;
+              calculatedDeadline = _context20.v;
+              _context20.n = 3;
               return getIpIdAddress({
                 nftContract: validateAddress(request.nftContract),
                 tokenId: BigInt(request.tokenId),
@@ -10167,18 +10720,18 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 3:
-              ipIdAddress = _context18.v;
-              _context18.n = 4;
+              ipIdAddress = _context20.v;
+              _context20.n = 4;
               return this.isRegistered(ipIdAddress);
             case 4:
-              isRegistered = _context18.v;
+              isRegistered = _context20.v;
               if (!isRegistered) {
-                _context18.n = 5;
+                _context20.n = 5;
                 break;
               }
               throw new Error("The NFT with id ".concat(request.tokenId, " is already registered as IP."));
             case 5:
-              _context18.n = 6;
+              _context20.n = 6;
               return transformRegistrationRequest({
                 request: request,
                 rpcClient: this.rpcClient,
@@ -10186,25 +10739,25 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 6:
-              _yield$transformRegis5 = _context18.v;
+              _yield$transformRegis5 = _context20.v;
               _transformRequest4 = _yield$transformRegis5.transformRequest;
-              _context18.n = 7;
+              _context20.n = 7;
               return this.royaltyTokenDistributionWorkflowsClient.registerIpAndAttachPilTermsAndDeployRoyaltyVault(_transformRequest4);
             case 7:
-              registerIpAndAttachPilTermsAndDeployRoyaltyVaultTxHash = _context18.v;
-              _context18.n = 8;
+              registerIpAndAttachPilTermsAndDeployRoyaltyVaultTxHash = _context20.v;
+              _context20.n = 8;
               return this.rpcClient.waitForTransactionReceipt(_objectSpread2(_objectSpread2({}, request.txOptions), {}, {
                 hash: registerIpAndAttachPilTermsAndDeployRoyaltyVaultTxHash
               }));
             case 8:
-              txReceipt = _context18.v;
+              txReceipt = _context20.v;
               ipId = this.getIpIdAndTokenIdsFromEvent(txReceipt)[0].ipId;
-              _context18.n = 9;
+              _context20.n = 9;
               return this.getLicenseTermsId(licenseTerms);
             case 9:
-              licenseTermsIds = _context18.v;
+              licenseTermsIds = _context20.v;
               ipRoyaltyVault = this.royaltyModuleEventClient.parseTxIpRoyaltyVaultDeployedEvent(txReceipt)[0].ipRoyaltyVault;
-              _context18.n = 10;
+              _context20.n = 10;
               return this.distributeRoyaltyTokens({
                 ipId: ipId,
                 deadline: calculatedDeadline,
@@ -10214,13 +10767,13 @@ var IPAssetClient = /*#__PURE__*/function () {
                 txOptions: request.txOptions
               });
             case 10:
-              distributeRoyaltyTokensTxHash = _context18.v;
-              _context18.n = 11;
+              distributeRoyaltyTokensTxHash = _context20.v;
+              _context20.n = 11;
               return this.rpcClient.waitForTransactionReceipt(_objectSpread2(_objectSpread2({}, request.txOptions), {}, {
                 hash: distributeRoyaltyTokensTxHash
               }));
             case 11:
-              _context18.n = 12;
+              _context20.n = 12;
               return setMaxLicenseTokens({
                 maxLicenseTokensData: request.licenseTermsData,
                 licensorIpId: ipId,
@@ -10229,8 +10782,8 @@ var IPAssetClient = /*#__PURE__*/function () {
                 templateAddress: this.licenseTemplateAddress
               });
             case 12:
-              maxLicenseTokensTxHashes = _context18.v;
-              return _context18.a(2, _objectSpread2({
+              maxLicenseTokensTxHashes = _context20.v;
+              return _context20.a(2, _objectSpread2({
                 registerIpAndAttachPilTermsAndDeployRoyaltyVaultTxHash: registerIpAndAttachPilTermsAndDeployRoyaltyVaultTxHash,
                 distributeRoyaltyTokensTxHash: distributeRoyaltyTokensTxHash,
                 ipId: ipId,
@@ -10240,13 +10793,13 @@ var IPAssetClient = /*#__PURE__*/function () {
                 maxLicenseTokensTxHashes: maxLicenseTokensTxHashes
               }));
             case 13:
-              _context18.p = 13;
-              _t24 = _context18.v;
-              return _context18.a(2, handleError(_t24, "Failed to register IP and attach license terms and distribute royalty tokens"));
+              _context20.p = 13;
+              _t25 = _context20.v;
+              return _context20.a(2, handleError(_t25, "Failed to register IP and attach license terms and distribute royalty tokens"));
           }
-        }, _callee18, this, [[0, 13]]);
+        }, _callee19, this, [[0, 13]]);
       }));
-      function registerIPAndAttachLicenseTermsAndDistributeRoyaltyTokens(_x16) {
+      function registerIPAndAttachLicenseTermsAndDistributeRoyaltyTokens(_x17) {
         return _registerIPAndAttachLicenseTermsAndDistributeRoyaltyTokens.apply(this, arguments);
       }
       return registerIPAndAttachLicenseTermsAndDistributeRoyaltyTokens;
@@ -10282,14 +10835,14 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "registerDerivativeIpAndAttachLicenseTermsAndDistributeRoyaltyTokens",
     value: (function () {
-      var _registerDerivativeIpAndAttachLicenseTermsAndDistributeRoyaltyTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee19(request) {
+      var _registerDerivativeIpAndAttachLicenseTermsAndDistributeRoyaltyTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee20(request) {
         var _this9 = this;
-        var _request$options5, ipIdAddress, _yield$transformRegis6, _transformRequest5, _getRoyaltyShares2, royaltyShares, totalAmount, isRegistered, encodedTxData, contractCall, _yield$this$handleReg, txHash, ipId, tokenId, receipt, ipRoyaltyVault, distributeRoyaltyTokensTxHash, _t25;
-        return _regenerator().w(function (_context19) {
-          while (1) switch (_context19.p = _context19.n) {
+        var _request$options4, ipIdAddress, _yield$transformRegis6, _transformRequest5, _getRoyaltyShares2, royaltyShares, totalAmount, isRegistered, encodedTxData, contractCall, _yield$this$handleReg, txHash, ipId, tokenId, receipt, ipRoyaltyVault, distributeRoyaltyTokensTxHash, _t26;
+        return _regenerator().w(function (_context21) {
+          while (1) switch (_context21.p = _context21.n) {
             case 0:
-              _context19.p = 0;
-              _context19.n = 1;
+              _context21.p = 0;
+              _context21.n = 1;
               return getIpIdAddress({
                 nftContract: validateAddress(request.nftContract),
                 tokenId: BigInt(request.tokenId),
@@ -10298,8 +10851,8 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 1:
-              ipIdAddress = _context19.v;
-              _context19.n = 2;
+              ipIdAddress = _context21.v;
+              _context21.n = 2;
               return transformRegistrationRequest({
                 request: request,
                 rpcClient: this.rpcClient,
@@ -10307,15 +10860,15 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 2:
-              _yield$transformRegis6 = _context19.v;
+              _yield$transformRegis6 = _context21.v;
               _transformRequest5 = _yield$transformRegis6.transformRequest;
               _getRoyaltyShares2 = getRoyaltyShares(request.royaltyShares), royaltyShares = _getRoyaltyShares2.royaltyShares, totalAmount = _getRoyaltyShares2.totalAmount;
-              _context19.n = 3;
+              _context21.n = 3;
               return this.isRegistered(ipIdAddress);
             case 3:
-              isRegistered = _context19.v;
+              isRegistered = _context21.v;
               if (!isRegistered) {
-                _context19.n = 4;
+                _context21.n = 4;
                 break;
               }
               throw new Error("The NFT with id ".concat(request.tokenId, " is already registered as IP."));
@@ -10324,10 +10877,10 @@ var IPAssetClient = /*#__PURE__*/function () {
               contractCall = function contractCall() {
                 return _this9.royaltyTokenDistributionWorkflowsClient.registerIpAndMakeDerivativeAndDeployRoyaltyVault(_transformRequest5);
               };
-              _context19.n = 5;
+              _context21.n = 5;
               return this.handleRegistrationWithFees({
                 options: _objectSpread2(_objectSpread2({}, request.options), {}, {
-                  wipOptions: _objectSpread2(_objectSpread2({}, (_request$options5 = request.options) === null || _request$options5 === void 0 ? void 0 : _request$options5.wipOptions), {}, {
+                  wipOptions: _objectSpread2(_objectSpread2({}, (_request$options4 = request.options) === null || _request$options4 === void 0 ? void 0 : _request$options4.wipOptions), {}, {
                     useMulticallWhenPossible: false
                   })
                 }),
@@ -10339,13 +10892,13 @@ var IPAssetClient = /*#__PURE__*/function () {
                 txOptions: _objectSpread2({}, request.txOptions)
               });
             case 5:
-              _yield$this$handleReg = _context19.v;
+              _yield$this$handleReg = _context21.v;
               txHash = _yield$this$handleReg.txHash;
               ipId = _yield$this$handleReg.ipId;
               tokenId = _yield$this$handleReg.tokenId;
               receipt = _yield$this$handleReg.receipt;
               if (!(tokenId === undefined || !ipId || !receipt)) {
-                _context19.n = 6;
+                _context21.n = 6;
                 break;
               }
               throw new Error("Failed to register derivative ip and deploy royalty vault.");
@@ -10353,7 +10906,7 @@ var IPAssetClient = /*#__PURE__*/function () {
               ipRoyaltyVault = this.royaltyModuleEventClient.parseTxIpRoyaltyVaultDeployedEvent(receipt).filter(function (item) {
                 return item.ipId === ipId;
               })[0].ipRoyaltyVault;
-              _context19.n = 7;
+              _context21.n = 7;
               return this.distributeRoyaltyTokens({
                 ipId: ipId,
                 deadline: request.deadline,
@@ -10363,13 +10916,13 @@ var IPAssetClient = /*#__PURE__*/function () {
                 txOptions: request.txOptions
               });
             case 7:
-              distributeRoyaltyTokensTxHash = _context19.v;
-              _context19.n = 8;
+              distributeRoyaltyTokensTxHash = _context21.v;
+              _context21.n = 8;
               return this.rpcClient.waitForTransactionReceipt(_objectSpread2(_objectSpread2({}, request.txOptions), {}, {
                 hash: distributeRoyaltyTokensTxHash
               }));
             case 8:
-              return _context19.a(2, {
+              return _context21.a(2, {
                 registerDerivativeIpAndAttachLicenseTermsAndDistributeRoyaltyTokensTxHash: txHash,
                 distributeRoyaltyTokensTxHash: distributeRoyaltyTokensTxHash,
                 ipId: ipId,
@@ -10377,13 +10930,13 @@ var IPAssetClient = /*#__PURE__*/function () {
                 ipRoyaltyVault: ipRoyaltyVault
               });
             case 9:
-              _context19.p = 9;
-              _t25 = _context19.v;
-              return _context19.a(2, handleError(_t25, "Failed to register derivative IP and attach license terms and distribute royalty tokens"));
+              _context21.p = 9;
+              _t26 = _context21.v;
+              return _context21.a(2, handleError(_t26, "Failed to register derivative IP and attach license terms and distribute royalty tokens"));
           }
-        }, _callee19, this, [[0, 9]]);
+        }, _callee20, this, [[0, 9]]);
       }));
-      function registerDerivativeIpAndAttachLicenseTermsAndDistributeRoyaltyTokens(_x17) {
+      function registerDerivativeIpAndAttachLicenseTermsAndDistributeRoyaltyTokens(_x18) {
         return _registerDerivativeIpAndAttachLicenseTermsAndDistributeRoyaltyTokens.apply(this, arguments);
       }
       return registerDerivativeIpAndAttachLicenseTermsAndDistributeRoyaltyTokens;
@@ -10417,19 +10970,19 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "mintAndRegisterIpAndAttachPilTermsAndDistributeRoyaltyTokens",
     value: (function () {
-      var _mintAndRegisterIpAndAttachPilTermsAndDistributeRoyaltyTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee20(request) {
+      var _mintAndRegisterIpAndAttachPilTermsAndDistributeRoyaltyTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee21(request) {
         var _this0 = this;
-        var _request$options6, _yield$validateLicens3, licenseTerms, _yield$transformRegis7, _transformRequest6, encodedTxData, contractCall, _yield$this$handleReg2, txHash, ipId, tokenId, receipt, licenseTermsIds, ipRoyaltyVault, maxLicenseTokensTxHashes, _t26;
-        return _regenerator().w(function (_context20) {
-          while (1) switch (_context20.p = _context20.n) {
+        var _request$options5, _yield$validateLicens3, licenseTerms, _yield$transformRegis7, _transformRequest6, encodedTxData, contractCall, _yield$this$handleReg2, txHash, ipId, tokenId, receipt, licenseTermsIds, ipRoyaltyVault, maxLicenseTokensTxHashes, _t27;
+        return _regenerator().w(function (_context22) {
+          while (1) switch (_context22.p = _context22.n) {
             case 0:
-              _context20.p = 0;
-              _context20.n = 1;
+              _context22.p = 0;
+              _context22.n = 1;
               return validateLicenseTermsData(request.licenseTermsData, this.rpcClient, this.chainId);
             case 1:
-              _yield$validateLicens3 = _context20.v;
+              _yield$validateLicens3 = _context22.v;
               licenseTerms = _yield$validateLicens3.licenseTerms;
-              _context20.n = 2;
+              _context22.n = 2;
               return transformRegistrationRequest({
                 request: request,
                 rpcClient: this.rpcClient,
@@ -10437,16 +10990,16 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 2:
-              _yield$transformRegis7 = _context20.v;
+              _yield$transformRegis7 = _context22.v;
               _transformRequest6 = _yield$transformRegis7.transformRequest;
               encodedTxData = this.royaltyTokenDistributionWorkflowsClient.mintAndRegisterIpAndAttachPilTermsAndDistributeRoyaltyTokensEncode(_transformRequest6);
               contractCall = function contractCall() {
                 return _this0.royaltyTokenDistributionWorkflowsClient.mintAndRegisterIpAndAttachPilTermsAndDistributeRoyaltyTokens(_transformRequest6);
               };
-              _context20.n = 3;
+              _context22.n = 3;
               return this.handleRegistrationWithFees({
                 options: _objectSpread2(_objectSpread2({}, request.options), {}, {
-                  wipOptions: _objectSpread2(_objectSpread2({}, (_request$options6 = request.options) === null || _request$options6 === void 0 ? void 0 : _request$options6.wipOptions), {}, {
+                  wipOptions: _objectSpread2(_objectSpread2({}, (_request$options5 = request.options) === null || _request$options5 === void 0 ? void 0 : _request$options5.wipOptions), {}, {
                     useMulticallWhenPossible: false
                   })
                 }),
@@ -10458,25 +11011,25 @@ var IPAssetClient = /*#__PURE__*/function () {
                 txOptions: request.txOptions
               });
             case 3:
-              _yield$this$handleReg2 = _context20.v;
+              _yield$this$handleReg2 = _context22.v;
               txHash = _yield$this$handleReg2.txHash;
               ipId = _yield$this$handleReg2.ipId;
               tokenId = _yield$this$handleReg2.tokenId;
               receipt = _yield$this$handleReg2.receipt;
               if (receipt) {
-                _context20.n = 4;
+                _context22.n = 4;
                 break;
               }
-              return _context20.a(2, {
+              return _context22.a(2, {
                 txHash: txHash
               });
             case 4:
-              _context20.n = 5;
+              _context22.n = 5;
               return this.getLicenseTermsId(licenseTerms);
             case 5:
-              licenseTermsIds = _context20.v;
+              licenseTermsIds = _context22.v;
               ipRoyaltyVault = this.royaltyModuleEventClient.parseTxIpRoyaltyVaultDeployedEvent(receipt)[0].ipRoyaltyVault;
-              _context20.n = 6;
+              _context22.n = 6;
               return setMaxLicenseTokens({
                 maxLicenseTokensData: request.licenseTermsData,
                 licensorIpId: ipId,
@@ -10485,8 +11038,8 @@ var IPAssetClient = /*#__PURE__*/function () {
                 templateAddress: this.licenseTemplateAddress
               });
             case 6:
-              maxLicenseTokensTxHashes = _context20.v;
-              return _context20.a(2, _objectSpread2({
+              maxLicenseTokensTxHashes = _context22.v;
+              return _context22.a(2, _objectSpread2({
                 txHash: txHash,
                 ipId: ipId,
                 licenseTermsIds: licenseTermsIds,
@@ -10496,13 +11049,13 @@ var IPAssetClient = /*#__PURE__*/function () {
                 maxLicenseTokensTxHashes: maxLicenseTokensTxHashes
               }));
             case 7:
-              _context20.p = 7;
-              _t26 = _context20.v;
-              return _context20.a(2, handleError(_t26, "Failed to mint and register IP and attach PIL terms and distribute royalty tokens"));
+              _context22.p = 7;
+              _t27 = _context22.v;
+              return _context22.a(2, handleError(_t27, "Failed to mint and register IP and attach PIL terms and distribute royalty tokens"));
           }
-        }, _callee20, this, [[0, 7]]);
+        }, _callee21, this, [[0, 7]]);
       }));
-      function mintAndRegisterIpAndAttachPilTermsAndDistributeRoyaltyTokens(_x18) {
+      function mintAndRegisterIpAndAttachPilTermsAndDistributeRoyaltyTokens(_x19) {
         return _mintAndRegisterIpAndAttachPilTermsAndDistributeRoyaltyTokens.apply(this, arguments);
       }
       return mintAndRegisterIpAndAttachPilTermsAndDistributeRoyaltyTokens;
@@ -10536,14 +11089,14 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "mintAndRegisterIpAndMakeDerivativeAndDistributeRoyaltyTokens",
     value: (function () {
-      var _mintAndRegisterIpAndMakeDerivativeAndDistributeRoyaltyTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee21(request) {
+      var _mintAndRegisterIpAndMakeDerivativeAndDistributeRoyaltyTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee22(request) {
         var _this1 = this;
-        var _yield$transformRegis8, _transformRequest7, encodedTxData, contractCall, _t27;
-        return _regenerator().w(function (_context21) {
-          while (1) switch (_context21.p = _context21.n) {
+        var _yield$transformRegis8, _transformRequest7, encodedTxData, contractCall, _t28;
+        return _regenerator().w(function (_context23) {
+          while (1) switch (_context23.p = _context23.n) {
             case 0:
-              _context21.p = 0;
-              _context21.n = 1;
+              _context23.p = 0;
+              _context23.n = 1;
               return transformRegistrationRequest({
                 request: request,
                 rpcClient: this.rpcClient,
@@ -10551,13 +11104,13 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 1:
-              _yield$transformRegis8 = _context21.v;
+              _yield$transformRegis8 = _context23.v;
               _transformRequest7 = _yield$transformRegis8.transformRequest;
               encodedTxData = this.royaltyTokenDistributionWorkflowsClient.mintAndRegisterIpAndMakeDerivativeAndDistributeRoyaltyTokensEncode(_transformRequest7);
               contractCall = function contractCall() {
                 return _this1.royaltyTokenDistributionWorkflowsClient.mintAndRegisterIpAndMakeDerivativeAndDistributeRoyaltyTokens(_transformRequest7);
               };
-              _context21.n = 2;
+              _context23.n = 2;
               return this.handleRegistrationWithFees({
                 spgNftContract: _transformRequest7.spgNftContract,
                 options: request.options,
@@ -10569,15 +11122,15 @@ var IPAssetClient = /*#__PURE__*/function () {
                 txOptions: request.txOptions
               });
             case 2:
-              return _context21.a(2, _context21.v);
+              return _context23.a(2, _context23.v);
             case 3:
-              _context21.p = 3;
-              _t27 = _context21.v;
-              return _context21.a(2, handleError(_t27, "Failed to mint and register IP and make derivative and distribute royalty tokens"));
+              _context23.p = 3;
+              _t28 = _context23.v;
+              return _context23.a(2, handleError(_t28, "Failed to mint and register IP and make derivative and distribute royalty tokens"));
           }
-        }, _callee21, this, [[0, 3]]);
+        }, _callee22, this, [[0, 3]]);
       }));
-      function mintAndRegisterIpAndMakeDerivativeAndDistributeRoyaltyTokens(_x19) {
+      function mintAndRegisterIpAndMakeDerivativeAndDistributeRoyaltyTokens(_x20) {
         return _mintAndRegisterIpAndMakeDerivativeAndDistributeRoyaltyTokens.apply(this, arguments);
       }
       return mintAndRegisterIpAndMakeDerivativeAndDistributeRoyaltyTokens;
@@ -10585,12 +11138,12 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "distributeRoyaltyTokens",
     value: function () {
-      var _distributeRoyaltyTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee22(request) {
+      var _distributeRoyaltyTokens = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee23(request) {
         var _yield$transferDistri, transformRequest, txHash;
-        return _regenerator().w(function (_context22) {
-          while (1) switch (_context22.n) {
+        return _regenerator().w(function (_context24) {
+          while (1) switch (_context24.n) {
             case 0:
-              _context22.n = 1;
+              _context24.n = 1;
               return transferDistributeRoyaltyTokensRequest({
                 request: request,
                 rpcClient: this.rpcClient,
@@ -10598,22 +11151,22 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 1:
-              _yield$transferDistri = _context22.v;
+              _yield$transferDistri = _context24.v;
               transformRequest = _yield$transferDistri.transformRequest;
-              _context22.n = 2;
+              _context24.n = 2;
               return this.royaltyTokenDistributionWorkflowsClient.distributeRoyaltyTokens(transformRequest);
             case 2:
-              txHash = _context22.v;
-              _context22.n = 3;
+              txHash = _context24.v;
+              _context24.n = 3;
               return this.rpcClient.waitForTransactionReceipt(_objectSpread2(_objectSpread2({}, request.txOptions), {}, {
                 hash: txHash
               }));
             case 3:
-              return _context22.a(2, txHash);
+              return _context24.a(2, txHash);
           }
-        }, _callee22, this);
+        }, _callee23, this);
       }));
-      function distributeRoyaltyTokens(_x20) {
+      function distributeRoyaltyTokens(_x21) {
         return _distributeRoyaltyTokens.apply(this, arguments);
       }
       return distributeRoyaltyTokens;
@@ -10621,20 +11174,20 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "isRegistered",
     value: function () {
-      var _isRegistered = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee23(ipId) {
-        return _regenerator().w(function (_context23) {
-          while (1) switch (_context23.n) {
+      var _isRegistered = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee24(ipId) {
+        return _regenerator().w(function (_context25) {
+          while (1) switch (_context25.n) {
             case 0:
-              _context23.n = 1;
+              _context25.n = 1;
               return this.ipAssetRegistryClient.isRegistered({
                 id: validateAddress(ipId)
               });
             case 1:
-              return _context23.a(2, _context23.v);
+              return _context25.a(2, _context25.v);
           }
-        }, _callee23, this);
+        }, _callee24, this);
       }));
-      function isRegistered(_x21) {
+      function isRegistered(_x22) {
         return _isRegistered.apply(this, arguments);
       }
       return isRegistered;
@@ -10680,24 +11233,24 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "batchRegisterIpAssetsWithOptimizedWorkflows",
     value: (function () {
-      var _batchRegisterIpAssetsWithOptimizedWorkflows = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee24(request) {
-        var transferWorkflowRequests, _iterator6, _step6, req, res, royaltyDistributionRequests, _yield$handleMultical, txResponses, aggregateRegistrationRequest, responses, royaltyTokensDistributionRequests, _iterator7, _step7, _step7$value, txHash, receipt, iPRegisteredLog, ipRoyaltyVaultEvent, _yield$prepareRoyalty, requests, ipRoyaltyVaults, distributeRoyaltyTokensTxHashes, _yield$handleMultical2, txResponse, registrationResults, _t28, _t29, _t30;
-        return _regenerator().w(function (_context24) {
-          while (1) switch (_context24.p = _context24.n) {
+      var _batchRegisterIpAssetsWithOptimizedWorkflows = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee25(request) {
+        var transferWorkflowRequests, _iterator6, _step6, req, res, royaltyDistributionRequests, _yield$handleMultical, txResponses, aggregateRegistrationRequest, responses, royaltyTokensDistributionRequests, _iterator7, _step7, _step7$value, txHash, receipt, iPRegisteredLog, ipRoyaltyVaultEvent, _yield$prepareRoyalty, requests, ipRoyaltyVaults, distributeRoyaltyTokensTxHashes, _yield$handleMultical2, txResponse, registrationResults, _t29, _t30, _t31;
+        return _regenerator().w(function (_context26) {
+          while (1) switch (_context26.p = _context26.n) {
             case 0:
-              _context24.p = 0;
+              _context26.p = 0;
               // Transform requests into workflow format
               transferWorkflowRequests = [];
               _iterator6 = _createForOfIteratorHelper(request.requests);
-              _context24.p = 1;
+              _context26.p = 1;
               _iterator6.s();
             case 2:
               if ((_step6 = _iterator6.n()).done) {
-                _context24.n = 5;
+                _context26.n = 5;
                 break;
               }
               req = _step6.value;
-              _context24.n = 3;
+              _context26.n = 3;
               return transformRegistrationRequest({
                 request: req,
                 rpcClient: this.rpcClient,
@@ -10705,22 +11258,22 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 3:
-              res = _context24.v;
+              res = _context26.v;
               transferWorkflowRequests.push(res);
             case 4:
-              _context24.n = 2;
+              _context26.n = 2;
               break;
             case 5:
-              _context24.n = 7;
+              _context26.n = 7;
               break;
             case 6:
-              _context24.p = 6;
-              _t28 = _context24.v;
-              _iterator6.e(_t28);
+              _context26.p = 6;
+              _t29 = _context26.v;
+              _iterator6.e(_t29);
             case 7:
-              _context24.p = 7;
+              _context26.p = 7;
               _iterator6.f();
-              return _context24.f(7);
+              return _context26.f(7);
             case 8:
               /**
                * Extract royalty distribution requests from workflow responses that contain royalty shares
@@ -10738,7 +11291,7 @@ var IPAssetClient = /*#__PURE__*/function () {
                   deadline: res.extraData.deadline
                 };
               }); // Process initial registration transactions
-              _context24.n = 9;
+              _context26.n = 9;
               return handleMulticall({
                 transferWorkflowRequests: transferWorkflowRequests,
                 multicall3Address: this.multicall3Client.address,
@@ -10749,23 +11302,23 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 9:
-              _yield$handleMultical = _context24.v;
+              _yield$handleMultical = _context26.v;
               txResponses = _yield$handleMultical.response;
               aggregateRegistrationRequest = _yield$handleMultical.aggregateRegistrationRequest;
               responses = [];
               royaltyTokensDistributionRequests = []; // Process each transaction response
               _iterator7 = _createForOfIteratorHelper(txResponses);
-              _context24.p = 10;
+              _context26.p = 10;
               _iterator7.s();
             case 11:
               if ((_step7 = _iterator7.n()).done) {
-                _context24.n = 14;
+                _context26.n = 14;
                 break;
               }
               _step7$value = _step7.value, txHash = _step7$value.txHash, receipt = _step7$value.receipt;
               iPRegisteredLog = this.ipAssetRegistryClient.parseTxIpRegisteredEvent(receipt);
               ipRoyaltyVaultEvent = this.royaltyModuleEventClient.parseTxIpRoyaltyVaultDeployedEvent(receipt); // Prepare royalty distribution if needed
-              _context24.n = 12;
+              _context26.n = 12;
               return prepareRoyaltyTokensDistributionRequests({
                 royaltyDistributionRequests: royaltyDistributionRequests,
                 ipRegisteredLog: iPRegisteredLog,
@@ -10775,7 +11328,7 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 12:
-              _yield$prepareRoyalty = _context24.v;
+              _yield$prepareRoyalty = _context26.v;
               requests = _yield$prepareRoyalty.requests;
               ipRoyaltyVaults = _yield$prepareRoyalty.ipRoyaltyVaults;
               royaltyTokensDistributionRequests.push.apply(royaltyTokensDistributionRequests, _toConsumableArray(requests));
@@ -10791,25 +11344,25 @@ var IPAssetClient = /*#__PURE__*/function () {
                 })
               });
             case 13:
-              _context24.n = 11;
+              _context26.n = 11;
               break;
             case 14:
-              _context24.n = 16;
+              _context26.n = 16;
               break;
             case 15:
-              _context24.p = 15;
-              _t29 = _context24.v;
-              _iterator7.e(_t29);
+              _context26.p = 15;
+              _t30 = _context26.v;
+              _iterator7.e(_t30);
             case 16:
-              _context24.p = 16;
+              _context26.p = 16;
               _iterator7.f();
-              return _context24.f(16);
+              return _context26.f(16);
             case 17:
               if (!(royaltyTokensDistributionRequests.length > 0)) {
-                _context24.n = 19;
+                _context26.n = 19;
                 break;
               }
-              _context24.n = 18;
+              _context26.n = 18;
               return handleMulticall({
                 transferWorkflowRequests: royaltyTokensDistributionRequests,
                 multicall3Address: this.multicall3Client.address,
@@ -10820,29 +11373,29 @@ var IPAssetClient = /*#__PURE__*/function () {
                 chainId: this.chainId
               });
             case 18:
-              _yield$handleMultical2 = _context24.v;
+              _yield$handleMultical2 = _context26.v;
               txResponse = _yield$handleMultical2.response;
               distributeRoyaltyTokensTxHashes = txResponse.map(function (tx) {
                 return tx.txHash;
               });
             case 19:
-              _context24.n = 20;
+              _context26.n = 20;
               return this.populateLicenseAndTokenIdsForRegistrationResults(responses, aggregateRegistrationRequest);
             case 20:
-              registrationResults = _context24.v;
-              return _context24.a(2, _objectSpread2({
+              registrationResults = _context26.v;
+              return _context26.a(2, _objectSpread2({
                 registrationResults: registrationResults
               }, distributeRoyaltyTokensTxHashes && {
                 distributeRoyaltyTokensTxHashes: distributeRoyaltyTokensTxHashes
               }));
             case 21:
-              _context24.p = 21;
-              _t30 = _context24.v;
-              return _context24.a(2, handleError(_t30, "Failed to batch register IP assets with optimized workflows"));
+              _context26.p = 21;
+              _t31 = _context26.v;
+              return _context26.a(2, handleError(_t31, "Failed to batch register IP assets with optimized workflows"));
           }
-        }, _callee24, this, [[10, 15, 16, 17], [1, 6, 7, 8], [0, 21]]);
+        }, _callee25, this, [[10, 15, 16, 17], [1, 6, 7, 8], [0, 21]]);
       }));
-      function batchRegisterIpAssetsWithOptimizedWorkflows(_x22) {
+      function batchRegisterIpAssetsWithOptimizedWorkflows(_x23) {
         return _batchRegisterIpAssetsWithOptimizedWorkflows.apply(this, arguments);
       }
       return batchRegisterIpAssetsWithOptimizedWorkflows;
@@ -10912,51 +11465,51 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "registerIpAsset",
     value: (function () {
-      var _registerIpAsset = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee25(request) {
-        var nft, licenseTermsData, royaltyShares, _t31;
-        return _regenerator().w(function (_context25) {
-          while (1) switch (_context25.p = _context25.n) {
+      var _registerIpAsset = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee26(request) {
+        var nft, licenseTermsData, royaltyShares, _t32;
+        return _regenerator().w(function (_context27) {
+          while (1) switch (_context27.p = _context27.n) {
             case 0:
-              _context25.p = 0;
+              _context27.p = 0;
               nft = request.nft, licenseTermsData = request.licenseTermsData, royaltyShares = request.royaltyShares; // Validate royalty shares without license terms
               if (!(royaltyShares && !licenseTermsData)) {
-                _context25.n = 1;
+                _context27.n = 1;
                 break;
               }
               throw new Error("License terms data must be provided when royalty shares are specified.");
             case 1:
               if (!(nft.type === "minted")) {
-                _context25.n = 3;
+                _context27.n = 3;
                 break;
               }
-              _context25.n = 2;
+              _context27.n = 2;
               return this.handleMintedNftRegistration(request);
             case 2:
-              return _context25.a(2, _context25.v);
+              return _context27.a(2, _context27.v);
             case 3:
               if (!(nft.type === "mint")) {
-                _context25.n = 5;
+                _context27.n = 5;
                 break;
               }
-              _context25.n = 4;
+              _context27.n = 4;
               return this.handleMintNftRegistration(request);
             case 4:
-              return _context25.a(2, _context25.v);
+              return _context27.a(2, _context27.v);
             case 5:
               throw new Error("Invalid NFT type");
             case 6:
-              _context25.n = 8;
+              _context27.n = 8;
               break;
             case 7:
-              _context25.p = 7;
-              _t31 = _context25.v;
-              return _context25.a(2, handleError(_t31, "Failed to register IP Asset"));
+              _context27.p = 7;
+              _t32 = _context27.v;
+              return _context27.a(2, handleError(_t32, "Failed to register IP Asset"));
             case 8:
-              return _context25.a(2);
+              return _context27.a(2);
           }
-        }, _callee25, this, [[0, 7]]);
+        }, _callee26, this, [[0, 7]]);
       }));
-      function registerIpAsset(_x23) {
+      function registerIpAsset(_x24) {
         return _registerIpAsset.apply(this, arguments);
       }
       return registerIpAsset;
@@ -11025,15 +11578,15 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "registerDerivativeIpAsset",
     value: (function () {
-      var _registerDerivativeIpAsset = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee26(request) {
-        var nft, licenseTokenIds, royaltyShares, derivData, hasDerivData, hasLicenseTokens, _t32;
-        return _regenerator().w(function (_context26) {
-          while (1) switch (_context26.p = _context26.n) {
+      var _registerDerivativeIpAsset = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee27(request) {
+        var nft, licenseTokenIds, royaltyShares, derivData, hasDerivData, hasLicenseTokens, _t33;
+        return _regenerator().w(function (_context28) {
+          while (1) switch (_context28.p = _context28.n) {
             case 0:
-              _context26.p = 0;
+              _context28.p = 0;
               nft = request.nft, licenseTokenIds = request.licenseTokenIds, royaltyShares = request.royaltyShares, derivData = request.derivData;
               if (!(royaltyShares && !derivData)) {
-                _context26.n = 1;
+                _context28.n = 1;
                 break;
               }
               throw new Error("derivData must be provided when royaltyShares are provided.");
@@ -11042,43 +11595,43 @@ var IPAssetClient = /*#__PURE__*/function () {
               hasDerivData = !!derivData;
               hasLicenseTokens = !!(licenseTokenIds && licenseTokenIds.length > 0);
               if (!(!hasDerivData && !hasLicenseTokens)) {
-                _context26.n = 2;
+                _context28.n = 2;
                 break;
               }
               throw new Error("Either derivData or licenseTokenIds must be provided.");
             case 2:
               if (!(nft.type === "minted")) {
-                _context26.n = 4;
+                _context28.n = 4;
                 break;
               }
-              _context26.n = 3;
+              _context28.n = 3;
               return this.handleMintedNftDerivativeRegistration(request);
             case 3:
-              return _context26.a(2, _context26.v);
+              return _context28.a(2, _context28.v);
             case 4:
               if (!(nft.type === "mint")) {
-                _context26.n = 6;
+                _context28.n = 6;
                 break;
               }
-              _context26.n = 5;
+              _context28.n = 5;
               return this.handleMintNftDerivativeRegistration(request);
             case 5:
-              return _context26.a(2, _context26.v);
+              return _context28.a(2, _context28.v);
             case 6:
               throw new Error("Invalid NFT type.");
             case 7:
-              _context26.n = 9;
+              _context28.n = 9;
               break;
             case 8:
-              _context26.p = 8;
-              _t32 = _context26.v;
-              return _context26.a(2, handleError(_t32, "Failed to register derivative IP Asset"));
+              _context28.p = 8;
+              _t33 = _context28.v;
+              return _context28.a(2, handleError(_t33, "Failed to register derivative IP Asset"));
             case 9:
-              return _context26.a(2);
+              return _context28.a(2);
           }
-        }, _callee26, this, [[0, 8]]);
+        }, _callee27, this, [[0, 8]]);
       }));
-      function registerDerivativeIpAsset(_x24) {
+      function registerDerivativeIpAsset(_x25) {
         return _registerDerivativeIpAsset.apply(this, arguments);
       }
       return registerDerivativeIpAsset;
@@ -11095,10 +11648,10 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "handleMintedNftDerivativeRegistration",
     value: (function () {
-      var _handleMintedNftDerivativeRegistration = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee27(request) {
+      var _handleMintedNftDerivativeRegistration = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee28(request) {
         var nft, royaltyShares, derivData, maxRts, licenseTokenIds, deadline, txOptions, options, ipMetadata, baseParams;
-        return _regenerator().w(function (_context27) {
-          while (1) switch (_context27.n) {
+        return _regenerator().w(function (_context29) {
+          while (1) switch (_context29.n) {
             case 0:
               nft = request.nft, royaltyShares = request.royaltyShares, derivData = request.derivData, maxRts = request.maxRts, licenseTokenIds = request.licenseTokenIds, deadline = request.deadline, txOptions = request.txOptions, options = request.options, ipMetadata = request.ipMetadata;
               baseParams = {
@@ -11110,31 +11663,31 @@ var IPAssetClient = /*#__PURE__*/function () {
                 options: options
               };
               if (!(royaltyShares && derivData)) {
-                _context27.n = 1;
+                _context29.n = 1;
                 break;
               }
-              return _context27.a(2, this.registerDerivativeIpAndAttachLicenseTermsAndDistributeRoyaltyTokens(_objectSpread2(_objectSpread2({}, baseParams), {}, {
+              return _context29.a(2, this.registerDerivativeIpAndAttachLicenseTermsAndDistributeRoyaltyTokens(_objectSpread2(_objectSpread2({}, baseParams), {}, {
                 royaltyShares: royaltyShares,
                 derivData: derivData
               })));
             case 1:
               if (!derivData) {
-                _context27.n = 2;
+                _context29.n = 2;
                 break;
               }
-              return _context27.a(2, this.registerDerivativeIp(_objectSpread2(_objectSpread2({}, baseParams), {}, {
+              return _context29.a(2, this.registerDerivativeIp(_objectSpread2(_objectSpread2({}, baseParams), {}, {
                 derivData: derivData
               })));
             case 2:
-              return _context27.a(2, this.registerIpAndMakeDerivativeWithLicenseTokens(_objectSpread2(_objectSpread2({}, baseParams), {}, {
+              return _context29.a(2, this.registerIpAndMakeDerivativeWithLicenseTokens(_objectSpread2(_objectSpread2({}, baseParams), {}, {
                 licenseTokenIds: licenseTokenIds,
                 maxRts: maxRts,
                 autoApproveLicenseTokens: request.autoApproveLicenseTokens
               })));
           }
-        }, _callee27, this);
+        }, _callee28, this);
       }));
-      function handleMintedNftDerivativeRegistration(_x25) {
+      function handleMintedNftDerivativeRegistration(_x26) {
         return _handleMintedNftDerivativeRegistration.apply(this, arguments);
       }
       return handleMintedNftDerivativeRegistration;
@@ -11151,10 +11704,10 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "handleMintNftDerivativeRegistration",
     value: (function () {
-      var _handleMintNftDerivativeRegistration = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee28(request) {
+      var _handleMintNftDerivativeRegistration = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee29(request) {
         var nft, royaltyShares, derivData, maxRts, licenseTokenIds, txOptions, options, ipMetadata, baseParams;
-        return _regenerator().w(function (_context28) {
-          while (1) switch (_context28.n) {
+        return _regenerator().w(function (_context30) {
+          while (1) switch (_context30.n) {
             case 0:
               nft = request.nft, royaltyShares = request.royaltyShares, derivData = request.derivData, maxRts = request.maxRts, licenseTokenIds = request.licenseTokenIds, txOptions = request.txOptions, options = request.options, ipMetadata = request.ipMetadata;
               baseParams = {
@@ -11166,31 +11719,31 @@ var IPAssetClient = /*#__PURE__*/function () {
                 options: options
               };
               if (!(royaltyShares && derivData)) {
-                _context28.n = 1;
+                _context30.n = 1;
                 break;
               }
-              return _context28.a(2, this.mintAndRegisterIpAndMakeDerivativeAndDistributeRoyaltyTokens(_objectSpread2(_objectSpread2({}, baseParams), {}, {
+              return _context30.a(2, this.mintAndRegisterIpAndMakeDerivativeAndDistributeRoyaltyTokens(_objectSpread2(_objectSpread2({}, baseParams), {}, {
                 royaltyShares: royaltyShares,
                 derivData: derivData
               })));
             case 1:
               if (!derivData) {
-                _context28.n = 2;
+                _context30.n = 2;
                 break;
               }
-              return _context28.a(2, this.mintAndRegisterIpAndMakeDerivative(_objectSpread2(_objectSpread2({}, baseParams), {}, {
+              return _context30.a(2, this.mintAndRegisterIpAndMakeDerivative(_objectSpread2(_objectSpread2({}, baseParams), {}, {
                 derivData: derivData
               })));
             case 2:
-              return _context28.a(2, this.mintAndRegisterIpAndMakeDerivativeWithLicenseTokens(_objectSpread2(_objectSpread2({}, baseParams), {}, {
+              return _context30.a(2, this.mintAndRegisterIpAndMakeDerivativeWithLicenseTokens(_objectSpread2(_objectSpread2({}, baseParams), {}, {
                 licenseTokenIds: licenseTokenIds,
                 maxRts: maxRts,
                 autoApproveLicenseTokens: request.autoApproveLicenseTokens
               })));
           }
-        }, _callee28, this);
+        }, _callee29, this);
       }));
-      function handleMintNftDerivativeRegistration(_x26) {
+      function handleMintNftDerivativeRegistration(_x27) {
         return _handleMintNftDerivativeRegistration.apply(this, arguments);
       }
       return handleMintNftDerivativeRegistration;
@@ -11228,32 +11781,32 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "linkDerivative",
     value: (function () {
-      var _linkDerivative = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee29(request) {
-        var _t33;
-        return _regenerator().w(function (_context29) {
-          while (1) switch (_context29.p = _context29.n) {
+      var _linkDerivative = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee30(request) {
+        var _t34;
+        return _regenerator().w(function (_context31) {
+          while (1) switch (_context31.p = _context31.n) {
             case 0:
-              _context29.p = 0;
+              _context31.p = 0;
               if (!("parentIpIds" in request)) {
-                _context29.n = 1;
+                _context31.n = 1;
                 break;
               }
-              return _context29.a(2, this.registerDerivative(request));
+              return _context31.a(2, this.registerDerivative(request));
             case 1:
-              return _context29.a(2, this.registerDerivativeWithLicenseTokens(request));
+              return _context31.a(2, this.registerDerivativeWithLicenseTokens(request));
             case 2:
-              _context29.n = 4;
+              _context31.n = 4;
               break;
             case 3:
-              _context29.p = 3;
-              _t33 = _context29.v;
-              return _context29.a(2, handleError(_t33, "Failed to link derivative"));
+              _context31.p = 3;
+              _t34 = _context31.v;
+              return _context31.a(2, handleError(_t34, "Failed to link derivative"));
             case 4:
-              return _context29.a(2);
+              return _context31.a(2);
           }
-        }, _callee29, this, [[0, 3]]);
+        }, _callee30, this, [[0, 3]]);
       }));
-      function linkDerivative(_x27) {
+      function linkDerivative(_x28) {
         return _linkDerivative.apply(this, arguments);
       }
       return linkDerivative;
@@ -11270,10 +11823,10 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "handleMintedNftRegistration",
     value: (function () {
-      var _handleMintedNftRegistration = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee30(request) {
+      var _handleMintedNftRegistration = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee31(request) {
         var nft, ipMetadata, txOptions, licenseTermsData, royaltyShares, deadline, baseParams;
-        return _regenerator().w(function (_context30) {
-          while (1) switch (_context30.n) {
+        return _regenerator().w(function (_context32) {
+          while (1) switch (_context32.n) {
             case 0:
               nft = request.nft, ipMetadata = request.ipMetadata, txOptions = request.txOptions, licenseTermsData = request.licenseTermsData, royaltyShares = request.royaltyShares, deadline = request.deadline;
               baseParams = {
@@ -11284,27 +11837,27 @@ var IPAssetClient = /*#__PURE__*/function () {
                 txOptions: txOptions
               };
               if (!(licenseTermsData && royaltyShares)) {
-                _context30.n = 1;
+                _context32.n = 1;
                 break;
               }
-              return _context30.a(2, this.registerIPAndAttachLicenseTermsAndDistributeRoyaltyTokens(_objectSpread2(_objectSpread2({}, baseParams), {}, {
+              return _context32.a(2, this.registerIPAndAttachLicenseTermsAndDistributeRoyaltyTokens(_objectSpread2(_objectSpread2({}, baseParams), {}, {
                 licenseTermsData: licenseTermsData,
                 royaltyShares: royaltyShares
               })));
             case 1:
               if (!licenseTermsData) {
-                _context30.n = 2;
+                _context32.n = 2;
                 break;
               }
-              return _context30.a(2, this.registerIpAndAttachPilTerms(_objectSpread2(_objectSpread2({}, baseParams), {}, {
+              return _context32.a(2, this.registerIpAndAttachPilTerms(_objectSpread2(_objectSpread2({}, baseParams), {}, {
                 licenseTermsData: licenseTermsData
               })));
             case 2:
-              return _context30.a(2, this.register(_objectSpread2({}, baseParams)));
+              return _context32.a(2, this.register(_objectSpread2({}, baseParams)));
           }
-        }, _callee30, this);
+        }, _callee31, this);
       }));
-      function handleMintedNftRegistration(_x28) {
+      function handleMintedNftRegistration(_x29) {
         return _handleMintedNftRegistration.apply(this, arguments);
       }
       return handleMintedNftRegistration;
@@ -11321,10 +11874,10 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "handleMintNftRegistration",
     value: (function () {
-      var _handleMintNftRegistration = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee31(request) {
+      var _handleMintNftRegistration = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee32(request) {
         var nft, ipMetadata, txOptions, options, licenseTermsData, royaltyShares, baseParams;
-        return _regenerator().w(function (_context31) {
-          while (1) switch (_context31.n) {
+        return _regenerator().w(function (_context33) {
+          while (1) switch (_context33.n) {
             case 0:
               nft = request.nft, ipMetadata = request.ipMetadata, txOptions = request.txOptions, options = request.options, licenseTermsData = request.licenseTermsData, royaltyShares = request.royaltyShares;
               baseParams = {
@@ -11336,27 +11889,27 @@ var IPAssetClient = /*#__PURE__*/function () {
                 options: options
               };
               if (!(licenseTermsData && royaltyShares)) {
-                _context31.n = 1;
+                _context33.n = 1;
                 break;
               }
-              return _context31.a(2, this.mintAndRegisterIpAndAttachPilTermsAndDistributeRoyaltyTokens(_objectSpread2(_objectSpread2({}, baseParams), {}, {
+              return _context33.a(2, this.mintAndRegisterIpAndAttachPilTermsAndDistributeRoyaltyTokens(_objectSpread2(_objectSpread2({}, baseParams), {}, {
                 licenseTermsData: licenseTermsData,
                 royaltyShares: royaltyShares
               })));
             case 1:
               if (!licenseTermsData) {
-                _context31.n = 2;
+                _context33.n = 2;
                 break;
               }
-              return _context31.a(2, this.mintAndRegisterIpAssetWithPilTerms(_objectSpread2(_objectSpread2({}, baseParams), {}, {
+              return _context33.a(2, this.mintAndRegisterIpAssetWithPilTerms(_objectSpread2(_objectSpread2({}, baseParams), {}, {
                 licenseTermsData: licenseTermsData
               })));
             case 2:
-              return _context31.a(2, this.mintAndRegisterIp(_objectSpread2({}, baseParams)));
+              return _context33.a(2, this.mintAndRegisterIp(_objectSpread2({}, baseParams)));
           }
-        }, _callee31, this);
+        }, _callee32, this);
       }));
-      function handleMintNftRegistration(_x29) {
+      function handleMintNftRegistration(_x30) {
         return _handleMintNftRegistration.apply(this, arguments);
       }
       return handleMintNftRegistration;
@@ -11364,48 +11917,48 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "getLicenseTermsId",
     value: function () {
-      var _getLicenseTermsId = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee32(licenseTerms) {
-        var licenseTermsIds, _iterator8, _step8, licenseTerm, licenseRes, _t34;
-        return _regenerator().w(function (_context32) {
-          while (1) switch (_context32.p = _context32.n) {
+      var _getLicenseTermsId = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee33(licenseTerms) {
+        var licenseTermsIds, _iterator8, _step8, licenseTerm, licenseRes, _t35;
+        return _regenerator().w(function (_context34) {
+          while (1) switch (_context34.p = _context34.n) {
             case 0:
               licenseTermsIds = [];
               _iterator8 = _createForOfIteratorHelper(licenseTerms);
-              _context32.p = 1;
+              _context34.p = 1;
               _iterator8.s();
             case 2:
               if ((_step8 = _iterator8.n()).done) {
-                _context32.n = 5;
+                _context34.n = 5;
                 break;
               }
               licenseTerm = _step8.value;
-              _context32.n = 3;
+              _context34.n = 3;
               return this.licenseTemplateClient.getLicenseTermsId({
                 terms: licenseTerm
               });
             case 3:
-              licenseRes = _context32.v;
+              licenseRes = _context34.v;
               licenseTermsIds.push(licenseRes.selectedLicenseTermsId);
             case 4:
-              _context32.n = 2;
+              _context34.n = 2;
               break;
             case 5:
-              _context32.n = 7;
+              _context34.n = 7;
               break;
             case 6:
-              _context32.p = 6;
-              _t34 = _context32.v;
-              _iterator8.e(_t34);
+              _context34.p = 6;
+              _t35 = _context34.v;
+              _iterator8.e(_t35);
             case 7:
-              _context32.p = 7;
+              _context34.p = 7;
               _iterator8.f();
-              return _context32.f(7);
+              return _context34.f(7);
             case 8:
-              return _context32.a(2, licenseTermsIds);
+              return _context34.a(2, licenseTermsIds);
           }
-        }, _callee32, this, [[1, 6, 7, 8]]);
+        }, _callee33, this, [[1, 6, 7, 8]]);
       }));
-      function getLicenseTermsId(_x30) {
+      function getLicenseTermsId(_x31) {
         return _getLicenseTermsId.apply(this, arguments);
       }
       return getLicenseTermsId;
@@ -11413,13 +11966,13 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "validateLicenseTokenIds",
     value: function () {
-      var _validateLicenseTokenIds = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee33(licenseTokenIds) {
-        var newLicenseTokenIds, _iterator9, _step9, licenseTokenId, tokenOwnerAddress, _t35;
-        return _regenerator().w(function (_context33) {
-          while (1) switch (_context33.p = _context33.n) {
+      var _validateLicenseTokenIds = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee34(licenseTokenIds) {
+        var newLicenseTokenIds, _iterator9, _step9, licenseTokenId, tokenOwnerAddress, _t36;
+        return _regenerator().w(function (_context35) {
+          while (1) switch (_context35.p = _context35.n) {
             case 0:
               if (!(licenseTokenIds.length === 0)) {
-                _context33.n = 1;
+                _context35.n = 1;
                 break;
               }
               throw new Error("License token IDs must be provided.");
@@ -11428,45 +11981,45 @@ var IPAssetClient = /*#__PURE__*/function () {
                 return BigInt(id);
               });
               _iterator9 = _createForOfIteratorHelper(newLicenseTokenIds);
-              _context33.p = 2;
+              _context35.p = 2;
               _iterator9.s();
             case 3:
               if ((_step9 = _iterator9.n()).done) {
-                _context33.n = 6;
+                _context35.n = 6;
                 break;
               }
               licenseTokenId = _step9.value;
-              _context33.n = 4;
+              _context35.n = 4;
               return this.licenseTokenReadOnlyClient.ownerOf({
                 tokenId: licenseTokenId
               });
             case 4:
-              tokenOwnerAddress = _context33.v;
+              tokenOwnerAddress = _context35.v;
               if (tokenOwnerAddress) {
-                _context33.n = 5;
+                _context35.n = 5;
                 break;
               }
               throw new Error("License token id ".concat(licenseTokenId, " must be owned by the caller."));
             case 5:
-              _context33.n = 3;
+              _context35.n = 3;
               break;
             case 6:
-              _context33.n = 8;
+              _context35.n = 8;
               break;
             case 7:
-              _context33.p = 7;
-              _t35 = _context33.v;
-              _iterator9.e(_t35);
+              _context35.p = 7;
+              _t36 = _context35.v;
+              _iterator9.e(_t36);
             case 8:
-              _context33.p = 8;
+              _context35.p = 8;
               _iterator9.f();
-              return _context33.f(8);
+              return _context35.f(8);
             case 9:
-              return _context33.a(2, newLicenseTokenIds);
+              return _context35.a(2, newLicenseTokenIds);
           }
-        }, _callee33, this, [[2, 7, 8, 9]]);
+        }, _callee34, this, [[2, 7, 8, 9]]);
       }));
-      function validateLicenseTokenIds(_x31) {
+      function validateLicenseTokenIds(_x32) {
         return _validateLicenseTokenIds.apply(this, arguments);
       }
       return validateLicenseTokenIds;
@@ -11489,28 +12042,28 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "handleRegistrationWithFees",
     value: function () {
-      var _handleRegistrationWithFees = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee34(_ref5) {
+      var _handleRegistrationWithFees = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee35(_ref6) {
         var _wipOptions$useMultic, _this$getIpIdAndToken, _event$ipId, _event$tokenId;
         var sender, derivData, spgNftContract, spgSpenderAddress, txOptions, options, encodedTxs, contractCall, tokenSpenders, wipOptions, useMulticallWhenPossible, nftMintFee, publicMinting, mintFees, _iterator0, _step0, mintFee, _yield$contractCallWi, txHash, receipt, event;
-        return _regenerator().w(function (_context34) {
-          while (1) switch (_context34.n) {
+        return _regenerator().w(function (_context36) {
+          while (1) switch (_context36.n) {
             case 0:
-              sender = _ref5.sender, derivData = _ref5.derivData, spgNftContract = _ref5.spgNftContract, spgSpenderAddress = _ref5.spgSpenderAddress, txOptions = _ref5.txOptions, options = _ref5.options, encodedTxs = _ref5.encodedTxs, contractCall = _ref5.contractCall;
+              sender = _ref6.sender, derivData = _ref6.derivData, spgNftContract = _ref6.spgNftContract, spgSpenderAddress = _ref6.spgSpenderAddress, txOptions = _ref6.txOptions, options = _ref6.options, encodedTxs = _ref6.encodedTxs, contractCall = _ref6.contractCall;
               tokenSpenders = [];
               wipOptions = options === null || options === void 0 ? void 0 : options.wipOptions;
               useMulticallWhenPossible = (_wipOptions$useMultic = wipOptions === null || wipOptions === void 0 ? void 0 : wipOptions.useMulticallWhenPossible) !== null && _wipOptions$useMultic !== void 0 ? _wipOptions$useMultic : true; // get spg minting fee
               if (!spgNftContract) {
-                _context34.n = 3;
+                _context36.n = 3;
                 break;
               }
-              _context34.n = 1;
+              _context36.n = 1;
               return calculateSPGMintFee(new SpgnftImplReadOnlyClient(this.rpcClient, spgNftContract));
             case 1:
-              nftMintFee = _context34.v;
-              _context34.n = 2;
+              nftMintFee = _context36.v;
+              _context36.n = 2;
               return getPublicMinting(spgNftContract, this.rpcClient);
             case 2:
-              publicMinting = _context34.v;
+              publicMinting = _context36.v;
               /**
                * If the SPG NFT contract's public minting is disabled, we need to check if the caller has the `minter role`.
                * When public minting is disabled, we can't use multicall because we need to perform additional role checks
@@ -11527,10 +12080,10 @@ var IPAssetClient = /*#__PURE__*/function () {
               }, nftMintFee)] : []));
             case 3:
               if (!derivData) {
-                _context34.n = 5;
+                _context36.n = 5;
                 break;
               }
-              _context34.n = 4;
+              _context36.n = 4;
               return calculateDerivativeMintingFee({
                 derivData: derivData,
                 rpcClient: this.rpcClient,
@@ -11539,7 +12092,7 @@ var IPAssetClient = /*#__PURE__*/function () {
                 sender: sender
               });
             case 4:
-              mintFees = _context34.v;
+              mintFees = _context36.v;
               _iterator0 = _createForOfIteratorHelper(mintFees);
               try {
                 for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
@@ -11554,7 +12107,7 @@ var IPAssetClient = /*#__PURE__*/function () {
                 _iterator0.f();
               }
             case 5:
-              _context34.n = 6;
+              _context36.n = 6;
               return contractCallWithFees({
                 options: _objectSpread2(_objectSpread2({}, options), {}, {
                   wipOptions: _objectSpread2(_objectSpread2({}, wipOptions), {}, {
@@ -11571,11 +12124,11 @@ var IPAssetClient = /*#__PURE__*/function () {
                 encodedTxs: encodedTxs
               });
             case 6:
-              _yield$contractCallWi = _context34.v;
+              _yield$contractCallWi = _context36.v;
               txHash = _yield$contractCallWi.txHash;
               receipt = _yield$contractCallWi.receipt;
               event = (_this$getIpIdAndToken = this.getIpIdAndTokenIdsFromEvent(receipt)) === null || _this$getIpIdAndToken === void 0 ? void 0 : _this$getIpIdAndToken[0];
-              return _context34.a(2, _objectSpread2({
+              return _context36.a(2, _objectSpread2({
                 txHash: txHash,
                 receipt: receipt
               }, event && {
@@ -11583,9 +12136,9 @@ var IPAssetClient = /*#__PURE__*/function () {
                 tokenId: (_event$tokenId = event.tokenId) !== null && _event$tokenId !== void 0 ? _event$tokenId : undefined
               }));
           }
-        }, _callee34, this);
+        }, _callee35, this);
       }));
-      function handleRegistrationWithFees(_x32) {
+      function handleRegistrationWithFees(_x33) {
         return _handleRegistrationWithFees.apply(this, arguments);
       }
       return handleRegistrationWithFees;
@@ -11596,66 +12149,66 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "populateLicenseAndTokenIdsForRegistrationResults",
     value: (function () {
-      var _populateLicenseAndTokenIdsForRegistrationResults = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee35(registrationResults, aggregateRegistrationRequest) {
-        var allExtraDataArrays, allExtraData, extraDataFlatIndex, _iterator1, _step1, registrationResult, i, ipAsset, _t36;
-        return _regenerator().w(function (_context35) {
-          while (1) switch (_context35.p = _context35.n) {
+      var _populateLicenseAndTokenIdsForRegistrationResults = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee36(registrationResults, aggregateRegistrationRequest) {
+        var allExtraDataArrays, allExtraData, extraDataFlatIndex, _iterator1, _step1, registrationResult, i, ipAsset, _t37;
+        return _regenerator().w(function (_context37) {
+          while (1) switch (_context37.p = _context37.n) {
             case 0:
-              allExtraDataArrays = Object.values(aggregateRegistrationRequest).map(function (_ref6) {
-                var extraData = _ref6.extraData;
+              allExtraDataArrays = Object.values(aggregateRegistrationRequest).map(function (_ref7) {
+                var extraData = _ref7.extraData;
                 return extraData;
               });
               allExtraData = allExtraDataArrays.flat();
               extraDataFlatIndex = -1;
               _iterator1 = _createForOfIteratorHelper(registrationResults);
-              _context35.p = 1;
+              _context37.p = 1;
               _iterator1.s();
             case 2:
               if ((_step1 = _iterator1.n()).done) {
-                _context35.n = 7;
+                _context37.n = 7;
                 break;
               }
               registrationResult = _step1.value;
               i = 0;
             case 3:
               if (!(i < registrationResult.ipAssetsWithLicenseTerms.length)) {
-                _context35.n = 6;
+                _context37.n = 6;
                 break;
               }
               extraDataFlatIndex++;
               if (!(registrationResult.ipAssetsWithLicenseTerms[i] && allExtraData[extraDataFlatIndex])) {
-                _context35.n = 5;
+                _context37.n = 5;
                 break;
               }
-              _context35.n = 4;
+              _context37.n = 4;
               return this.processIpAssetLicenseTerms(registrationResult.ipAssetsWithLicenseTerms[i], allExtraData[extraDataFlatIndex]);
             case 4:
-              ipAsset = _context35.v;
+              ipAsset = _context37.v;
               registrationResult.ipAssetsWithLicenseTerms[i] = ipAsset;
             case 5:
               i++;
-              _context35.n = 3;
+              _context37.n = 3;
               break;
             case 6:
-              _context35.n = 2;
+              _context37.n = 2;
               break;
             case 7:
-              _context35.n = 9;
+              _context37.n = 9;
               break;
             case 8:
-              _context35.p = 8;
-              _t36 = _context35.v;
-              _iterator1.e(_t36);
+              _context37.p = 8;
+              _t37 = _context37.v;
+              _iterator1.e(_t37);
             case 9:
-              _context35.p = 9;
+              _context37.p = 9;
               _iterator1.f();
-              return _context35.f(9);
+              return _context37.f(9);
             case 10:
-              return _context35.a(2, registrationResults);
+              return _context37.a(2, registrationResults);
           }
-        }, _callee35, this, [[1, 8, 9, 10]]);
+        }, _callee36, this, [[1, 8, 9, 10]]);
       }));
-      function populateLicenseAndTokenIdsForRegistrationResults(_x33, _x34) {
+      function populateLicenseAndTokenIdsForRegistrationResults(_x34, _x35) {
         return _populateLicenseAndTokenIdsForRegistrationResults.apply(this, arguments);
       }
       return populateLicenseAndTokenIdsForRegistrationResults;
@@ -11663,31 +12216,31 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "processIpAssetLicenseTerms",
     value: function () {
-      var _processIpAssetLicenseTerms = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee36(ipAsset, extraData) {
+      var _processIpAssetLicenseTerms = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee37(ipAsset, extraData) {
         var _extraData$licenseTer;
         var licenseTermsIds, maxLicenseTokens, maxLicenseTokensData, maxLicenseTokensTxHashes;
-        return _regenerator().w(function (_context36) {
-          while (1) switch (_context36.n) {
+        return _regenerator().w(function (_context38) {
+          while (1) switch (_context38.n) {
             case 0:
               if (extraData !== null && extraData !== void 0 && (_extraData$licenseTer = extraData.licenseTermsData) !== null && _extraData$licenseTer !== void 0 && _extraData$licenseTer.length) {
-                _context36.n = 1;
+                _context38.n = 1;
                 break;
               }
-              return _context36.a(2, ipAsset);
+              return _context38.a(2, ipAsset);
             case 1:
-              _context36.n = 2;
+              _context38.n = 2;
               return this.getLicenseTermsId(extraData.licenseTermsData.map(function (item) {
                 return item.terms;
               }));
             case 2:
-              licenseTermsIds = _context36.v;
+              licenseTermsIds = _context38.v;
               ipAsset.licenseTermsIds = licenseTermsIds;
               maxLicenseTokens = extraData.maxLicenseTokens;
               if (maxLicenseTokens !== null && maxLicenseTokens !== void 0 && maxLicenseTokens.length) {
-                _context36.n = 3;
+                _context38.n = 3;
                 break;
               }
-              return _context36.a(2, ipAsset);
+              return _context38.a(2, ipAsset);
             case 3:
               maxLicenseTokensData = maxLicenseTokens.filter(function (maxLicenseToken) {
                 return maxLicenseToken !== undefined;
@@ -11696,7 +12249,7 @@ var IPAssetClient = /*#__PURE__*/function () {
                   maxLicenseTokens: maxLicenseToken
                 };
               });
-              _context36.n = 4;
+              _context38.n = 4;
               return setMaxLicenseTokens({
                 maxLicenseTokensData: maxLicenseTokensData,
                 licensorIpId: ipAsset.ipId,
@@ -11705,15 +12258,15 @@ var IPAssetClient = /*#__PURE__*/function () {
                 templateAddress: this.licenseTemplateAddress
               });
             case 4:
-              maxLicenseTokensTxHashes = _context36.v;
+              maxLicenseTokensTxHashes = _context38.v;
               if (maxLicenseTokensTxHashes !== null && maxLicenseTokensTxHashes !== void 0 && maxLicenseTokensTxHashes.length) {
                 ipAsset.maxLicenseTokensTxHashes = maxLicenseTokensTxHashes;
               }
-              return _context36.a(2, ipAsset);
+              return _context38.a(2, ipAsset);
           }
-        }, _callee36, this);
+        }, _callee37, this);
       }));
-      function processIpAssetLicenseTerms(_x35, _x36) {
+      function processIpAssetLicenseTerms(_x36, _x37) {
         return _processIpAssetLicenseTerms.apply(this, arguments);
       }
       return processIpAssetLicenseTerms;
@@ -11721,53 +12274,53 @@ var IPAssetClient = /*#__PURE__*/function () {
   }, {
     key: "approveLicenseTokensForDerivativeWorkflows",
     value: function () {
-      var _approveLicenseTokensForDerivativeWorkflows = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee37(licenseTokenIds, autoApproveLicenseTokens) {
-        var _iterator10, _step10, licenseTokenId, txHash, _t37;
-        return _regenerator().w(function (_context37) {
-          while (1) switch (_context37.p = _context37.n) {
+      var _approveLicenseTokensForDerivativeWorkflows = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee38(licenseTokenIds, autoApproveLicenseTokens) {
+        var _iterator10, _step10, licenseTokenId, txHash, _t38;
+        return _regenerator().w(function (_context39) {
+          while (1) switch (_context39.p = _context39.n) {
             case 0:
               if (!(autoApproveLicenseTokens !== false)) {
-                _context37.n = 8;
+                _context39.n = 8;
                 break;
               }
               _iterator10 = _createForOfIteratorHelper(licenseTokenIds);
-              _context37.p = 1;
+              _context39.p = 1;
               _iterator10.s();
             case 2:
               if ((_step10 = _iterator10.n()).done) {
-                _context37.n = 5;
+                _context39.n = 5;
                 break;
               }
               licenseTokenId = _step10.value;
-              _context37.n = 3;
+              _context39.n = 3;
               return this.licenseTokenClient.approve({
                 to: this.derivativeWorkflowsClient.address,
                 tokenId: BigInt(licenseTokenId)
               });
             case 3:
-              txHash = _context37.v;
-              _context37.n = 4;
+              txHash = _context39.v;
+              _context39.n = 4;
               return waitTx(this.rpcClient, txHash);
             case 4:
-              _context37.n = 2;
+              _context39.n = 2;
               break;
             case 5:
-              _context37.n = 7;
+              _context39.n = 7;
               break;
             case 6:
-              _context37.p = 6;
-              _t37 = _context37.v;
-              _iterator10.e(_t37);
+              _context39.p = 6;
+              _t38 = _context39.v;
+              _iterator10.e(_t38);
             case 7:
-              _context37.p = 7;
+              _context39.p = 7;
               _iterator10.f();
-              return _context37.f(7);
+              return _context39.f(7);
             case 8:
-              return _context37.a(2);
+              return _context39.a(2);
           }
-        }, _callee37, this, [[1, 6, 7, 8]]);
+        }, _callee38, this, [[1, 6, 7, 8]]);
       }));
-      function approveLicenseTokensForDerivativeWorkflows(_x37, _x38) {
+      function approveLicenseTokensForDerivativeWorkflows(_x38, _x39) {
         return _approveLicenseTokensForDerivativeWorkflows.apply(this, arguments);
       }
       return approveLicenseTokensForDerivativeWorkflows;
@@ -12331,7 +12884,8 @@ var LicenseClient = /*#__PURE__*/function () {
                 licensingConfig: _objectSpread2(_objectSpread2({}, licensingConfig), {}, {
                   licensingHook: this.totalLicenseTokenLimitHookClient.address,
                   // use Math.trunc to avoid precision issues
-                  expectMinimumGroupRewardShare: Math.trunc(licensingConfig.expectMinimumGroupRewardShare / 1000000)
+                  expectMinimumGroupRewardShare: Math.trunc(licensingConfig.expectMinimumGroupRewardShare / 1000000),
+                  commercialRevShare: Math.trunc(licensingConfig.commercialRevShare / 1000000)
                 })
               });
             case 4:
@@ -14791,6 +15345,16 @@ var AIRelationship = /*#__PURE__*/function (AIRelationship) {
  * For more information, see {@link https://docs.story.foundation/concepts/programmable-ip-license/pil-terms | PIL}.
  **/
 
+/**
+ * The data of the license and its configuration to be attached to the IP.
+ *
+ * You must provide either `licenseTermsId` or `terms`:
+ * - `licenseTermsId`: Use an existing pre-registered license terms
+ * - `terms`: Register new license terms and attach
+ *
+ * If both are provided, `terms` takes priority and new terms will be registered.
+ */
+
 /**
  * @deprecated Use `PILFlavor.nonCommercialSocialRemixing`, `PILFlavor.commercialUse`, `PILFlavor.commercialRemix`, or `PILFlavor.creativeCommonsAttribution` instead.
  *