@story-protocol/core-sdk 1.0.0-rc.19 → 1.0.0-rc.20

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

@@ -25,7 +25,7 @@ function _interopNamespace(e) {
 
 var dotenv__namespace = /*#__PURE__*/_interopNamespace(dotenv);
 
-function toPrimitive(t, r) {
+function _toPrimitive(t, r) {
   if ("object" != typeof t || !t) return t;
   var e = t[Symbol.toPrimitive];
   if (void 0 !== e) {
@@ -36,24 +36,18 @@ function toPrimitive(t, r) {
   return ("string" === r ? String : Number)(t);
 }
 
-function toPropertyKey(t) {
-  var i = toPrimitive(t, "string");
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
   return "symbol" == typeof i ? i : i + "";
 }
 
-function _defineProperty(obj, key, value) {
-  key = toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
 }
 
 function ownKeys(e, r) {
@@ -78,92 +72,80 @@ function _objectSpread2(e) {
   return e;
 }
 
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
 }
 
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
   }
 }
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  Object.defineProperty(Constructor, "prototype", {
-    writable: false
-  });
-  return Constructor;
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
 }
 
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-  return arr2;
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
 }
 
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
 }
 
-function _createForOfIteratorHelper(o, allowArrayLike) {
-  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-  if (!it) {
-    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-      if (it) o = it;
-      var i = 0;
-      var F = function () {};
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
       return {
         s: F,
         n: function () {
-          if (i >= o.length) return {
-            done: true
-          };
-          return {
-            done: false,
-            value: o[i++]
+          return n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[n++]
           };
         },
-        e: function (e) {
-          throw e;
+        e: function (r) {
+          throw r;
         },
         f: F
       };
     }
     throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
-  var normalCompletion = true,
-    didErr = false,
-    err;
+  var o,
+    a = !0,
+    u = !1;
   return {
     s: function () {
-      it = it.call(o);
+      t = t.call(r);
     },
     n: function () {
-      var step = it.next();
-      normalCompletion = step.done;
-      return step;
+      var r = t.next();
+      return a = r.done, r;
     },
-    e: function (e) {
-      didErr = true;
-      err = e;
+    e: function (r) {
+      u = !0, o = r;
     },
     f: function () {
       try {
-        if (!normalCompletion && it.return != null) it.return();
+        a || null == t.return || t.return();
       } finally {
-        if (didErr) throw err;
+        if (u) throw o;
       }
     }
   };
@@ -471,37 +453,54 @@ function _regeneratorRuntime() {
   }, e;
 }
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
   try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
   }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
 }
-function _asyncToGenerator(fn) {
+function _asyncToGenerator(n) {
   return function () {
-    var self = this,
-      args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
       }
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
       }
-      _next(undefined);
+      _next(void 0);
     });
   };
 }
 
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (e.includes(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 s = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+
 var iliad = viem.defineChain({
   id: 1513,
   name: "iliad",
@@ -559,11 +558,10 @@ function handleError(error, msg) {
   throw new Error("".concat(msg, ": Unknown error type"));
 }
 
-function _getPrototypeOf(o) {
-  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
-    return o.__proto__ || Object.getPrototypeOf(o);
-  };
-  return _getPrototypeOf(o);
+function _getPrototypeOf(t) {
+  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, _getPrototypeOf(t);
 }
 
 function _isNativeReflectConstruct() {
@@ -575,49 +573,38 @@ function _isNativeReflectConstruct() {
   })();
 }
 
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-  return self;
+function _assertThisInitialized(e) {
+  if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
 }
 
-function _possibleConstructorReturn(self, call) {
-  if (call && (typeof call === "object" || typeof call === "function")) {
-    return call;
-  } else if (call !== void 0) {
-    throw new TypeError("Derived constructors may only return object or undefined");
-  }
-  return _assertThisInitialized(self);
+function _possibleConstructorReturn(t, e) {
+  if (e && ("object" == typeof e || "function" == typeof e)) return e;
+  if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
+  return _assertThisInitialized(t);
 }
 
 function _callSuper(t, o, e) {
   return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
 }
 
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-  return _setPrototypeOf(o, p);
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
 }
 
-function _inherits(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function");
-  }
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
+function _inherits(t, e) {
+  if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(e && e.prototype, {
     constructor: {
-      value: subClass,
-      writable: true,
-      configurable: true
+      value: t,
+      writable: !0,
+      configurable: !0
     }
-  });
-  Object.defineProperty(subClass, "prototype", {
-    writable: false
-  });
-  if (superClass) _setPrototypeOf(subClass, superClass);
+  }), Object.defineProperty(t, "prototype", {
+    writable: !1
+  }), e && _setPrototypeOf(t, e);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -18490,6 +18477,7 @@ var AccessPermission = /*#__PURE__*/function (AccessPermission) {
   return AccessPermission;
 }({});
 
+var _excluded = ["title", "description", "ipType", "relationships", "createdAt", "watermarkImg", "creators", "media", "attributes", "app", "tags", "robotTerms"];
 var IPAssetClient = /*#__PURE__*/function () {
   function IPAssetClient(rpcClient, wallet, chainId) {
     _classCallCheck(this, IPAssetClient);
@@ -18508,21 +18496,141 @@ var IPAssetClient = /*#__PURE__*/function () {
   }
 
   /**
-   * Registers an NFT as IP, creating a corresponding IP record.
-   * @param request - The request object that contains all data needed to register IP.
-   *   @param request.nftContract The address of the NFT.
-   *   @param request.tokenId The token identifier of the NFT.
-   *   @param request.ipMetadata - [Optional] The desired metadata for the newly minted NFT and newly registered IP.
-   *   @param request.ipMetadata.ipMetadataURI [Optional] The URI of the metadata for the IP.
-   *   @param request.ipMetadata.ipMetadataHash [Optional] The hash of the metadata for the IP.
-   *   @param request.ipMetadata.nftMetadataURI [Optional] The URI of the metadata for the NFT.
-   *   @param request.ipMetadata.nftMetadataHash [Optional] The hash of the metadata for the IP NFT.
-   *   @param request.deadline [Optional] The deadline for the signature in milliseconds, default is 1000ms.
-   *   @param request.txOptions [Optional] The transaction options.
-   * @returns A Promise that resolves to an object containing the transaction hash and optional IP ID if waitForTxn is set to true.
-   * @emits IPRegistered (ipId, chainId, tokenContract, tokenId, resolverAddr, metadataProviderAddress, metadata)
+   * Create a new `IpCreator` object with the specified details.
+   * @param params - The parameters required to create the `IpCreator` object.
+   *   @param params.name The name of the creator.
+   *   @param params.address The wallet address of the creator.
+   *   @param params.description [Optional] A description of the creator.
+   *   @param params.image [Optional] The URL or path to an image representing the creator.
+   *   @param params.socialMedia [Optional] An array of social media profiles associated with the creator.
+   *     @param params.socialMedia[].platform The name of the social media platform.
+   *     @param params.socialMedia[].url The URL to the creator's profile on the platform.
+   *   @param params.contributionPercent The percentage of contribution by the creator, must add up to 100.
+   *   @param params.role [Optional] The role of the creator in relation to the IP.
+   * @returns An `IpCreator` object containing the provided details.
    */
   return _createClass(IPAssetClient, [{
+    key: "generateCreatorMetadata",
+    value: function generateCreatorMetadata(_ref) {
+      var name = _ref.name,
+        address = _ref.address,
+        _ref$description = _ref.description,
+        description = _ref$description === void 0 ? "" : _ref$description,
+        _ref$image = _ref.image,
+        image = _ref$image === void 0 ? "" : _ref$image,
+        _ref$socialMedia = _ref.socialMedia,
+        socialMedia = _ref$socialMedia === void 0 ? [] : _ref$socialMedia,
+        contributionPercent = _ref.contributionPercent,
+        _ref$role = _ref.role,
+        role = _ref$role === void 0 ? "" : _ref$role;
+      return {
+        name: name,
+        address: address,
+        description: description,
+        image: image,
+        socialMedia: socialMedia,
+        contributionPercent: contributionPercent,
+        role: role
+      };
+    }
+
+    /**
+     * Create a new `IpMetadata` object with the specified details.
+     * @param params - The parameters required to create the `IpMetadata` object.
+     *   @param params.title [Optional] The title of the IP.
+     *   @param params.description [Optional] A description of the IP.
+     *   @param params.ipType [Optional] The type of the IP asset (e.g., "character", "chapter").
+     *   @param params.relationships [Optional] An array of relationships between this IP and its parent IPs.
+     *     @param params.relationships[].ipId The ID of the parent IP.
+     *     @param params.relationships[].type The type of relationship (e.g., "APPEARS_IN").
+     *   @param params.createdAt [Optional] The creation date and time of the IP in ISO 8601 format.
+     *   @param params.watermarkImg [Optional] The URL or path to an image used as a watermark for the IP.
+     *   @param params.creators [Optional] An array of creators associated with the IP.
+     *     @param params.creators[].name The name of the creator.
+     *     @param params.creators[].address The address of the creator.
+     *     @param params.creators[].description [Optional] A description of the creator.
+     *     @param params.creators[].image [Optional] The URL or path to an image representing the creator.
+     *     @param params.creators[].socialMedia [Optional] An array of social media profiles for the creator.
+     *       @param params.creators[].socialMedia[].platform The social media platform name.
+     *       @param params.creators[].socialMedia[].url The URL to the creator's profile.
+     *     @param params.creators[].role [Optional] The role of the creator in relation to the IP.
+     *     @param params.creators[].contributionPercent The percentage of contribution by the creator.
+     *   @param params.media [Optional] An array of media related to the IP.
+     *     @param params.media[].name The name of the media.
+     *     @param params.media[].url The URL to the media.
+     *     @param params.media[].mimeType The MIME type of the media.
+     *   @param params.attributes [Optional] An array of key-value pairs providing additional metadata.
+     *     @param params.attributes[].key The key for the attribute.
+     *     @param params.attributes[].value The value for the attribute, can be a string or number.
+     *   @param params.app [Optional] Information about the application associated with the IP.
+     *     @param params.app.id The ID of the application.
+     *     @param params.app.name The name of the application.
+     *     @param params.app.website The website URL of the application.
+     *   @param params.tags [Optional] An array of tags associated with the IP.
+     *   @param params.robotTerms [Optional] Robot terms for the IP, specifying access rules.
+     *     @param params.robotTerms.userAgent The user agent for which the rules apply.
+     *     @param params.robotTerms.allow The rules allowing access.
+     *   @param params.additionalProperties [Optional] Any additional key-value pairs to include in the metadata.
+     * @returns An `IpMetadata` object containing the provided details and any additional properties.
+     */
+  }, {
+    key: "generateIpMetadata",
+    value: function generateIpMetadata(_ref2) {
+      var _ref2$title = _ref2.title,
+        title = _ref2$title === void 0 ? "" : _ref2$title,
+        _ref2$description = _ref2.description,
+        description = _ref2$description === void 0 ? "" : _ref2$description,
+        _ref2$ipType = _ref2.ipType,
+        ipType = _ref2$ipType === void 0 ? "" : _ref2$ipType,
+        _ref2$relationships = _ref2.relationships,
+        relationships = _ref2$relationships === void 0 ? [] : _ref2$relationships,
+        _ref2$createdAt = _ref2.createdAt,
+        createdAt = _ref2$createdAt === void 0 ? "" : _ref2$createdAt,
+        _ref2$watermarkImg = _ref2.watermarkImg,
+        watermarkImg = _ref2$watermarkImg === void 0 ? "" : _ref2$watermarkImg,
+        _ref2$creators = _ref2.creators,
+        creators = _ref2$creators === void 0 ? [] : _ref2$creators,
+        _ref2$media = _ref2.media,
+        media = _ref2$media === void 0 ? [] : _ref2$media,
+        _ref2$attributes = _ref2.attributes,
+        attributes = _ref2$attributes === void 0 ? [] : _ref2$attributes,
+        app = _ref2.app,
+        _ref2$tags = _ref2.tags,
+        tags = _ref2$tags === void 0 ? [] : _ref2$tags,
+        robotTerms = _ref2.robotTerms,
+        additionalProperties = _objectWithoutProperties(_ref2, _excluded);
+      return _objectSpread2({
+        title: title,
+        description: description,
+        ipType: ipType,
+        relationships: relationships,
+        createdAt: createdAt,
+        watermarkImg: watermarkImg,
+        creators: creators,
+        media: media,
+        attributes: attributes,
+        app: app,
+        tags: tags,
+        robotTerms: robotTerms
+      }, additionalProperties);
+    }
+
+    /**
+     * Registers an NFT as IP, creating a corresponding IP record.
+     * @param request - The request object that contains all data needed to register IP.
+     *   @param request.nftContract The address of the NFT.
+     *   @param request.tokenId The token identifier of the NFT.
+     *   @param request.ipMetadata - [Optional] The desired metadata for the newly minted NFT and newly registered IP.
+     *   @param request.ipMetadata.ipMetadataURI [Optional] The URI of the metadata for the IP.
+     *   @param request.ipMetadata.ipMetadataHash [Optional] The hash of the metadata for the IP.
+     *   @param request.ipMetadata.nftMetadataURI [Optional] The URI of the metadata for the NFT.
+     *   @param request.ipMetadata.nftMetadataHash [Optional] The hash of the metadata for the IP NFT.
+     *   @param request.deadline [Optional] The deadline for the signature in milliseconds, default is 1000ms.
+     *   @param request.txOptions [Optional] The transaction options.
+     * @returns A Promise that resolves to an object containing the transaction hash and optional IP ID if waitForTxn is set to true.
+     * @emits IPRegistered (ipId, chainId, tokenContract, tokenId, resolverAddr, metadataProviderAddress, metadata)
+     */
+  }, {
     key: "register",
     value: (function () {
       var _register = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
@@ -19004,7 +19112,7 @@ var IPAssetClient = /*#__PURE__*/function () {
             case 11:
               txHash = _context4.sent;
               if (!((_request$txOptions8 = request.txOptions) !== null && _request$txOptions8 !== void 0 && _request$txOptions8.waitForTransaction)) {
-                _context4.next = 19;
+                _context4.next = 21;
                 break;
               }
               _context4.next = 15;
@@ -19014,29 +19122,32 @@ var IPAssetClient = /*#__PURE__*/function () {
             case 15:
               txReceipt = _context4.sent;
               iPRegisteredLog = this.ipAssetRegistryClient.parseTxIpRegisteredEvent(txReceipt)[0];
-              licenseTermsId = this.licensingModuleClient.parseTxLicenseTermsAttachedEvent(txReceipt)[0].licenseTermsId;
+              _context4.next = 19;
+              return this.getLicenseTermsId(txReceipt);
+            case 19:
+              licenseTermsId = _context4.sent;
               return _context4.abrupt("return", {
                 txHash: txHash,
                 ipId: iPRegisteredLog.ipId,
                 licenseTermsId: licenseTermsId,
                 tokenId: iPRegisteredLog.tokenId
               });
-            case 19:
+            case 21:
               return _context4.abrupt("return", {
                 txHash: txHash
               });
-            case 20:
-              _context4.next = 25;
-              break;
             case 22:
-              _context4.prev = 22;
+              _context4.next = 27;
+              break;
+            case 24:
+              _context4.prev = 24;
               _context4.t0 = _context4["catch"](0);
               handleError(_context4.t0, "Failed to mint and register IP and attach PIL terms");
-            case 25:
+            case 27:
             case "end":
               return _context4.stop();
           }
-        }, _callee4, this, [[0, 22]]);
+        }, _callee4, this, [[0, 24]]);
       }));
       function mintAndRegisterIpAssetWithPilTerms(_x4) {
         return _mintAndRegisterIpAssetWithPilTerms.apply(this, arguments);
@@ -19067,7 +19178,7 @@ var IPAssetClient = /*#__PURE__*/function () {
     key: "registerIpAndAttachPilTerms",
     value: (function () {
       var _registerIpAndAttachPilTerms = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(request) {
-        var _request$ipMetadata9, _request$ipMetadata10, _request$ipMetadata11, _request$ipMetadata12, _request$txOptions9, ipIdAddress, isRegistered, licenseTerm, calculatedDeadline, sigAttachSignature, object, sigMetadataSignature, _request$txOptions10, txHash, txReceipt, log;
+        var _request$ipMetadata9, _request$ipMetadata10, _request$ipMetadata11, _request$ipMetadata12, _request$txOptions9, ipIdAddress, isRegistered, licenseTerm, calculatedDeadline, sigAttachSignature, object, sigMetadataSignature, _request$txOptions10, txHash, txReceipt, ipRegisterEvent, licenseTermsId;
         return _regeneratorRuntime().wrap(function _callee5$(_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
@@ -19181,7 +19292,7 @@ var IPAssetClient = /*#__PURE__*/function () {
             case 28:
               txHash = _context5.sent;
               if (!((_request$txOptions10 = request.txOptions) !== null && _request$txOptions10 !== void 0 && _request$txOptions10.waitForTransaction)) {
-                _context5.next = 35;
+                _context5.next = 38;
                 break;
               }
               _context5.next = 32;
@@ -19190,28 +19301,32 @@ var IPAssetClient = /*#__PURE__*/function () {
               });
             case 32:
               txReceipt = _context5.sent;
-              log = this.licensingModuleClient.parseTxLicenseTermsAttachedEvent(txReceipt)[0];
+              ipRegisterEvent = this.ipAssetRegistryClient.parseTxIpRegisteredEvent(txReceipt);
+              _context5.next = 36;
+              return this.getLicenseTermsId(txReceipt);
+            case 36:
+              licenseTermsId = _context5.sent;
               return _context5.abrupt("return", {
                 txHash: txHash,
-                licenseTermsId: log.licenseTermsId,
-                ipId: log.ipId
+                licenseTermsId: licenseTermsId,
+                ipId: ipRegisterEvent[0].ipId
               });
-            case 35:
+            case 38:
               return _context5.abrupt("return", {
                 txHash: txHash
               });
-            case 36:
-              _context5.next = 41;
+            case 39:
+              _context5.next = 44;
               break;
-            case 38:
-              _context5.prev = 38;
+            case 41:
+              _context5.prev = 41;
               _context5.t0 = _context5["catch"](0);
               handleError(_context5.t0, "Failed to register IP and attach PIL terms");
-            case 41:
+            case 44:
             case "end":
               return _context5.stop();
           }
-        }, _callee5, this, [[0, 38]]);
+        }, _callee5, this, [[0, 41]]);
       }));
       function registerIpAndAttachPilTerms(_x5) {
         return _registerIpAndAttachPilTerms.apply(this, arguments);
@@ -19616,6 +19731,38 @@ var IPAssetClient = /*#__PURE__*/function () {
       })]));
       return sigAttachState;
     }
+  }, {
+    key: "getLicenseTermsId",
+    value: function () {
+      var _getLicenseTermsId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(txReceipt) {
+        var licensingModuleLicenseTermsAttachedEvent, licenseTermsId, defaultLicenseTerms;
+        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              licensingModuleLicenseTermsAttachedEvent = this.licensingModuleClient.parseTxLicenseTermsAttachedEvent(txReceipt);
+              licenseTermsId = licensingModuleLicenseTermsAttachedEvent.length >= 1 && licensingModuleLicenseTermsAttachedEvent[0].licenseTermsId;
+              if (!(licenseTermsId === false)) {
+                _context10.next = 7;
+                break;
+              }
+              _context10.next = 5;
+              return this.licenseRegistryReadOnlyClient.getDefaultLicenseTerms();
+            case 5:
+              defaultLicenseTerms = _context10.sent;
+              licenseTermsId = defaultLicenseTerms.licenseTermsId;
+            case 7:
+              return _context10.abrupt("return", licenseTermsId);
+            case 8:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this);
+      }));
+      function getLicenseTermsId(_x11) {
+        return _getLicenseTermsId.apply(this, arguments);
+      }
+      return getLicenseTermsId;
+    }()
   }]);
 }();