@story-protocol/core-sdk 0.0.1-beta-test.1 → 0.0.1-beta-rc.3

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

@@ -2,11 +2,10 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var axios = require('axios');
 var viem = require('viem');
-var chains = require('viem/chains');
+var axios = require('axios');
 var dotenv = require('dotenv');
-var abitype = require('abitype');
+var chains = require('viem/chains');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
@@ -108,81 +107,6 @@ function _createClass(Constructor, protoProps, staticProps) {
   return Constructor;
 }
 
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-  return _setPrototypeOf(o, p);
-}
-
-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, {
-    constructor: {
-      value: subClass,
-      writable: true,
-      configurable: true
-    }
-  });
-  Object.defineProperty(subClass, "prototype", {
-    writable: false
-  });
-  if (superClass) _setPrototypeOf(subClass, superClass);
-}
-
-function _getPrototypeOf(o) {
-  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
-    return o.__proto__ || Object.getPrototypeOf(o);
-  };
-  return _getPrototypeOf(o);
-}
-
-function _isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-  if (Reflect.construct.sham) return false;
-  if (typeof Proxy === "function") return true;
-  try {
-    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-  return self;
-}
-
-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 _createSuper(Derived) {
-  var hasNativeReflectConstruct = _isNativeReflectConstruct();
-  return function _createSuperInternal() {
-    var Super = _getPrototypeOf(Derived),
-      result;
-    if (hasNativeReflectConstruct) {
-      var NewTarget = _getPrototypeOf(this).constructor;
-      result = Reflect.construct(Super, arguments, NewTarget);
-    } else {
-      result = Super.apply(this, arguments);
-    }
-    return _possibleConstructorReturn(this, result);
-  };
-}
-
 function _regeneratorRuntime() {
   _regeneratorRuntime = function () {
     return e;
@@ -523,664 +447,1509 @@ function handleError(error, msg) {
   throw new Error("".concat(msg, ": Unknown error type"));
 }
 
-/**
- * TransactionClient allows you to view and monitor transactions on Story Protocol.
- */
-var TransactionReadOnlyClient = /*#__PURE__*/function () {
-  function TransactionReadOnlyClient(httpClient, rpcClient) {
-    _classCallCheck(this, TransactionReadOnlyClient);
-    this.httpClient = httpClient;
-    this.rpcClient = rpcClient;
-  }
-
-  /**
-   * Get transaction data based on the specified transaction id.
-   *
-   * @param request - the request object for getting the transaction
-   * @returns the response object that contains the fetched transaction object
-   */
-  _createClass(TransactionReadOnlyClient, [{
-    key: "get",
-    value: function () {
-      var _get = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var response;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              _context.prev = 0;
-              _context.next = 3;
-              return this.httpClient.get("/protocol/transaction/".concat(request.transactionId));
-            case 3:
-              response = _context.sent;
-              return _context.abrupt("return", response.data);
-            case 7:
-              _context.prev = 7;
-              _context.t0 = _context["catch"](0);
-              handleError(_context.t0, "Failed to get transaction");
-            case 10:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this, [[0, 7]]);
-      }));
-      function get(_x) {
-        return _get.apply(this, arguments);
-      }
-      return get;
-    }()
-    /**
-     * List Transactions.
-     *
-     * @returns the response object that contains a list of transactions
-     */
-  }, {
-    key: "list",
-    value: function () {
-      var _list = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var response;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              _context2.prev = 0;
-              _context2.next = 3;
-              return this.httpClient.post("/protocol/transaction", request || {});
-            case 3:
-              response = _context2.sent;
-              return _context2.abrupt("return", response.data);
-            case 7:
-              _context2.prev = 7;
-              _context2.t0 = _context2["catch"](0);
-              handleError(_context2.t0, "Failed to list transactions");
-            case 10:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this, [[0, 7]]);
-      }));
-      function list(_x2) {
-        return _list.apply(this, arguments);
-      }
-      return list;
-    }()
-  }]);
-  return TransactionReadOnlyClient;
-}();
-
-/**
- * TransactionClient allows you to view and monitor transactions on Story Protocol.
- */
-var TransactionClient = /*#__PURE__*/function (_TransactionReadOnlyC) {
-  _inherits(TransactionClient, _TransactionReadOnlyC);
-  var _super = _createSuper(TransactionClient);
-  function TransactionClient(httpClient, rpcClient, wallet) {
-    var _this;
-    _classCallCheck(this, TransactionClient);
-    _this = _super.call(this, httpClient, rpcClient);
-    _this.wallet = wallet;
-    return _this;
-  }
-  return _createClass(TransactionClient);
-}(TransactionReadOnlyClient);
+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;
+}
 
-/**
- * Default timeout value for http clients.
- */
-var HTTP_TIMEOUT = 5000;
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
 
-var PlatformClient = /*#__PURE__*/function () {
-  function PlatformClient(httpClient) {
-    _classCallCheck(this, PlatformClient);
-    this.httpClient = httpClient;
-  }
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
 
-  /**
-   * Upload a file to Arweave.
-   *
-   * @param file - the file binary data to upload
-   * @param mimeType - the mime type of the file
-   * @returns the response object that contains the uri of the uploaded file
-   */
-  _createClass(PlatformClient, [{
-    key: "uploadFile",
-    value: function () {
-      var _uploadFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(file, mimeType) {
-        var preSignUrlResp, data, uploadResp, confirmResp;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              _context.prev = 0;
-              _context.next = 3;
-              return this.httpClient.post("/platform/file-upload/request");
-            case 3:
-              preSignUrlResp = _context.sent;
-              data = preSignUrlResp.data; // upload the file to s3
-              _context.next = 7;
-              return this.httpClient.put(data.url, file, {
-                timeout: 0,
-                headers: {
-                  "Content-Type": mimeType
-                }
-              });
-            case 7:
-              uploadResp = _context.sent;
-              if (!(uploadResp.status !== 200)) {
-                _context.next = 10;
-                break;
-              }
-              throw new Error("Failed to upload file to s3. Status: ".concat(uploadResp.status));
-            case 10:
-              _context.next = 12;
-              return this.httpClient.post("/platform/file-upload/confirm", {
-                key: data.key
-              });
-            case 12:
-              confirmResp = _context.sent;
-              return _context.abrupt("return", confirmResp.data);
-            case 16:
-              _context.prev = 16;
-              _context.t0 = _context["catch"](0);
-              return _context.abrupt("return", handleError(_context.t0, "Failed to upload file"));
-            case 19:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this, [[0, 16]]);
-      }));
-      function uploadFile(_x, _x2) {
-        return _uploadFile.apply(this, arguments);
-      }
-      return uploadFile;
-    }()
-  }]);
-  return PlatformClient;
-}();
+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);
+}
 
-/**
- * ModuleReadOnlyClient allows you to view and search modules on Story Protocol.
- */
-var ModuleReadOnlyClient = /*#__PURE__*/function () {
-  function ModuleReadOnlyClient(httpClient, rpcClient) {
-    _classCallCheck(this, ModuleReadOnlyClient);
-    this.httpClient = httpClient;
-    this.rpcClient = rpcClient;
-  }
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 
-  /**
-   * Get an module based on the module name.
-   *
-   * @param request - the request object for getting a module.
-   * @returns the response object the contains the fetched module.
-   */
-  _createClass(ModuleReadOnlyClient, [{
-    key: "get",
-    value: function () {
-      var _get = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var response;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              _context.prev = 0;
-              _context.next = 3;
-              return this.httpClient.get("/modules/".concat(request.name));
-            case 3:
-              response = _context.sent;
-              return _context.abrupt("return", response.data);
-            case 7:
-              _context.prev = 7;
-              _context.t0 = _context["catch"](0);
-              handleError(_context.t0, "Failed to get module");
-            case 10:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this, [[0, 7]]);
-      }));
-      function get(_x) {
-        return _get.apply(this, arguments);
-      }
-      return get;
-    }()
-    /**
-     * List modules.
-     *
-     * @returns the response object that contains results from listing query.
-     */
-  }, {
-    key: "list",
-    value: function () {
-      var _list = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var response;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              _context2.prev = 0;
-              _context2.next = 3;
-              return this.httpClient.post("/modules", request || {});
-            case 3:
-              response = _context2.sent;
-              return _context2.abrupt("return", response.data);
-            case 7:
-              _context2.prev = 7;
-              _context2.t0 = _context2["catch"](0);
-              handleError(_context2.t0, "Failed to list modules.");
-            case 10:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this, [[0, 7]]);
-      }));
-      function list(_x2) {
-        return _list.apply(this, arguments);
-      }
-      return list;
-    }()
-  }]);
-  return ModuleReadOnlyClient;
-}();
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
 
-var TaggingModuleABI = [{
+var IERC1155ABI = [{
+  anonymous: false,
   inputs: [{
-    internalType: "string",
-    name: "tag",
-    type: "string"
+    indexed: true,
+    internalType: "address",
+    name: "operator",
+    type: "address"
   }, {
+    indexed: true,
     internalType: "address",
-    name: "ipId",
+    name: "from",
     type: "address"
+  }, {
+    indexed: true,
+    internalType: "address",
+    name: "to",
+    type: "address"
+  }, {
+    indexed: false,
+    internalType: "uint256[]",
+    name: "ids",
+    type: "uint256[]"
+  }, {
+    indexed: false,
+    internalType: "uint256[]",
+    name: "values",
+    type: "uint256[]"
   }],
-  name: "removeTag",
-  outputs: [{
-    internalType: "bool",
-    name: "removed",
-    type: "bool"
-  }],
-  stateMutability: "nonpayable",
-  type: "function"
+  name: "TransferBatch",
+  type: "event"
 }, {
+  anonymous: false,
   inputs: [{
-    internalType: "string",
-    name: "tag",
-    type: "string"
-  }, {
+    indexed: true,
     internalType: "address",
-    name: "ipId",
+    name: "operator",
     type: "address"
-  }],
-  name: "setTag",
-  outputs: [{
-    internalType: "bool",
-    name: "added",
-    type: "bool"
-  }],
-  stateMutability: "nonpayable",
-  type: "function"
-}];
-
-var TaggingModuleRaw = TaggingModuleABI;
-abitype.formatAbi(TaggingModuleRaw);
-var TaggingModuleConfig = {
-  abi: TaggingModuleRaw,
-  address: viem.getAddress(process.env.TAGGING_MODULE || process.env.NEXT_PUBLIC_TAGGING_MODULE || "")
-};
-
-/**
- * TaggingReadOnlyClient allows you to view and search IP Assets on Story Protocol.
- */
-var TaggingReadOnlyClient = /*#__PURE__*/function () {
-  function TaggingReadOnlyClient(httpClient, rpcClient) {
-    _classCallCheck(this, TaggingReadOnlyClient);
-    this.httpClient = httpClient;
-    this.rpcClient = rpcClient;
-  }
-
-  /**
-   * Get tags.
-   *
-   * @returns the response object that contains results from get tag query.
-   */
-  _createClass(TaggingReadOnlyClient, [{
-    key: "get",
-    value: function () {
-      var _get = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var response;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              _context.prev = 0;
-              _context.next = 3;
-              return this.httpClient.get("/tags/".concat(request.id));
-            case 3:
-              response = _context.sent;
-              return _context.abrupt("return", response.data);
-            case 7:
-              _context.prev = 7;
-              _context.t0 = _context["catch"](0);
-              handleError(_context.t0, "Failed to get tags.");
-            case 10:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this, [[0, 7]]);
-      }));
-      function get(_x) {
-        return _get.apply(this, arguments);
-      }
-      return get;
-    }()
-    /**
-     * List tags.
-     *
-     * @returns the response object that contains results from list tags query.
-     */
-  }, {
-    key: "list",
-    value: function () {
-      var _list = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var response;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              _context2.prev = 0;
-              _context2.next = 3;
-              return this.httpClient.post("/tags", request || {});
-            case 3:
-              response = _context2.sent;
-              return _context2.abrupt("return", response.data);
-            case 7:
-              _context2.prev = 7;
-              _context2.t0 = _context2["catch"](0);
-              handleError(_context2.t0, "Failed to list tags.");
-            case 10:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this, [[0, 7]]);
-      }));
-      function list(_x2) {
-        return _list.apply(this, arguments);
-      }
-      return list;
-    }()
-  }]);
-  return TaggingReadOnlyClient;
-}();
-
-var TaggingClient = /*#__PURE__*/function (_TaggingReadOnlyClien) {
-  _inherits(TaggingClient, _TaggingReadOnlyClien);
-  var _super = _createSuper(TaggingClient);
-  function TaggingClient(httpClient, rpcClient, wallet) {
-    var _this;
-    _classCallCheck(this, TaggingClient);
-    _this = _super.call(this, httpClient, rpcClient);
-    _this.wallet = wallet;
-    return _this;
-  }
-  _createClass(TaggingClient, [{
-    key: "setTag",
-    value: function () {
-      var _setTag = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var _yield$this$rpcClient, call, txHash;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              _context.prev = 0;
-              _context.next = 3;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, TaggingModuleConfig), {}, {
-                functionName: "setTag",
-                args: [request.tag, request.ipId]
-              }));
-            case 3:
-              _yield$this$rpcClient = _context.sent;
-              call = _yield$this$rpcClient.request;
-              _context.next = 7;
-              return this.wallet.writeContract(call);
-            case 7:
-              txHash = _context.sent;
-              return _context.abrupt("return", {
-                txHash: txHash
-              });
-            case 11:
-              _context.prev = 11;
-              _context.t0 = _context["catch"](0);
-              handleError(_context.t0, "Failed to set tag");
-            case 14:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this, [[0, 11]]);
-      }));
-      function setTag(_x) {
-        return _setTag.apply(this, arguments);
-      }
-      return setTag;
-    }()
   }, {
-    key: "removeTag",
-    value: function () {
-      var _removeTag = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _yield$this$rpcClient2, call, txHash;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              _context2.prev = 0;
-              _context2.next = 3;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, TaggingModuleConfig), {}, {
-                functionName: "removeTag",
-                args: [request.tag, request.ipId]
-              }));
-            case 3:
-              _yield$this$rpcClient2 = _context2.sent;
-              call = _yield$this$rpcClient2.request;
-              _context2.next = 7;
-              return this.wallet.writeContract(call);
-            case 7:
-              txHash = _context2.sent;
-              return _context2.abrupt("return", {
-                txHash: txHash
-              });
-            case 11:
-              _context2.prev = 11;
-              _context2.t0 = _context2["catch"](0);
-              handleError(_context2.t0, "Failed to remove tag");
-            case 14:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this, [[0, 11]]);
-      }));
-      function removeTag(_x2) {
-        return _removeTag.apply(this, arguments);
-      }
-      return removeTag;
-    }()
-  }]);
-  return TaggingClient;
-}(TaggingReadOnlyClient);
-
-/**
- * IPAssetReadOnlyClient allows you to view and search IP Assets on Story Protocol.
- */
-var IPAssetReadOnlyClient = /*#__PURE__*/function () {
-  function IPAssetReadOnlyClient(httpClient, rpcClient) {
-    _classCallCheck(this, IPAssetReadOnlyClient);
-    this.httpClient = httpClient;
-    this.rpcClient = rpcClient;
-  }
-
-  /**
-   * Get an IP Asset based on the specified IP asset ID.
-   *
-   * @param request - the request object for getting an IP Asset.
-   * @returns the response object the contains the fetched IP Asset.
-   */
-  _createClass(IPAssetReadOnlyClient, [{
-    key: "get",
-    value: function () {
-      var _get = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var response;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              _context.prev = 0;
-              if (viem.isAddress(request.ipId)) {
-                _context.next = 3;
-                break;
-              }
-              throw new Error("Invalid ip id. Must be an address. But get: ".concat(request.ipId));
-            case 3:
-              _context.next = 5;
-              return this.httpClient.get("/accounts/".concat(request.ipId));
-            case 5:
-              response = _context.sent;
-              return _context.abrupt("return", response.data);
-            case 9:
-              _context.prev = 9;
-              _context.t0 = _context["catch"](0);
-              handleError(_context.t0, "Failed to get IP account");
-            case 12:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this, [[0, 9]]);
-      }));
-      function get(_x) {
-        return _get.apply(this, arguments);
-      }
-      return get;
-    }()
-    /**
-     * List IP accounts.
-     *
-     * @returns the response object that contains results from listing query.
-     */
+    indexed: true,
+    internalType: "address",
+    name: "from",
+    type: "address"
   }, {
-    key: "list",
-    value: function () {
-      var _list = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var response;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              _context2.prev = 0;
-              _context2.next = 3;
-              return this.httpClient.post("/accounts", request || {});
-            case 3:
-              response = _context2.sent;
-              return _context2.abrupt("return", response.data);
-            case 7:
-              _context2.prev = 7;
-              _context2.t0 = _context2["catch"](0);
-              handleError(_context2.t0, "Failed to list IP Asset.");
-            case 10:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this, [[0, 7]]);
-      }));
-      function list(_x2) {
-        return _list.apply(this, arguments);
-      }
-      return list;
-    }()
+    indexed: true,
+    internalType: "address",
+    name: "to",
+    type: "address"
   }, {
-    key: "getIpId",
-    value: function () {
-      var _getIpId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
-        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3);
-      }));
-      function getIpId() {
-        return _getIpId.apply(this, arguments);
-      }
-      return getIpId;
-    }()
-  }]);
-  return IPAssetReadOnlyClient;
-}();
-
-var IPAccountRegistryABI = [{
-  inputs: [{
+    indexed: false,
     internalType: "uint256",
-    name: "chainId_",
+    name: "id",
     type: "uint256"
   }, {
-    internalType: "address",
-    name: "tokenContract_",
-    type: "address"
-  }, {
+    indexed: false,
     internalType: "uint256",
-    name: "tokenId_",
+    name: "value",
     type: "uint256"
   }],
-  name: "ipAsset",
-  outputs: [{
-    internalType: "address",
-    name: "",
-    type: "address"
-  }],
-  stateMutability: "view",
-  type: "function"
-}, {
+  name: "TransferSingle",
+  type: "event"
+}];
+
+var AccessControllerABI = [{
   anonymous: false,
   inputs: [{
-    indexed: true,
+    indexed: false,
     internalType: "address",
-    name: "account",
+    name: "ipAccountOwner",
     type: "address"
   }, {
     indexed: true,
     internalType: "address",
-    name: "implementation",
+    name: "ipAccount",
     type: "address"
   }, {
     indexed: true,
-    internalType: "uint256",
-    name: "chainId",
-    type: "uint256"
+    internalType: "address",
+    name: "signer",
+    type: "address"
   }, {
-    indexed: false,
+    indexed: true,
     internalType: "address",
-    name: "tokenContract",
+    name: "to",
     type: "address"
   }, {
     indexed: false,
-    internalType: "uint256",
-    name: "tokenId",
-    type: "uint256"
+    internalType: "bytes4",
+    name: "func",
+    type: "bytes4"
+  }, {
+    indexed: false,
+    internalType: "uint8",
+    name: "permission",
+    type: "uint8"
   }],
-  name: "IPAccountRegistered",
+  name: "PermissionSet",
   type: "event"
-}];
-
-if (typeof process !== "undefined") {
-  dotenv__namespace.config();
-}
-var IPAccountRegistryRaw = IPAccountRegistryABI;
-abitype.formatAbi(IPAccountRegistryRaw);
-var IPAccountRegistryConfig = {
-  abi: IPAccountRegistryRaw,
-  address: viem.getAddress(process.env.IP_ACCOUNT_REGISTRY || process.env.NEXT_PUBLIC_IP_ACCOUNT_REGISTRY || "")
-};
-
-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;
-}
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "ipAccount",
+    type: "address"
+  }, {
+    internalType: "address",
+    name: "signer",
+    type: "address"
+  }, {
+    internalType: "address",
+    name: "to",
+    type: "address"
+  }, {
+    internalType: "bytes4",
+    name: "func",
+    type: "bytes4"
+  }, {
+    internalType: "uint8",
+    name: "permission",
+    type: "uint8"
+  }],
+  name: "setPermission",
+  outputs: [],
+  stateMutability: "nonpayable",
+  type: "function"
+}];
+
+var DisputeModuleABI = [{
+  anonymous: false,
+  inputs: [{
+    indexed: false,
+    internalType: "uint256",
+    name: "disputeId",
+    type: "uint256"
+  }, {
+    indexed: false,
+    internalType: "bytes",
+    name: "data",
+    type: "bytes"
+  }],
+  name: "DisputeCancelled",
+  type: "event"
+}, {
+  anonymous: false,
+  inputs: [{
+    indexed: false,
+    internalType: "uint256",
+    name: "disputeId",
+    type: "uint256"
+  }, {
+    indexed: false,
+    internalType: "address",
+    name: "targetIpId",
+    type: "address"
+  }, {
+    indexed: false,
+    internalType: "address",
+    name: "disputeInitiator",
+    type: "address"
+  }, {
+    indexed: false,
+    internalType: "address",
+    name: "arbitrationPolicy",
+    type: "address"
+  }, {
+    indexed: false,
+    internalType: "bytes32",
+    name: "linkToDisputeEvidence",
+    type: "bytes32"
+  }, {
+    indexed: false,
+    internalType: "bytes32",
+    name: "targetTag",
+    type: "bytes32"
+  }, {
+    indexed: false,
+    internalType: "bytes",
+    name: "data",
+    type: "bytes"
+  }],
+  name: "DisputeRaised",
+  type: "event"
+}, {
+  anonymous: false,
+  inputs: [{
+    indexed: false,
+    internalType: "uint256",
+    name: "disputeId",
+    type: "uint256"
+  }],
+  name: "DisputeResolved",
+  type: "event"
+}, {
+  inputs: [{
+    internalType: "uint256",
+    name: "disputeId",
+    type: "uint256"
+  }, {
+    internalType: "bytes",
+    name: "data",
+    type: "bytes"
+  }],
+  name: "cancelDispute",
+  outputs: [],
+  stateMutability: "nonpayable",
+  type: "function"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "targetIpId",
+    type: "address"
+  }, {
+    internalType: "string",
+    name: "linkToDisputeEvidence",
+    type: "string"
+  }, {
+    internalType: "bytes32",
+    name: "targetTag",
+    type: "bytes32"
+  }, {
+    internalType: "bytes",
+    name: "data",
+    type: "bytes"
+  }],
+  name: "raiseDispute",
+  outputs: [{
+    internalType: "uint256",
+    name: "",
+    type: "uint256"
+  }],
+  stateMutability: "nonpayable",
+  type: "function"
+}, {
+  inputs: [{
+    internalType: "uint256",
+    name: "disputeId",
+    type: "uint256"
+  }],
+  name: "resolveDispute",
+  outputs: [],
+  stateMutability: "nonpayable",
+  type: "function"
+}];
+
+var IPAccountImplABI = [{
+  inputs: [{
+    internalType: "address",
+    name: "to",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "value",
+    type: "uint256"
+  }, {
+    internalType: "bytes",
+    name: "data",
+    type: "bytes"
+  }],
+  name: "execute",
+  outputs: [{
+    internalType: "bytes",
+    name: "result",
+    type: "bytes"
+  }],
+  stateMutability: "payable",
+  type: "function"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "to",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "value",
+    type: "uint256"
+  }, {
+    internalType: "bytes",
+    name: "data",
+    type: "bytes"
+  }, {
+    internalType: "address",
+    name: "signer",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "deadline",
+    type: "uint256"
+  }, {
+    internalType: "bytes",
+    name: "signature",
+    type: "bytes"
+  }],
+  name: "executeWithSig",
+  outputs: [{
+    internalType: "bytes",
+    name: "result",
+    type: "bytes"
+  }],
+  stateMutability: "payable",
+  type: "function"
+}];
+
+var IPAssetRegistryABI = [{
+  anonymous: false,
+  inputs: [{
+    indexed: false,
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }, {
+    indexed: true,
+    internalType: "uint256",
+    name: "chainId",
+    type: "uint256"
+  }, {
+    indexed: true,
+    internalType: "address",
+    name: "tokenContract",
+    type: "address"
+  }, {
+    indexed: true,
+    internalType: "uint256",
+    name: "tokenId",
+    type: "uint256"
+  }, {
+    indexed: false,
+    internalType: "address",
+    name: "resolver",
+    type: "address"
+  }, {
+    indexed: false,
+    internalType: "address",
+    name: "provider",
+    type: "address"
+  }, {
+    indexed: false,
+    internalType: "bytes",
+    name: "metadata",
+    type: "bytes"
+  }],
+  name: "IPRegistered",
+  type: "event"
+}];
+
+var LicensingModuleABI = [{
+  anonymous: false,
+  inputs: [{
+    indexed: true,
+    internalType: "address",
+    name: "caller",
+    type: "address"
+  }, {
+    indexed: true,
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }, {
+    indexed: false,
+    internalType: "address[]",
+    name: "parentIpIds",
+    type: "address[]"
+  }],
+  name: "IpIdLinkedToParents",
+  type: "event"
+}, {
+  anonymous: false,
+  inputs: [{
+    indexed: true,
+    internalType: "address",
+    name: "caller",
+    type: "address"
+  }, {
+    indexed: true,
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }, {
+    indexed: true,
+    internalType: "uint256",
+    name: "policyId",
+    type: "uint256"
+  }, {
+    indexed: false,
+    internalType: "uint256",
+    name: "index",
+    type: "uint256"
+  }, {
+    indexed: false,
+    internalType: "bool",
+    name: "isInherited",
+    type: "bool"
+  }],
+  name: "PolicyAddedToIpId",
+  type: "event"
+}, {
+  anonymous: false,
+  inputs: [{
+    indexed: true,
+    internalType: "uint256",
+    name: "policyId",
+    type: "uint256"
+  }, {
+    indexed: true,
+    internalType: "address",
+    name: "policyFrameworkManager",
+    type: "address"
+  }, {
+    indexed: false,
+    internalType: "bytes",
+    name: "frameworkData",
+    type: "bytes"
+  }, {
+    indexed: false,
+    internalType: "address",
+    name: "royaltyPolicy",
+    type: "address"
+  }, {
+    indexed: false,
+    internalType: "bytes",
+    name: "royaltyData",
+    type: "bytes"
+  }, {
+    indexed: false,
+    internalType: "uint256",
+    name: "mintingFee",
+    type: "uint256"
+  }, {
+    indexed: false,
+    internalType: "address",
+    name: "mintingFeeToken",
+    type: "address"
+  }],
+  name: "PolicyRegistered",
+  type: "event"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "polId",
+    type: "uint256"
+  }],
+  name: "addPolicyToIp",
+  outputs: [{
+    internalType: "uint256",
+    name: "indexOnIpId",
+    type: "uint256"
+  }],
+  stateMutability: "nonpayable",
+  type: "function"
+}, {
+  inputs: [{
+    internalType: "uint256[]",
+    name: "licenseIds",
+    type: "uint256[]"
+  }, {
+    internalType: "address",
+    name: "childIpId",
+    type: "address"
+  }, {
+    internalType: "bytes",
+    name: "royaltyContext",
+    type: "bytes"
+  }],
+  name: "linkIpToParents",
+  outputs: [],
+  stateMutability: "nonpayable",
+  type: "function"
+}, {
+  inputs: [{
+    internalType: "uint256",
+    name: "policyId",
+    type: "uint256"
+  }, {
+    internalType: "address",
+    name: "licensorIpId",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "amount",
+    type: "uint256"
+  }, {
+    internalType: "address",
+    name: "receiver",
+    type: "address"
+  }, {
+    internalType: "bytes",
+    name: "royaltyContext",
+    type: "bytes"
+  }],
+  name: "mintLicense",
+  outputs: [{
+    internalType: "uint256",
+    name: "licenseId",
+    type: "uint256"
+  }],
+  stateMutability: "nonpayable",
+  type: "function"
+}, {
+  inputs: [{
+    components: [{
+      internalType: "bool",
+      name: "isLicenseTransferable",
+      type: "bool"
+    }, {
+      internalType: "address",
+      name: "policyFramework",
+      type: "address"
+    }, {
+      internalType: "bytes",
+      name: "frameworkData",
+      type: "bytes"
+    }, {
+      internalType: "address",
+      name: "royaltyPolicy",
+      type: "address"
+    }, {
+      internalType: "bytes",
+      name: "royaltyData",
+      type: "bytes"
+    }, {
+      internalType: "uint256",
+      name: "mintingFee",
+      type: "uint256"
+    }, {
+      internalType: "address",
+      name: "mintingFeeToken",
+      type: "address"
+    }],
+    internalType: "struct Licensing.Policy",
+    name: "pol",
+    type: "tuple"
+  }],
+  name: "registerPolicy",
+  outputs: [{
+    internalType: "uint256",
+    name: "policyId",
+    type: "uint256"
+  }],
+  stateMutability: "nonpayable",
+  type: "function"
+}];
+
+var PILPolicyFrameworkManagerABI = [{
+  inputs: [{
+    components: [{
+      internalType: "bool",
+      name: "transferable",
+      type: "bool"
+    }, {
+      internalType: "address",
+      name: "royaltyPolicy",
+      type: "address"
+    }, {
+      internalType: "uint256",
+      name: "mintingFee",
+      type: "uint256"
+    }, {
+      internalType: "address",
+      name: "mintingFeeToken",
+      type: "address"
+    }, {
+      components: [{
+        internalType: "bool",
+        name: "attribution",
+        type: "bool"
+      }, {
+        internalType: "bool",
+        name: "commercialUse",
+        type: "bool"
+      }, {
+        internalType: "bool",
+        name: "commercialAttribution",
+        type: "bool"
+      }, {
+        internalType: "address",
+        name: "commercializerChecker",
+        type: "address"
+      }, {
+        internalType: "bytes",
+        name: "commercializerCheckerData",
+        type: "bytes"
+      }, {
+        internalType: "uint32",
+        name: "commercialRevShare",
+        type: "uint32"
+      }, {
+        internalType: "bool",
+        name: "derivativesAllowed",
+        type: "bool"
+      }, {
+        internalType: "bool",
+        name: "derivativesAttribution",
+        type: "bool"
+      }, {
+        internalType: "bool",
+        name: "derivativesApproval",
+        type: "bool"
+      }, {
+        internalType: "bool",
+        name: "derivativesReciprocal",
+        type: "bool"
+      }, {
+        internalType: "string[]",
+        name: "territories",
+        type: "string[]"
+      }, {
+        internalType: "string[]",
+        name: "distributionChannels",
+        type: "string[]"
+      }, {
+        internalType: "string[]",
+        name: "contentRestrictions",
+        type: "string[]"
+      }],
+      internalType: "struct PILPolicy",
+      name: "policy",
+      type: "tuple"
+    }],
+    internalType: "struct RegisterPILPolicyParams",
+    name: "params",
+    type: "tuple"
+  }],
+  name: "registerPolicy",
+  outputs: [{
+    internalType: "uint256",
+    name: "policyId",
+    type: "uint256"
+  }],
+  stateMutability: "nonpayable",
+  type: "function"
+}];
+
+var RegistrationModuleABI = [{
+  inputs: [{
+    internalType: "uint256[]",
+    name: "licenseIds",
+    type: "uint256[]"
+  }, {
+    internalType: "address",
+    name: "tokenContract",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "tokenId",
+    type: "uint256"
+  }, {
+    internalType: "string",
+    name: "ipName",
+    type: "string"
+  }, {
+    internalType: "bytes32",
+    name: "contentHash",
+    type: "bytes32"
+  }, {
+    internalType: "string",
+    name: "externalURL",
+    type: "string"
+  }, {
+    internalType: "bytes",
+    name: "royaltyContext",
+    type: "bytes"
+  }],
+  name: "registerDerivativeIp",
+  outputs: [],
+  stateMutability: "nonpayable",
+  type: "function"
+}, {
+  inputs: [{
+    internalType: "uint256",
+    name: "policyId",
+    type: "uint256"
+  }, {
+    internalType: "address",
+    name: "tokenContract",
+    type: "address"
+  }, {
+    internalType: "uint256",
+    name: "tokenId",
+    type: "uint256"
+  }, {
+    internalType: "string",
+    name: "ipName",
+    type: "string"
+  }, {
+    internalType: "bytes32",
+    name: "contentHash",
+    type: "bytes32"
+  }, {
+    internalType: "string",
+    name: "externalURL",
+    type: "string"
+  }],
+  name: "registerRootIp",
+  outputs: [{
+    internalType: "address",
+    name: "",
+    type: "address"
+  }],
+  stateMutability: "nonpayable",
+  type: "function"
+}];
+
+var TaggingModuleABI = [{
+  inputs: [{
+    internalType: "string",
+    name: "tag",
+    type: "string"
+  }, {
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }],
+  name: "removeTag",
+  outputs: [{
+    internalType: "bool",
+    name: "removed",
+    type: "bool"
+  }],
+  stateMutability: "nonpayable",
+  type: "function"
+}, {
+  inputs: [{
+    internalType: "string",
+    name: "tag",
+    type: "string"
+  }, {
+    internalType: "address",
+    name: "ipId",
+    type: "address"
+  }],
+  name: "setTag",
+  outputs: [{
+    internalType: "bool",
+    name: "added",
+    type: "bool"
+  }],
+  stateMutability: "nonpayable",
+  type: "function"
+}];
+
+var ErrorsABI = [{
+  inputs: [{
+    internalType: "address",
+    name: "caller",
+    type: "address"
+  }],
+  name: "AccessControlled__CallerIsNotIpAccount",
+  type: "error"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "ipAccount",
+    type: "address"
+  }],
+  name: "AccessControlled__NotIpAccount",
+  type: "error"
+}, {
+  inputs: [],
+  name: "AccessControlled__ZeroAddress",
+  type: "error"
+}, {
+  inputs: [],
+  name: "AccessController__CallerIsNotIPAccount",
+  type: "error"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "ipAccount",
+    type: "address"
+  }],
+  name: "AccessController__IPAccountIsNotValid",
+  type: "error"
+}, {
+  inputs: [],
+  name: "AccessController__IPAccountIsZeroAddress",
+  type: "error"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "ipAccount",
+    type: "address"
+  }, {
+    internalType: "address",
+    name: "signer",
+    type: "address"
+  }, {
+    internalType: "address",
+    name: "to",
+    type: "address"
+  }, {
+    internalType: "bytes4",
+    name: "func",
+    type: "bytes4"
+  }],
+  name: "AccessController__PermissionDenied",
+  type: "error"
+}, {
+  inputs: [],
+  name: "AccessController__PermissionIsNotValid",
+  type: "error"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "to",
+    type: "address"
+  }],
+  name: "AccessController__RecipientIsNotRegisteredModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "AccessController__SignerIsZeroAddress",
+  type: "error"
+}, {
+  inputs: [],
+  name: "AncestorsVaultLAP__AlreadyClaimed",
+  type: "error"
+}, {
+  inputs: [],
+  name: "AncestorsVaultLAP__ClaimerNotAnAncestor",
+  type: "error"
+}, {
+  inputs: [],
+  name: "AncestorsVaultLAP__ERC20BalanceNotZero",
+  type: "error"
+}, {
+  inputs: [],
+  name: "AncestorsVaultLAP__ETHBalanceNotZero",
+  type: "error"
+}, {
+  inputs: [],
+  name: "AncestorsVaultLAP__InvalidAncestorsHash",
+  type: "error"
+}, {
+  inputs: [],
+  name: "AncestorsVaultLAP__InvalidClaimer",
+  type: "error"
+}, {
+  inputs: [],
+  name: "AncestorsVaultLAP__TransferFailed",
+  type: "error"
+}, {
+  inputs: [],
+  name: "AncestorsVaultLAP__ZeroRoyaltyPolicyLAP",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ArbitrationPolicySP__NotDisputeModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ArbitrationPolicySP__ZeroDisputeModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ArbitrationPolicySP__ZeroPaymentToken",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotAbleToResolve",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotDisputeInitiator",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotInDisputeState",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotRegisteredIpId",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotWhitelistedArbitrationPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotWhitelistedArbitrationRelayer",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__NotWhitelistedDisputeTag",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__UnauthorizedAccess",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__ZeroArbitrationPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__ZeroArbitrationRelayer",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__ZeroDisputeTag",
+  type: "error"
+}, {
+  inputs: [],
+  name: "DisputeModule__ZeroLinkToDisputeEvidence",
+  type: "error"
+}, {
+  inputs: [],
+  name: "Governance__InconsistentState",
+  type: "error"
+}, {
+  inputs: [],
+  name: "Governance__NewStateIsTheSameWithOldState",
+  type: "error"
+}, {
+  inputs: [],
+  name: "Governance__OnlyProtocolAdmin",
+  type: "error"
+}, {
+  inputs: [],
+  name: "Governance__ProtocolPaused",
+  type: "error"
+}, {
+  inputs: [{
+    internalType: "string",
+    name: "interfaceName",
+    type: "string"
+  }],
+  name: "Governance__UnsupportedInterface",
+  type: "error"
+}, {
+  inputs: [],
+  name: "Governance__ZeroAddress",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAccountRegistry_InvalidIpAccountImpl",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAccount__ExpiredSignature",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAccount__InvalidAccessController",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAccount__InvalidCalldata",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAccount__InvalidSignature",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAccount__InvalidSigner",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAssetRegistry__AlreadyRegistered",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAssetRegistry__IPAccountAlreadyCreated",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAssetRegistry__InvalidAccount",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAssetRegistry__InvalidMetadataProvider",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAssetRegistry__NotYetRegistered",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAssetRegistry__RegistrantUnauthorized",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAssetRegistry__ResolverInvalid",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPAssetRegistry__Unauthorized",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPResolver_InvalidIP",
+  type: "error"
+}, {
+  inputs: [],
+  name: "IPResolver_Unauthorized",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicenseRegistry__CallerNotLicensingModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicenseRegistry__NotTransferable",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicenseRegistry__RevokedLicense",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicenseRegistry__ZeroDisputeModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicenseRegistry__ZeroLicensingModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModuleAware__CallerNotLicensingModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__CallerNotLicenseRegistry",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__CallerNotLicensorAndPolicyNotSet",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__CommercialTermInNonCommercialPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__DerivativeRevShareSumExceedsMaxRNFTSupply",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__DerivativesCannotAddPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__DisputedIpId",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__EmptyLicenseUrl",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__EmptyParamName",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__FrameworkNotFound",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__IncompatibleLicensorCommercialPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__IncompatibleLicensorRoyaltyDerivativeRevShare",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__IncompatibleRoyaltyPolicyAddress",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__IncompatibleRoyaltyPolicyDerivativeRevShare",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__InvalidLicensor",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__InvalidPolicyFramework",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__LicensorDoesntHaveThisPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__LicensorNotRegistered",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__LinkParentParamFailed",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__LinkingRevokedLicense",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__MintLicenseParamFailed",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__MintingFeeTokenNotWhitelisted",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__MismatchBetweenRoyaltyPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__NotLicensee",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__ParamVerifierAlreadySet",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__ParamVerifierLengthMismatch",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__ParentIdEqualThanChild",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__PolicyAlreadySetForIpId",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__PolicyNotFound",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__RegisterPolicyFrameworkMismatch",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__RoyaltyPolicyNotWhitelisted",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__TransferParamFailed",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__UnauthorizedAccess",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensingModule__UnregisteredFrameworkAddingPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "LicensorApprovalChecker__Unauthorized",
+  type: "error"
+}, {
+  inputs: [],
+  name: "MetadataProvider__HashInvalid",
+  type: "error"
+}, {
+  inputs: [],
+  name: "MetadataProvider__IPAssetOwnerInvalid",
+  type: "error"
+}, {
+  inputs: [],
+  name: "MetadataProvider__MetadataNotCompatible",
+  type: "error"
+}, {
+  inputs: [],
+  name: "MetadataProvider__NameInvalid",
+  type: "error"
+}, {
+  inputs: [],
+  name: "MetadataProvider__RegistrantInvalid",
+  type: "error"
+}, {
+  inputs: [],
+  name: "MetadataProvider__RegistrationDateInvalid",
+  type: "error"
+}, {
+  inputs: [],
+  name: "MetadataProvider__URIInvalid",
+  type: "error"
+}, {
+  inputs: [],
+  name: "MetadataProvider__Unauthorized",
+  type: "error"
+}, {
+  inputs: [],
+  name: "MetadataProvider__UpgradeProviderInvalid",
+  type: "error"
+}, {
+  inputs: [],
+  name: "MetadataProvider__UpgradeUnavailable",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ModuleRegistry__InterfaceIdZero",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ModuleRegistry__ModuleAddressNotContract",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ModuleRegistry__ModuleAddressZeroAddress",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ModuleRegistry__ModuleAlreadyRegistered",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ModuleRegistry__ModuleNotRegistered",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ModuleRegistry__ModuleNotSupportExpectedModuleTypeInterfaceId",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ModuleRegistry__ModuleTypeAlreadyRegistered",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ModuleRegistry__ModuleTypeEmptyString",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ModuleRegistry__ModuleTypeNotRegistered",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ModuleRegistry__NameAlreadyRegistered",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ModuleRegistry__NameDoesNotMatch",
+  type: "error"
+}, {
+  inputs: [],
+  name: "ModuleRegistry__NameEmptyString",
+  type: "error"
+}, {
+  inputs: [],
+  name: "Module_Unauthorized",
+  type: "error"
+}, {
+  inputs: [{
+    internalType: "address",
+    name: "commercializer",
+    type: "address"
+  }],
+  name: "PolicyFrameworkManager__CommercializerCheckerDoesNotSupportHook",
+  type: "error"
+}, {
+  inputs: [],
+  name: "PolicyFrameworkManager__GettingPolicyWrongFramework",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RegistrationModule__InvalidOwner",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyModule__CanOnlyMintSelectedPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyModule__IncompatibleRoyaltyPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyModule__NoParentsOnLinking",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyModule__NoRoyaltyPolicySet",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyModule__NotAllowedCaller",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyModule__NotRegisteredIpId",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyModule__NotWhitelistedRoyaltyPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyModule__NotWhitelistedRoyaltyToken",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyModule__ZeroLicensingModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyModule__ZeroRoyaltyPolicy",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyModule__ZeroRoyaltyToken",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__AboveAncestorsLimit",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__AboveParentLimit",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__AboveRoyaltyStackLimit",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__ImplementationAlreadySet",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__InvalidAncestors",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__InvalidAncestorsHash",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__InvalidAncestorsLength",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__InvalidAncestorsRoyalty",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__InvalidParentRoyaltiesLength",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__InvalidRoyaltyAmountLength",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__LastPositionNotAbleToMintLicense",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__NotFullOwnership",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__NotRoyaltyModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__TransferFailed",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__UnlinkableToParents",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__ZeroAncestorsVaultImpl",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__ZeroLicensingModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__ZeroLiquidSplitFactory",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__ZeroLiquidSplitMain",
+  type: "error"
+}, {
+  inputs: [],
+  name: "RoyaltyPolicyLAP__ZeroRoyaltyModule",
+  type: "error"
+}, {
+  inputs: [],
+  name: "TaggingModule__DstIpIdDoesNotHaveDstTag",
+  type: "error"
+}, {
+  inputs: [],
+  name: "TaggingModule__InvalidRelationTypeName",
+  type: "error"
+}, {
+  inputs: [],
+  name: "TaggingModule__RelationTypeAlreadyExists",
+  type: "error"
+}, {
+  inputs: [],
+  name: "TaggingModule__RelationTypeDoesNotExist",
+  type: "error"
+}, {
+  inputs: [],
+  name: "TaggingModule__SrcIpIdDoesNotHaveSrcTag",
+  type: "error"
+}];
 
-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);
-}
+var sepolia = {
+  AccessController: "0x31dd83a3FebB5fAD7F7bc8D4E05B623461B74a02",
+  AncestorsVaultLAP: "0x9Faa4E491a211bFa415d44554120B1b31b6f4e59",
+  ArbitrationPolicySP: "0x75e181d5eb307eCccf8d3b4724109eca14719A75",
+  DisputeModule: "0x11dAA3F573C4d6673BBE7f2D96B4C91073A0d55d",
+  Governance: "0xa18252Aa11Ff1B20b89C10109050CC46A4067b22",
+  IPAccountImpl: "0x7BBaB2BD68fd3990c8dA2c26334a6DF8Acc7E96E",
+  IPAccountRegistry: "0x7184bAdAdf24dc261C7C27BceFF53d7A25a06846",
+  IPAssetRegistry: "0xF59adB67B7CC87436A7CC41040A7dB24AE90aDB8",
+  IPAssetRenderer: "0x986d8E96b30b688FCD84e9A5A757C3d4304B47b6",
+  IPMetadataProvider: "0xfcD468A72F76e89F2Df517274063ef7210a32e2A",
+  IPResolver: "0xF0920314Fb4C375cdEB5b15c4e77277aCf36E3D7",
+  LicenseRegistry: "0x4D6a54B467332dF675cFa689cb294A4cB9122866",
+  LicensingModule: "0x0C72b24067a15994f91D92Fd9bA23eB5ebcF8378",
+  MockERC20: "0xd53C2A80D24F6B3Ff009E48CF88D3b482E8E1457",
+  MockERC721: "0xD3719824a768c139AAa7C5eFc8BDb5D1d13A1564",
+  MockTokenGatedHook: "0x2d3ED4354eD09B0E6aa252938aEF41920aB6FC40",
+  ModuleRegistry: "0x17Ad1cD06d44ae5F5480A675A4D8BD8DAED40410",
+  PILPolicyFrameworkManager: "0x49cF5C5523011F8B4A0489969096Eb68C571C197",
+  RegistrationModule: "0x248c8CbF469ec7CB22Dc9914E569920b93d717a3",
+  RoyaltyModule: "0x512bbF310452cC96E0E9818B0870EcA557b86d4D",
+  RoyaltyPolicyLAP: "0x8404061350BA0CA85c4E733B0be78c5519679003",
+  TaggingModule: "0xED445f1DeE74Cf470Aab47F4b63734653C4C9537"
+};
+
+var IPAccountABI = [].concat(_toConsumableArray(IPAccountImplABI), _toConsumableArray(ErrorsABI));
+var IPAssetRegistryConfig = {
+  abi: IPAssetRegistryABI,
+  address: viem.getAddress(sepolia.IPAssetRegistry)
+};
+var AccessControllerConfig = {
+  abi: [].concat(_toConsumableArray(AccessControllerABI), _toConsumableArray(ErrorsABI)),
+  address: viem.getAddress(sepolia.AccessController)
+};
+var DisputeModuleConfig = {
+  abi: [].concat(_toConsumableArray(DisputeModuleABI), _toConsumableArray(ErrorsABI)),
+  address: viem.getAddress(sepolia.DisputeModule)
+};
+var LicenseRegistryConfig = {
+  abi: IERC1155ABI,
+  address: viem.getAddress(sepolia.LicenseRegistry)
+};
+var LicensingModuleConfig = {
+  abi: LicensingModuleABI,
+  //abi: [...LicensingModuleABI, ...ErrorsABI],
+  address: viem.getAddress(sepolia.LicensingModule)
+};
+var RegistrationModuleConfig = {
+  abi: RegistrationModuleABI,
+  //abi: [...RegistrationModuleABI, ...ErrorsABI],
+  address: viem.getAddress(sepolia.RegistrationModule)
+};
+var TaggingModuleConfig = {
+  abi: [].concat(_toConsumableArray(TaggingModuleABI), _toConsumableArray(ErrorsABI)),
+  address: viem.getAddress(sepolia.TaggingModule)
+};
+var PILPolicyFrameworkManagerConfig = {
+  abi: PILPolicyFrameworkManagerABI,
+  //abi: [...PILPolicyFrameworkManagerABI, ...ErrorsABI],
+  address: viem.getAddress(sepolia.PILPolicyFrameworkManager)
+};
 
 function _createForOfIteratorHelper(o, allowArrayLike) {
   var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
@@ -1208,546 +1977,737 @@ function _createForOfIteratorHelper(o, allowArrayLike) {
     }
     throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
-  var normalCompletion = true,
-    didErr = false,
-    err;
-  return {
-    s: function () {
-      it = it.call(o);
-    },
-    n: function () {
-      var step = it.next();
-      normalCompletion = step.done;
-      return step;
-    },
-    e: function (e) {
-      didErr = true;
-      err = e;
-    },
-    f: function () {
-      try {
-        if (!normalCompletion && it.return != null) it.return();
-      } finally {
-        if (didErr) throw err;
+  var normalCompletion = true,
+    didErr = false,
+    err;
+  return {
+    s: function () {
+      it = it.call(o);
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+
+function parseToBigInt(num) {
+  return BigInt(num);
+}
+function waitTxAndFilterLog(_x, _x2, _x3) {
+  return _waitTxAndFilterLog.apply(this, arguments);
+}
+function _waitTxAndFilterLog() {
+  _waitTxAndFilterLog = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(client, txHash, params) {
+    var txReceipt, _iterator, _step, log;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return client.waitForTransactionReceipt({
+            hash: txHash,
+            confirmations: params.confirmations,
+            pollingInterval: params.pollingInterval,
+            timeout: params.timeout
+          });
+        case 2:
+          txReceipt = _context.sent;
+          _iterator = _createForOfIteratorHelper(txReceipt.logs);
+          _context.prev = 4;
+          _iterator.s();
+        case 6:
+          if ((_step = _iterator.n()).done) {
+            _context.next = 17;
+            break;
+          }
+          log = _step.value;
+          _context.prev = 8;
+          return _context.abrupt("return", viem.decodeEventLog({
+            abi: params.abi,
+            eventName: params.eventName,
+            data: log.data,
+            topics: log.topics
+          }));
+        case 12:
+          _context.prev = 12;
+          _context.t0 = _context["catch"](8);
+          return _context.abrupt("continue", 15);
+        case 15:
+          _context.next = 6;
+          break;
+        case 17:
+          _context.next = 22;
+          break;
+        case 19:
+          _context.prev = 19;
+          _context.t1 = _context["catch"](4);
+          _iterator.e(_context.t1);
+        case 22:
+          _context.prev = 22;
+          _iterator.f();
+          return _context.finish(22);
+        case 25:
+          throw new Error("not found event ".concat(params.eventName, " in target transaction"));
+        case 26:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[4, 19, 22, 25], [8, 12]]);
+  }));
+  return _waitTxAndFilterLog.apply(this, arguments);
+}
+function waitTx(_x4, _x5, _x6) {
+  return _waitTx.apply(this, arguments);
+}
+function _waitTx() {
+  _waitTx = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(client, txHash, params) {
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return client.waitForTransactionReceipt(_objectSpread2({
+            hash: txHash
+          }, params));
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _waitTx.apply(this, arguments);
+}
+function chainStringToViemChain(chainId) {
+  switch (chainId) {
+    case "1":
+    case "mainnet":
+      return chains.mainnet;
+    case "11155111":
+    case "sepolia":
+      return chains.sepolia;
+    case "80001":
+    case "mumbai":
+    case "polygonMumbai":
+      return chains.polygonMumbai;
+    default:
+      throw new Error("chainId ".concat(chainId, " not supported"));
+  }
+}
+
+var TaggingClient = /*#__PURE__*/function () {
+  function TaggingClient(rpcClient, wallet) {
+    _classCallCheck(this, TaggingClient);
+    _defineProperty(this, "taggingModuleConfig", TaggingModuleConfig);
+    this.rpcClient = rpcClient;
+    this.wallet = wallet;
+  }
+  _createClass(TaggingClient, [{
+    key: "setTag",
+    value: function () {
+      var _setTag = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
+        var _request$txOptions, _yield$this$rpcClient, call, txHash;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              _context.next = 3;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.taggingModuleConfig), {}, {
+                functionName: "setTag",
+                args: [request.tag, request.ipId]
+              }));
+            case 3:
+              _yield$this$rpcClient = _context.sent;
+              call = _yield$this$rpcClient.request;
+              _context.next = 7;
+              return this.wallet.writeContract(call);
+            case 7:
+              txHash = _context.sent;
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
+                _context.next = 11;
+                break;
+              }
+              _context.next = 11;
+              return waitTx(this.rpcClient, txHash);
+            case 11:
+              return _context.abrupt("return", {
+                txHash: txHash
+              });
+            case 14:
+              _context.prev = 14;
+              _context.t0 = _context["catch"](0);
+              handleError(_context.t0, "Failed to set tag");
+            case 17:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[0, 14]]);
+      }));
+      function setTag(_x) {
+        return _setTag.apply(this, arguments);
+      }
+      return setTag;
+    }()
+  }, {
+    key: "removeTag",
+    value: function () {
+      var _removeTag = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
+        var _request$txOptions2, _yield$this$rpcClient2, call, txHash;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.prev = 0;
+              _context2.next = 3;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.taggingModuleConfig), {}, {
+                functionName: "removeTag",
+                args: [request.tag, request.ipId]
+              }));
+            case 3:
+              _yield$this$rpcClient2 = _context2.sent;
+              call = _yield$this$rpcClient2.request;
+              _context2.next = 7;
+              return this.wallet.writeContract(call);
+            case 7:
+              txHash = _context2.sent;
+              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
+                _context2.next = 11;
+                break;
+              }
+              _context2.next = 11;
+              return waitTx(this.rpcClient, txHash);
+            case 11:
+              return _context2.abrupt("return", {
+                txHash: txHash
+              });
+            case 14:
+              _context2.prev = 14;
+              _context2.t0 = _context2["catch"](0);
+              handleError(_context2.t0, "Failed to remove tag");
+            case 17:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[0, 14]]);
+      }));
+      function removeTag(_x2) {
+        return _removeTag.apply(this, arguments);
+      }
+      return removeTag;
+    }()
+  }]);
+  return TaggingClient;
+}();
+
+var AddressZero = "0x0000000000000000000000000000000000000000";
+var HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
+
+var IPAssetClient = /*#__PURE__*/function () {
+  function IPAssetClient(rpcClient, wallet) {
+    _classCallCheck(this, IPAssetClient);
+    _defineProperty(this, "ipAssetRegistryConfig", IPAssetRegistryConfig);
+    _defineProperty(this, "registrationModuleConfig", RegistrationModuleConfig);
+    this.wallet = wallet;
+    this.rpcClient = rpcClient;
+  }
+
+  /**
+   *  Registers a root-level IP into the protocol. Root-level IPs can be thought of as organizational hubs
+   *  for encapsulating policies that actual IPs can use to register through. As such, a root-level IP is not an
+   *  actual IP, but a container for IP policy management for their child IP assets.
+   * @param request The request object that contains all data needed to register a root IP.
+   *   @param request.policyId The policy that identifies the licensing terms of the IP.
+   *   @param request.tokenContract The address of the NFT bound to the root-level IP.
+   *   @param request.tokenId The token id of the NFT bound to the root-level IP.
+   *   @param request.ipName [Optional] The name assigned to the new IP.
+   *   @param request.contentHash [Optional] The content hash of the IP being registered.
+   *   @param request.uri [Optional] An external URI to link to the IP.
+   *   @param request.txOptions [Optional] The transaction options.
+   * @returns A Promise that resolves to an object containing the transaction hash and optional IP ID if waitForTxn is set to true.
+   * @emits RootIPRegistered (msg.sender, ipId, policyId)
+   */
+  _createClass(IPAssetClient, [{
+    key: "registerRootIp",
+    value: function () {
+      var _registerRootIp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
+        var _request$txOptions, _yield$this$rpcClient, call, txHash, targetLog;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              _context.next = 3;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.registrationModuleConfig), {}, {
+                functionName: "registerRootIp",
+                args: [parseToBigInt(request.policyId), viem.getAddress(request.tokenContractAddress),
+                // 0x Address
+                parseToBigInt(request.tokenId), request.ipName || "", request.contentHash || HashZero, request.uri || ""],
+                account: this.wallet.account
+              }));
+            case 3:
+              _yield$this$rpcClient = _context.sent;
+              call = _yield$this$rpcClient.request;
+              _context.next = 7;
+              return this.wallet.writeContract(call);
+            case 7:
+              txHash = _context.sent;
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
+                _context.next = 15;
+                break;
+              }
+              _context.next = 11;
+              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.ipAssetRegistryConfig), {}, {
+                eventName: "IPRegistered"
+              }));
+            case 11:
+              targetLog = _context.sent;
+              return _context.abrupt("return", {
+                txHash: txHash,
+                ipId: targetLog.args.ipId
+              });
+            case 15:
+              return _context.abrupt("return", {
+                txHash: txHash
+              });
+            case 16:
+              _context.next = 21;
+              break;
+            case 18:
+              _context.prev = 18;
+              _context.t0 = _context["catch"](0);
+              handleError(_context.t0, "Failed to register root IP");
+            case 21:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[0, 18]]);
+      }));
+      function registerRootIp(_x) {
+        return _registerRootIp.apply(this, arguments);
       }
-    }
-  };
-}
+      return registerRootIp;
+    }()
+    /**
+     *  Registers derivative IPs into the protocol. Derivative IPs are IP assets that inherit policies from
+     *  parent IPs by burning acquired license NFTs.
+     * @param request The request object that contains all data needed to register a root IP.
+     *   @param request.licenseIds The policy that identifies the licensing terms of the IP.
+     *   @param request.tokenContract The address of the NFT bound to the derivative IP.
+     *   @param request.tokenId The token id of the NFT bound to the derivative IP.
+     *   @param request.ipName [Optional] The name assigned to the new IP.
+     *   @param request.contentHash [Optional] The content hash of the IP being registered.
+     *   @param request.uri [Optional] An external URI to link to the IP.
+     *   @param request.minRoyalty [Optional] The minimum royalty percentage that the IP owner will receive.
+     *   @param request.txOptions [Optional] The transaction options.
+     * @returns A Promise that resolves to an object containing the transaction hash and optional IP ID if waitForTxn is set to true.
+     * @emits RootIPRegistered (msg.sender, ipId, policyId)
+     */
+  }, {
+    key: "registerDerivativeIp",
+    value: function () {
+      var _registerDerivativeIp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
+        var _request$txOptions2, licenseIds, _yield$this$rpcClient2, call, txHash, targetLog;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.prev = 0;
+              licenseIds = [];
+              request.licenseIds.forEach(function (licenseId) {
+                licenseIds.push(parseToBigInt(licenseId));
+              });
+              _context2.next = 5;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.registrationModuleConfig), {}, {
+                functionName: "registerDerivativeIp",
+                args: [licenseIds, viem.getAddress(request.tokenContractAddress),
+                // 0x Address
+                parseToBigInt(request.tokenId), request.ipName || "", request.contentHash || HashZero, request.uri || "", "0x"],
+                account: this.wallet.account
+              }));
+            case 5:
+              _yield$this$rpcClient2 = _context2.sent;
+              call = _yield$this$rpcClient2.request;
+              _context2.next = 9;
+              return this.wallet.writeContract(call);
+            case 9:
+              txHash = _context2.sent;
+              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
+                _context2.next = 17;
+                break;
+              }
+              _context2.next = 13;
+              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.ipAssetRegistryConfig), {}, {
+                eventName: "IPRegistered"
+              }));
+            case 13:
+              targetLog = _context2.sent;
+              return _context2.abrupt("return", {
+                txHash: txHash,
+                ipId: targetLog.args.ipId
+              });
+            case 17:
+              return _context2.abrupt("return", {
+                txHash: txHash
+              });
+            case 18:
+              _context2.next = 23;
+              break;
+            case 20:
+              _context2.prev = 20;
+              _context2.t0 = _context2["catch"](0);
+              handleError(_context2.t0, "Failed to register derivative IP");
+            case 23:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[0, 20]]);
+      }));
+      function registerDerivativeIp(_x2) {
+        return _registerDerivativeIp.apply(this, arguments);
+      }
+      return registerDerivativeIp;
+    }()
+  }]);
+  return IPAssetClient;
+}();
 
-function parseToBigInt(num) {
-  return BigInt(num);
-}
-function waitTxAndFilterLog(_x, _x2, _x3) {
-  return _waitTxAndFilterLog.apply(this, arguments);
-}
-function _waitTxAndFilterLog() {
-  _waitTxAndFilterLog = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(client, txHash, params) {
-    var txReceipt, _iterator, _step, log;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          _context.next = 2;
-          return client.waitForTransactionReceipt({
-            hash: txHash,
-            confirmations: params.confirmations,
-            pollingInterval: params.pollingInterval,
-            timeout: params.timeout
-          });
-        case 2:
-          txReceipt = _context.sent;
-          _iterator = _createForOfIteratorHelper(txReceipt.logs);
-          _context.prev = 4;
-          _iterator.s();
-        case 6:
-          if ((_step = _iterator.n()).done) {
-            _context.next = 17;
-            break;
+var PermissionClient = /*#__PURE__*/function () {
+  function PermissionClient(rpcClient, wallet) {
+    _classCallCheck(this, PermissionClient);
+    _defineProperty(this, "ipAccountABI", IPAccountABI);
+    _defineProperty(this, "accessControllerConfig", AccessControllerConfig);
+    this.rpcClient = rpcClient;
+    this.wallet = wallet;
+  }
+
+  /**
+   * Sets the permission for a specific function call
+   * Each policy is represented as a mapping from an IP account address to a signer address to a recipient
+   * address to a function selector to a permission level. The permission level can be 0 (ABSTAIN), 1 (ALLOW), or
+   * 2 (DENY).
+   * By default, all policies are set to 0 (ABSTAIN), which means that the permission is not set.
+   * The owner of ipAccount by default has all permission.
+   * address(0) => wildcard
+   * bytes4(0) => wildcard
+   * Specific permission overrides wildcard permission.
+   * @param request The request object containing necessary data to set permissions.
+   *   @param request.ipAsset The address of the IP account that grants the permission for `signer`
+   *   @param request.signer The address that can call `to` on behalf of the `ipAccount`
+   *   @param request.to The address that can be called by the `signer` (currently only modules can be `to`)
+   *   @param request.func The function selector string of `to` that can be called by the `signer` on behalf of the `ipAccount`
+   *   @param request.permission The new permission level
+   * @returns A Promise that resolves to an object containing the transaction hash
+   * @emits PermissionSet (ipAccountOwner, ipAccount, signer, to, func, permission)
+   */
+  _createClass(PermissionClient, [{
+    key: "setPermission",
+    value: function () {
+      var _setPermission = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
+        var _request$txOptions, IPAccountConfig, _yield$this$rpcClient, call, txHash;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              IPAccountConfig = {
+                abi: this.ipAccountABI,
+                address: viem.getAddress(request.ipId)
+              };
+              _context.next = 4;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, IPAccountConfig), {}, {
+                functionName: "execute",
+                args: [this.accessControllerConfig.address, parseToBigInt(0), viem.encodeFunctionData({
+                  abi: this.accessControllerConfig.abi,
+                  functionName: "setPermission",
+                  args: [viem.getAddress(request.ipId),
+                  // 0x Address
+                  viem.getAddress(request.signer),
+                  // 0x Address
+                  viem.getAddress(request.to),
+                  // 0x Address
+                  request.func,
+                  // bytes4
+                  request.permission // uint8
+                  ]
+                })],
+
+                account: this.wallet.account
+              }));
+            case 4:
+              _yield$this$rpcClient = _context.sent;
+              call = _yield$this$rpcClient.request;
+              _context.next = 8;
+              return this.wallet.writeContract(call);
+            case 8:
+              txHash = _context.sent;
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
+                _context.next = 15;
+                break;
+              }
+              _context.next = 12;
+              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.accessControllerConfig), {}, {
+                eventName: "PermissionSet"
+              }));
+            case 12:
+              return _context.abrupt("return", {
+                txHash: txHash,
+                success: true
+              });
+            case 15:
+              return _context.abrupt("return", {
+                txHash: txHash
+              });
+            case 16:
+              _context.next = 21;
+              break;
+            case 18:
+              _context.prev = 18;
+              _context.t0 = _context["catch"](0);
+              handleError(_context.t0, "Failed to set permissions");
+            case 21:
+            case "end":
+              return _context.stop();
           }
-          log = _step.value;
-          _context.prev = 8;
-          return _context.abrupt("return", viem.decodeEventLog({
-            abi: params.abi,
-            eventName: params.eventName,
-            data: log.data,
-            topics: log.topics
-          }));
-        case 12:
-          _context.prev = 12;
-          _context.t0 = _context["catch"](8);
-          return _context.abrupt("continue", 15);
-        case 15:
-          _context.next = 6;
-          break;
-        case 17:
-          _context.next = 22;
-          break;
-        case 19:
-          _context.prev = 19;
-          _context.t1 = _context["catch"](4);
-          _iterator.e(_context.t1);
-        case 22:
-          _context.prev = 22;
-          _iterator.f();
-          return _context.finish(22);
-        case 25:
-          throw new Error("not found event ".concat(params.eventName, " in target transaction"));
-        case 26:
-        case "end":
-          return _context.stop();
+        }, _callee, this, [[0, 18]]);
+      }));
+      function setPermission(_x) {
+        return _setPermission.apply(this, arguments);
       }
-    }, _callee, null, [[4, 19, 22, 25], [8, 12]]);
-  }));
-  return _waitTxAndFilterLog.apply(this, arguments);
-}
-
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
+      return setPermission;
+    }()
+  }]);
+  return PermissionClient;
+}();
 
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
+var LicenseClient = /*#__PURE__*/function () {
+  function LicenseClient(rpcClient, wallet) {
+    _classCallCheck(this, LicenseClient);
+    _defineProperty(this, "ipAccountABI", IPAccountABI);
+    _defineProperty(this, "licenseRegistryConfig", LicenseRegistryConfig);
+    _defineProperty(this, "licensingModuleConfig", LicensingModuleConfig);
+    this.wallet = wallet;
+    this.rpcClient = rpcClient;
+  }
 
-var RegistrationModuleABI = [{
-  inputs: [{
-    internalType: "uint256",
-    name: "licenseId",
-    type: "uint256"
-  }, {
-    internalType: "address",
-    name: "tokenContract",
-    type: "address"
-  }, {
-    internalType: "uint256",
-    name: "tokenId",
-    type: "uint256"
-  }, {
-    internalType: "string",
-    name: "ipName",
-    type: "string"
-  }, {
-    internalType: "string",
-    name: "ipDescription",
-    type: "string"
-  }, {
-    internalType: "bytes32",
-    name: "contentHash",
-    type: "bytes32"
-  }],
-  name: "registerDerivativeIp",
-  outputs: [],
-  stateMutability: "nonpayable",
-  type: "function"
-}, {
-  inputs: [{
-    internalType: "uint256",
-    name: "policyId",
-    type: "uint256"
-  }, {
-    internalType: "address",
-    name: "tokenContract",
-    type: "address"
+  /**
+   * Mints license NFTs representing a policy granted by a set of ipIds (licensors). This NFT needs to be
+   * burned in order to link a derivative IP with its parents. If this is the first combination of policy and
+   * licensors, a new licenseId will be created. If not, the license is fungible and an id will be reused.
+   * @dev Only callable by the licensing module.
+   * @param request The request object containing necessary data to mint a license.
+   *   @param request.policyId The ID of the policy to be minted
+   *   @param request.licensorIpId_ The ID of the IP granting the license (ie. licensor)
+   *   @param request.mintAmount Number of licenses to mint. License NFT is fungible for same policy and same licensors
+   *   @param request.receiver Receiver address of the minted license NFT(s).
+   * @return licenseId The ID of the minted license NFT(s).
+   */
+  _createClass(LicenseClient, [{
+    key: "mintLicense",
+    value: function () {
+      var _mintLicense = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
+        var _request$txOptions, IPAccountConfig, _yield$this$rpcClient, call, txHash, targetLog;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              IPAccountConfig = {
+                abi: this.ipAccountABI,
+                address: viem.getAddress(request.licensorIpId)
+              };
+              _context.next = 4;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, IPAccountConfig), {}, {
+                functionName: "execute",
+                args: [this.licensingModuleConfig.address, parseToBigInt(0), viem.encodeFunctionData({
+                  abi: this.licensingModuleConfig.abi,
+                  functionName: "mintLicense",
+                  args: [parseToBigInt(request.policyId), request.licensorIpId, parseToBigInt(request.mintAmount), viem.getAddress(request.receiverAddress), "0x"]
+                })],
+                account: this.wallet.account
+              }));
+            case 4:
+              _yield$this$rpcClient = _context.sent;
+              call = _yield$this$rpcClient.request;
+              _context.next = 8;
+              return this.wallet.writeContract(call);
+            case 8:
+              txHash = _context.sent;
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
+                _context.next = 16;
+                break;
+              }
+              _context.next = 12;
+              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licenseRegistryConfig), {}, {
+                eventName: "TransferSingle"
+              }));
+            case 12:
+              targetLog = _context.sent;
+              return _context.abrupt("return", {
+                txHash: txHash,
+                licenseId: targetLog.args.id.toString()
+              });
+            case 16:
+              return _context.abrupt("return", {
+                txHash: txHash
+              });
+            case 17:
+              _context.next = 22;
+              break;
+            case 19:
+              _context.prev = 19;
+              _context.t0 = _context["catch"](0);
+              handleError(_context.t0, "Failed to mint license");
+            case 22:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[0, 19]]);
+      }));
+      function mintLicense(_x) {
+        return _mintLicense.apply(this, arguments);
+      }
+      return mintLicense;
+    }()
   }, {
-    internalType: "uint256",
-    name: "tokenId",
-    type: "uint256"
-  }],
-  name: "registerRootIp",
-  outputs: [{
-    internalType: "address",
-    name: "",
-    type: "address"
-  }],
-  stateMutability: "nonpayable",
-  type: "function"
-}];
-
-var errorsJson = [
-	{
-		inputs: [
-		],
-		name: "AccessController__CallerIsNotIPAccount",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "AccessController__IPAccountIsNotValid",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "AccessController__IPAccountIsZeroAddress",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "AccessController__PermissionIsNotValid",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "AccessController__SignerIsZeroAddress",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "ArbitrationPolicySP__NotDisputeModule",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "ArbitrationPolicySP__ZeroDisputeModule",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "ArbitrationPolicySP__ZeroPaymentToken",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "DisputeModule__NotDisputeInitiator",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "DisputeModule__NotWhitelistedArbitrationPolicy",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "DisputeModule__NotWhitelistedArbitrationRelayer",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "DisputeModule__NotWhitelistedDisputeTag",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "DisputeModule__ZeroArbitrationPolicy",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "DisputeModule__ZeroArbitrationRelayer",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "DisputeModule__ZeroDisputeTag",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "DisputeModule__ZeroLinkToDisputeSummary",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "IPRecordRegistry_AlreadyRegistered",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "IPRecordRegistry_IPAccountAlreadyCreated",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "IPRecordRegistry_NotYetRegistered",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "IPRecordRegistry_ResolverInvalid",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "IPRecordRegistry_Unauthorized",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "IPResolver_InvalidIP",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "IPResolver_Unauthorized",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "LicenseRegistry__EmptyLicenseUrl",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "LicenseRegistry__FrameworkNotFound",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "LicenseRegistry__InvalidParamVerifierType",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "LicenseRegistry__LicensorDoesntHaveThisPolicy",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "LicenseRegistry__LinkParentParamFailed",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "LicenseRegistry__MintParamFailed",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "LicenseRegistry__NotLicensee",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "LicenseRegistry__ParamVerifierLengthMismatch",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "LicenseRegistry__ParentIdEqualThanChild",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "LicenseRegistry__PolicyAlreadySetForIpId",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "LicenseRegistry__PolicyNotFound",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "ModuleRegistry__ModuleAddressNotContract",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "ModuleRegistry__ModuleAddressZeroAddress",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "ModuleRegistry__ModuleAlreadyRegistered",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "ModuleRegistry__ModuleNotRegistered",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "ModuleRegistry__NameAlreadyRegistered",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "ModuleRegistry__NameDoesNotMatch",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "ModuleRegistry__NameEmptyString",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "Module_Unauthorized",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "RegistrationModule__InvalidOwner",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "RoyaltyModule__AlreadySetRoyaltyPolicy",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "RoyaltyModule__NotWhitelistedRoyaltyPolicy",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "RoyaltyModule__ZeroRoyaltyPolicy",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "RoyaltyPolicyLS__NotRoyaltyModule",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "RoyaltyPolicyLS__TransferFailed",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "RoyaltyPolicyLS__ZeroLiquidSplitFactory",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "RoyaltyPolicyLS__ZeroLiquidSplitMain",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "RoyaltyPolicyLS__ZeroRoyaltyModule",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "TaggingModule__DstIpIdDoesNotHaveDstTag",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "TaggingModule__InvalidRelationTypeName",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "TaggingModule__RelationTypeAlreadyExists",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "TaggingModule__RelationTypeDoesNotExist",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "TaggingModule__SrcIpIdDoesNotHaveSrcTag",
-		type: "error"
-	}
-];
-
-var ErrorsAbi$2 = errorsJson;
-var storyProtocolMerged = [].concat(_toConsumableArray(RegistrationModuleABI), _toConsumableArray(ErrorsAbi$2));
-var RegistrationModuleConfig = {
-  abi: storyProtocolMerged,
-  address: viem.getAddress(process.env.REGISTRATION_MODULE || process.env.NEXT_PUBLIC_REGISTRATION_MODULE || "")
-};
+    key: "linkIpToParent",
+    value: function () {
+      var _linkIpToParent = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
+        var _request$txOptions2, IPAccountConfig, licenseIds, _yield$this$rpcClient2, call, txHash;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.prev = 0;
+              IPAccountConfig = {
+                abi: this.ipAccountABI,
+                address: viem.getAddress(request.childIpId)
+              };
+              licenseIds = [];
+              request.licenseIds.forEach(function (licenseId) {
+                licenseIds.push(parseToBigInt(licenseId));
+              });
+              _context2.next = 6;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, IPAccountConfig), {}, {
+                functionName: "execute",
+                args: [this.licensingModuleConfig.address, parseToBigInt(0), viem.encodeFunctionData({
+                  abi: this.licensingModuleConfig.abi,
+                  functionName: "linkIpToParents",
+                  args: [licenseIds, viem.getAddress(request.childIpId), "0x"]
+                })],
+                account: this.wallet.account
+              }));
+            case 6:
+              _yield$this$rpcClient2 = _context2.sent;
+              call = _yield$this$rpcClient2.request;
+              _context2.next = 10;
+              return this.wallet.writeContract(call);
+            case 10:
+              txHash = _context2.sent;
+              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
+                _context2.next = 17;
+                break;
+              }
+              _context2.next = 14;
+              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, LicenseRegistryConfig), {}, {
+                eventName: "TransferBatch"
+              }));
+            case 14:
+              return _context2.abrupt("return", {
+                txHash: txHash,
+                success: true
+              });
+            case 17:
+              return _context2.abrupt("return", {
+                txHash: txHash
+              });
+            case 18:
+              _context2.next = 23;
+              break;
+            case 20:
+              _context2.prev = 20;
+              _context2.t0 = _context2["catch"](0);
+              handleError(_context2.t0, "Failed to mint license");
+            case 23:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[0, 20]]);
+      }));
+      function linkIpToParent(_x2) {
+        return _linkIpToParent.apply(this, arguments);
+      }
+      return linkIpToParent;
+    }()
+  }]);
+  return LicenseClient;
+}();
 
-var IPAssetClient = /*#__PURE__*/function (_IPAssetReadOnlyClien) {
-  _inherits(IPAssetClient, _IPAssetReadOnlyClien);
-  var _super = _createSuper(IPAssetClient);
-  function IPAssetClient(httpClient, rpcClient, wallet) {
-    var _this;
-    _classCallCheck(this, IPAssetClient);
-    _this = _super.call(this, httpClient, rpcClient);
-    _this.wallet = wallet;
-    return _this;
+var PolicyClient = /*#__PURE__*/function () {
+  function PolicyClient(rpcClient, wallet) {
+    _classCallCheck(this, PolicyClient);
+    _defineProperty(this, "ipAccountABI", IPAccountABI);
+    _defineProperty(this, "licensingModuleConfig", LicensingModuleConfig);
+    _defineProperty(this, "pilPolicyFrameworkManagerConfig", PILPolicyFrameworkManagerConfig);
+    this.wallet = wallet;
+    this.rpcClient = rpcClient;
   }
 
   /**
-   * Register a root IP on Story Protocol based on the specified input asset data.
-   *
-   * @param request - the request object that contains all data needed to register a root IP.
-   * @returns the response object that contains results from the IP creation.
+   * Registers a PIL policy to the registry
+   * Internally, this function must generate a Licensing.Policy struct and call registerPolicy.
+   * @param request - the licensing parameters for the Programmable IP License v1 (PIL) standard.
+   *   @param request.transferable Whether or not the license is transferable
+   *   @param request.attribution Whether or not attribution is required when reproducing the work
+   *   @param request.commercialUse Whether or not the work can be used commercially
+   *   @param request.commercialAttribution Whether or not attribution is required when reproducing the work commercially
+   *   @param request.commercializerChecker commericializers that are allowed to commercially exploit the work. If zero address, then no restrictions is enforced.
+   *   @param request.commercialRevShare Percentage of revenue that must be shared with the licensor
+   *   @param request.derivativesAllowed Whether or not the licensee can create derivatives of his work
+   *   @param request.derivativesAttribution Whether or not attribution is required for derivatives of the work
+   *   @param request.derivativesApproval Whether or not the licensor must approve derivatives of the work before they can be linked to the licensor IP ID
+   *   @param request.derivativesReciprocal Whether or not the licensee must license derivatives of the work under the same terms.
+   *   @param request.territories List of territories where the license is valid. If empty, global.
+   *   @param request.distributionChannels List of distribution channels where the license is valid. Empty if no restrictions.
+   *   @param request.royaltyPolicy Address of a royalty policy contract (e.g. RoyaltyPolicyLS) that will handle royalty payments
+   * @returns the transaction hash and the policy ID if the txOptions.waitForTransaction is set to true
    */
-  _createClass(IPAssetClient, [{
-    key: "registerRootIp",
+  _createClass(PolicyClient, [{
+    key: "registerPILPolicy",
     value: function () {
-      var _registerRootIp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
+      var _registerPILPolicy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
         var _request$txOptions, _yield$this$rpcClient, call, txHash, targetLog;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               _context.prev = 0;
               _context.next = 3;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, RegistrationModuleConfig), {}, {
-                functionName: "registerRootIp",
-                args: [parseToBigInt(request.policyId), viem.getAddress(request.tokenContractAddress),
-                // 0x Address
-                parseToBigInt(request.tokenId)],
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.pilPolicyFrameworkManagerConfig), {}, {
+                functionName: "registerPolicy",
+                args: [{
+                  transferable: request.transferable,
+                  royaltyPolicy: request.royaltyPolicy || viem.zeroAddress,
+                  mintingFee: parseToBigInt(request.mintingFee || 0),
+                  mintingFeeToken: request.mintingFeeToken || viem.zeroAddress,
+                  policy: {
+                    attribution: request.attribution || false,
+                    commercialUse: request.commercialUse || false,
+                    commercialAttribution: request.commercialAttribution || false,
+                    commercialRevShare: request.commercialRevShare || 0,
+                    derivativesAllowed: request.derivativesAllowed || false,
+                    derivativesAttribution: request.commercialAttribution || false,
+                    derivativesApproval: request.derivativesApproval || false,
+                    derivativesReciprocal: request.derivativesReciprocal || false,
+                    commercializerChecker: request.commercializerChecker || viem.zeroAddress,
+                    commercializerCheckerData: request.commercializerCheckerData || "0x",
+                    territories: request.territories || [],
+                    distributionChannels: request.distributionChannels || [],
+                    contentRestrictions: request.contentRestrictions || []
+                  }
+                }],
                 account: this.wallet.account
               }));
             case 3:
@@ -1762,14 +2722,14 @@ var IPAssetClient = /*#__PURE__*/function (_IPAssetReadOnlyClien) {
                 break;
               }
               _context.next = 11;
-              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, IPAccountRegistryConfig), {}, {
-                eventName: "IPAccountRegistered"
+              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
+                eventName: "PolicyRegistered"
               }));
             case 11:
               targetLog = _context.sent;
               return _context.abrupt("return", {
                 txHash: txHash,
-                ipAccountId: targetLog === null || targetLog === void 0 ? void 0 : targetLog.args.account.toString()
+                policyId: targetLog === null || targetLog === void 0 ? void 0 : targetLog.args.policyId.toString()
               });
             case 15:
               return _context.abrupt("return", {
@@ -1781,398 +2741,359 @@ var IPAssetClient = /*#__PURE__*/function (_IPAssetReadOnlyClien) {
             case 18:
               _context.prev = 18;
               _context.t0 = _context["catch"](0);
-              handleError(_context.t0, "Failed to register root IP");
+              handleError(_context.t0, "Failed to register policy");
             case 21:
             case "end":
               return _context.stop();
           }
         }, _callee, this, [[0, 18]]);
       }));
-      function registerRootIp(_x) {
-        return _registerRootIp.apply(this, arguments);
+      function registerPILPolicy(_x) {
+        return _registerPILPolicy.apply(this, arguments);
       }
-      return registerRootIp;
+      return registerPILPolicy;
     }()
     /**
-     * Register a derivative IP on Story Protocol based on the specified input asset data.
-     *
-     * @param request - the request object that contains all data needed to register a derivative IP.
-     * @returns the response object that contains results from the IP creation.
+     * Adds a policy to the set of policies of an IP
+     * @param request The request object containing details to add a policy to an IP
+     *   @param request.ipId The id of the IP
+     *   @param request.polId The id of the policy
+     * @return the transaction hash and the index of the policy in the IP's policy set if the txOptions.waitForTransaction is set to true
      */
   }, {
-    key: "registerDerivativeIp",
+    key: "addPolicyToIp",
     value: function () {
-      var _registerDerivativeIp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var _request$txOptions2, _yield$this$rpcClient2, call, txHash, targetLog;
+      var _addPolicyToIp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
+        var _request$txOptions2, IPAccountConfig, _yield$this$rpcClient2, call, txHash, targetLog;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
               _context2.prev = 0;
-              _context2.next = 3;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, RegistrationModuleConfig), {}, {
-                functionName: "registerDerivativeIp",
-                args: [parseToBigInt(request.licenseId), viem.getAddress(request.tokenContractAddress),
-                // 0x Address
-                parseToBigInt(request.tokenId), request.ipName, request.ipDescription, viem.getAddress(request.hash) // Byte32
-                ]
+              IPAccountConfig = {
+                abi: this.ipAccountABI,
+                address: viem.getAddress(request.ipId)
+              };
+              _context2.next = 4;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, IPAccountConfig), {}, {
+                functionName: "execute",
+                args: [this.licensingModuleConfig.address, parseToBigInt(0), viem.encodeFunctionData({
+                  abi: this.licensingModuleConfig.abi,
+                  functionName: "addPolicyToIp",
+                  args: [viem.getAddress(request.ipId), parseToBigInt(request.policyId)]
+                })],
+                account: this.wallet.account
               }));
-            case 3:
+            case 4:
               _yield$this$rpcClient2 = _context2.sent;
               call = _yield$this$rpcClient2.request;
-              _context2.next = 7;
+              _context2.next = 8;
               return this.wallet.writeContract(call);
-            case 7:
+            case 8:
               txHash = _context2.sent;
               if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
-                _context2.next = 15;
+                _context2.next = 16;
                 break;
               }
-              _context2.next = 11;
-              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, IPAccountRegistryConfig), {}, {
-                eventName: "IPAccountRegistered"
+              _context2.next = 12;
+              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.licensingModuleConfig), {}, {
+                eventName: "PolicyAddedToIpId"
               }));
-            case 11:
+            case 12:
               targetLog = _context2.sent;
               return _context2.abrupt("return", {
                 txHash: txHash,
-                ipAccountId: targetLog === null || targetLog === void 0 ? void 0 : targetLog.args.account.toString()
+                index: targetLog.args.index.toString()
               });
-            case 15:
+            case 16:
               return _context2.abrupt("return", {
                 txHash: txHash
               });
-            case 16:
-              _context2.next = 21;
+            case 17:
+              _context2.next = 22;
               break;
-            case 18:
-              _context2.prev = 18;
+            case 19:
+              _context2.prev = 19;
               _context2.t0 = _context2["catch"](0);
-              handleError(_context2.t0, "Failed to register derivative IP");
-            case 21:
+              handleError(_context2.t0, "Failed to add policy to IP");
+            case 22:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this, [[0, 18]]);
+        }, _callee2, this, [[0, 19]]);
       }));
-      function registerDerivativeIp(_x2) {
-        return _registerDerivativeIp.apply(this, arguments);
+      function addPolicyToIp(_x2) {
+        return _addPolicyToIp.apply(this, arguments);
       }
-      return registerDerivativeIp;
-    }() // TODO: move to License resource
-    // public async createPolicy(request: addPolicyRequest): Promise<addPolicyResponse> {
-    //   try {
-    //     const { request: call } = await this.rpcClient.simulateContract({
-    //       ...LicenseRegistryConfig,
-    //       functionName: "addPolicy",
-    //       args: [
-    //         {
-    //           frameworkId: parseToBigInt(request.frameworkId),
-    //           mintingParamValues: request.mintingParamValues.map((add) => getAddress(add)),
-    //           activationParamValues: request.activationParamValues.map((add) => getAddress(add)),
-    //           needsActivation: request.needsActivation,
-    //           linkParentParamValues: request.linkParentParamValues.map((add) => getAddress(add)),
-    //         },
-    //       ], // TODO: add args
-    //     });
-    //     const txHash = await this.wallet.writeContract(call);
-    //     // TODO: need an emitted event
-    //     // if (request.txOptions?.waitForTransaction) {
-    //     //   const targetLog = await waitTxAndFilterLog(this.rpcClient, txHash, {
-    //     //     ...IPAccountRegistryConfig,
-    //     //     eventName: "IPAccountRegistered",
-    //     //   });
-    //     //   return { txHash: txHash, policyId: targetLog?.args.account.toString() };
-    //     // } else {
-    //     return { txHash: txHash };
-    //     // }
-    //   } catch (error) {
-    //     handleError(error, "Failed to register derivative IP");
-    //   }
-    // }
-    // TODO: move to License resource
-    // public async addPolicyToIp(request: addPolicyToIpRequest): Promise<addPolicyToIpResponse> {
-    // TODO: use getIpAccount to get the ipId
-    // }
+      return addPolicyToIp;
+    }()
   }]);
-  return IPAssetClient;
-}(IPAssetReadOnlyClient);
-
-// import { isIntegerString } from "../utils/utils";
+  return PolicyClient;
+}();
 
-/**
- * IPAssetReadOnlyClient allows you to view and search IP Assets on Story Protocol.
- */
-var PermissionReadOnlyClient = /*#__PURE__*/function () {
-  function PermissionReadOnlyClient(httpClient, rpcClient) {
-    _classCallCheck(this, PermissionReadOnlyClient);
-    this.httpClient = httpClient;
+var DisputeClient = /*#__PURE__*/function () {
+  function DisputeClient(rpcClient, wallet) {
+    _classCallCheck(this, DisputeClient);
+    _defineProperty(this, "disputeModuleConfig", DisputeModuleConfig);
     this.rpcClient = rpcClient;
+    this.wallet = wallet;
   }
 
   /**
-   * Get permission based on based on the specified IP id.
-   *
-   * @param request - the request object for getting an IP Asset.
-   * @returns the response object the contains the fetched IP Asset.
+   * Raises a dispute on a given ipId
+   * @param request - The request object containing necessary data to raise a dispute.
+   *   @param request.targetIpId - The IP ID that is the target of the dispute.
+   *   @param request.arbitrationPolicy - The address of the arbitration policy.
+   *   @param request.linkToDisputeEvidence - The link to the dispute evidence.
+   *   @param request.targetTag - The target tag of the dispute.
+   *   @param request.calldata - Optional calldata to initialize the policy.
+   *   @param request.txOptions - Optional transaction options.
+   * @returns A Promise that resolves to a RaiseDisputeResponse containing the transaction hash.
+   * @throws `NotRegisteredIpId` if targetIpId is not registered in the IPA Registry.
+   * @throws `NotWhitelistedDisputeTag` if targetTag is not whitelisted.
+   * @throws `ZeroLinkToDisputeEvidence` if linkToDisputeEvidence is empty
+   * @calls raiseDispute(address _targetIpId, string memory _linkToDisputeEvidence, bytes32 _targetTag, bytes calldata _data) external nonReentrant returns (uint256) {
+   * @emits DisputeRaised (disputeId_, targetIpId, msg.sender, arbitrationPolicy, linkToDisputeEvidence, targetTag, calldata);
    */
-  _createClass(PermissionReadOnlyClient, [{
-    key: "get",
+  _createClass(DisputeClient, [{
+    key: "raiseDispute",
     value: function () {
-      var _get = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var response;
+      var _raiseDispute = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
+        var _request$txOptions, _yield$this$rpcClient, call, txHash, logs;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               _context.prev = 0;
               _context.next = 3;
-              return this.httpClient.get("/permissions/".concat(request.permissionId));
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.disputeModuleConfig), {}, {
+                functionName: "raiseDispute",
+                args: [request.targetIpId, request.linkToDisputeEvidence, viem.stringToHex(request.targetTag, {
+                  size: 32
+                }), request.calldata || "0x"]
+              }));
+            case 3:
+              _yield$this$rpcClient = _context.sent;
+              call = _yield$this$rpcClient.request;
+              _context.next = 7;
+              return this.wallet.writeContract(call);
+            case 7:
+              txHash = _context.sent;
+              if (!((_request$txOptions = request.txOptions) !== null && _request$txOptions !== void 0 && _request$txOptions.waitForTransaction)) {
+                _context.next = 13;
+                break;
+              }
+              _context.next = 11;
+              return waitTxAndFilterLog(this.rpcClient, txHash, _objectSpread2(_objectSpread2({}, this.disputeModuleConfig), {}, {
+                eventName: "DisputeRaised"
+              }));
+            case 11:
+              logs = _context.sent;
+              return _context.abrupt("return", {
+                txHash: txHash,
+                disputeId: BigInt(logs.args.disputeId).toString()
+              });
+            case 13:
+              return _context.abrupt("return", {
+                txHash: txHash
+              });
+            case 16:
+              _context.prev = 16;
+              _context.t0 = _context["catch"](0);
+              handleError(_context.t0, "Failed to raise dispute");
+            case 19:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[0, 16]]);
+      }));
+      function raiseDispute(_x) {
+        return _raiseDispute.apply(this, arguments);
+      }
+      return raiseDispute;
+    }()
+    /**
+     * Cancels an ongoing dispute
+     * @param request The request object containing details to cancel the dispute.
+     *   @param request.disputeId The ID of the dispute to be cancelled.
+     *   @param request.calldata Optional additional data used in the cancellation process.
+     * @returns A Promise that resolves to a CancelDisputeResponse containing the transaction hash.
+     * @throws NotInDisputeState, if the currentTag of the Dispute is not being disputed
+     * @throws NotDisputeInitiator, if the transaction executor is not the one that initiated the dispute
+     * @throws error if the Dispute's ArbitrationPolicy contract is not valid
+     * @calls cancelDispute(uint256 _disputeId, bytes calldata _data) external nonReentrant {
+     * @emits DisputeCancelled (_disputeId, _data);
+     */
+  }, {
+    key: "cancelDispute",
+    value: function () {
+      var _cancelDispute = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
+        var _request$txOptions2, _yield$this$rpcClient2, call, txHash;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.prev = 0;
+              _context2.next = 3;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.disputeModuleConfig), {}, {
+                functionName: "cancelDispute",
+                args: [BigInt(request.disputeId), request.calldata ? request.calldata : "0x"]
+              }));
             case 3:
-              response = _context.sent;
-              return _context.abrupt("return", response.data);
+              _yield$this$rpcClient2 = _context2.sent;
+              call = _yield$this$rpcClient2.request;
+              _context2.next = 7;
+              return this.wallet.writeContract(call);
             case 7:
-              _context.prev = 7;
-              _context.t0 = _context["catch"](0);
-              handleError(_context.t0, "Failed to get IP account");
-            case 10:
+              txHash = _context2.sent;
+              if (!((_request$txOptions2 = request.txOptions) !== null && _request$txOptions2 !== void 0 && _request$txOptions2.waitForTransaction)) {
+                _context2.next = 11;
+                break;
+              }
+              _context2.next = 11;
+              return waitTx(this.rpcClient, txHash);
+            case 11:
+              return _context2.abrupt("return", {
+                txHash: txHash
+              });
+            case 14:
+              _context2.prev = 14;
+              _context2.t0 = _context2["catch"](0);
+              handleError(_context2.t0, "Failed to cancel dispute");
+            case 17:
             case "end":
-              return _context.stop();
+              return _context2.stop();
           }
-        }, _callee, this, [[0, 7]]);
+        }, _callee2, this, [[0, 14]]);
       }));
-      function get(_x) {
-        return _get.apply(this, arguments);
+      function cancelDispute(_x2) {
+        return _cancelDispute.apply(this, arguments);
       }
-      return get;
+      return cancelDispute;
     }()
     /**
-     * List IP accounts.
-     *
-     * @returns the response object that contains results from listing query.
+     * Resolves a dispute after it has been judged
+     * @param request The request object containing details to resolve the dispute.
+     *   @param request.disputeId The ID of the dispute to be resolved.
+     * @returns A Promise that resolves to a ResolveDisputeResponse.
+     * @throws NotAbleToResolve, if currentTag is still in dispute (i.e still needs a judgement to be set)
+     * @throws NotDisputeInitiator, if the transaction executor is not the one that initiated the dispute
+     * @emits DisputeResolved (_disputeId)
      */
   }, {
-    key: "list",
+    key: "resolveDispute",
     value: function () {
-      var _list = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(request) {
-        var response;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
+      var _resolveDispute = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(request) {
+        var _request$txOptions3, _yield$this$rpcClient3, call, txHash;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
             case 0:
-              _context2.prev = 0;
-              _context2.next = 3;
-              return this.httpClient.post("/permissions", request || {});
+              _context3.prev = 0;
+              _context3.next = 3;
+              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, this.disputeModuleConfig), {}, {
+                functionName: "resolveDispute",
+                args: [BigInt(request.disputeId)]
+              }));
             case 3:
-              response = _context2.sent;
-              return _context2.abrupt("return", response.data);
+              _yield$this$rpcClient3 = _context3.sent;
+              call = _yield$this$rpcClient3.request;
+              _context3.next = 7;
+              return this.wallet.writeContract(call);
             case 7:
-              _context2.prev = 7;
-              _context2.t0 = _context2["catch"](0);
-              handleError(_context2.t0, "Failed to list IP Asset.");
-            case 10:
+              txHash = _context3.sent;
+              if (!((_request$txOptions3 = request.txOptions) !== null && _request$txOptions3 !== void 0 && _request$txOptions3.waitForTransaction)) {
+                _context3.next = 11;
+                break;
+              }
+              _context3.next = 11;
+              return waitTx(this.rpcClient, txHash);
+            case 11:
+              return _context3.abrupt("return", {
+                txHash: txHash
+              });
+            case 14:
+              _context3.prev = 14;
+              _context3.t0 = _context3["catch"](0);
+              handleError(_context3.t0, "Failed to cancel dispute");
+            case 17:
             case "end":
-              return _context2.stop();
+              return _context3.stop();
           }
-        }, _callee2, this, [[0, 7]]);
+        }, _callee3, this, [[0, 14]]);
       }));
-      function list(_x2) {
-        return _list.apply(this, arguments);
+      function resolveDispute(_x3) {
+        return _resolveDispute.apply(this, arguments);
       }
-      return list;
+      return resolveDispute;
     }()
   }]);
-  return PermissionReadOnlyClient;
+  return DisputeClient;
 }();
 
-var IPAccountImplABI = [{
-  inputs: [{
-    internalType: "address",
-    name: "to_",
-    type: "address"
-  }, {
-    internalType: "uint256",
-    name: "value_",
-    type: "uint256"
-  }, {
-    internalType: "bytes",
-    name: "data_",
-    type: "bytes"
-  }],
-  name: "execute",
-  outputs: [{
-    internalType: "bytes",
-    name: "result",
-    type: "bytes"
-  }],
-  stateMutability: "payable",
-  type: "function"
-}, {
-  inputs: [{
-    internalType: "address",
-    name: "signer_",
-    type: "address"
-  }, {
-    internalType: "bytes",
-    name: "data_",
-    type: "bytes"
-  }],
-  name: "isValidSigner",
-  outputs: [{
-    internalType: "bytes4",
-    name: "",
-    type: "bytes4"
-  }],
-  stateMutability: "view",
-  type: "function"
-}];
-
-var ErrorsAbi$1 = errorsJson;
-var IPAccountImplMerged = [].concat(_toConsumableArray(IPAccountImplABI), _toConsumableArray(ErrorsAbi$1));
-
-var AccessControllerABI = [{
-  inputs: [{
-    internalType: "address",
-    name: "ipAccount_",
-    type: "address"
-  }, {
-    internalType: "address",
-    name: "signer_",
-    type: "address"
-  }, {
-    internalType: "address",
-    name: "to_",
-    type: "address"
-  }, {
-    internalType: "bytes4",
-    name: "func_",
-    type: "bytes4"
-  }, {
-    internalType: "uint8",
-    name: "permission_",
-    type: "uint8"
-  }],
-  name: "setPermission",
-  outputs: [],
-  stateMutability: "nonpayable",
-  type: "function"
-}, {
-  anonymous: false,
-  inputs: [{
-    indexed: true,
-    internalType: "address",
-    name: "ipAccount",
-    type: "address"
-  }, {
-    indexed: true,
-    internalType: "address",
-    name: "signer",
-    type: "address"
-  }, {
-    indexed: true,
-    internalType: "address",
-    name: "to",
-    type: "address"
-  }, {
-    indexed: false,
-    internalType: "bytes4",
-    name: "func",
-    type: "bytes4"
-  }, {
-    indexed: false,
-    internalType: "uint8",
-    name: "permission",
-    type: "uint8"
-  }],
-  name: "PermissionSet",
-  type: "event"
-}];
-
-var ErrorsAbi = errorsJson;
-var AccessControllerABImerged = [].concat(_toConsumableArray(AccessControllerABI), _toConsumableArray(ErrorsAbi));
-({
-  abi: AccessControllerABImerged,
-  address: viem.getAddress(process.env.ACCESS_CONTROLLER || process.env.NEXT_PUBLIC_ACCESS_CONTROLLER || "")
-});
-
-// import { HashZero } from "../constants/common";
-
-var PermissionClient = /*#__PURE__*/function (_PermissionReadOnlyCl) {
-  _inherits(PermissionClient, _PermissionReadOnlyCl);
-  var _super = _createSuper(PermissionClient);
-  function PermissionClient(httpClient, rpcClient, wallet) {
-    var _this;
-    _classCallCheck(this, PermissionClient);
-    _this = _super.call(this, httpClient, rpcClient);
-    _this.wallet = wallet;
-    return _this;
+var PlatformClient = /*#__PURE__*/function () {
+  function PlatformClient(httpClient) {
+    _classCallCheck(this, PlatformClient);
+    this.httpClient = httpClient;
   }
 
   /**
-   * Set Permission based on the specified input
+   * Upload a file to Arweave.
    *
-   * @param request - the request object that contains all data needed to set permission.
-   * @returns the response object that contains results from the set permission.
+   * @param file - the file binary data to upload
+   * @param mimeType - the mime type of the file
+   * @returns the response object that contains the uri of the uploaded file
    */
-  _createClass(PermissionClient, [{
-    key: "setPermission",
+  _createClass(PlatformClient, [{
+    key: "uploadFile",
     value: function () {
-      var _setPermission = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(request) {
-        var IPAccountConfig, accessController, _yield$this$rpcClient, call, txHash;
+      var _uploadFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(file, mimeType) {
+        var preSignUrlResp, data, uploadResp, confirmResp;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               _context.prev = 0;
-              IPAccountConfig = {
-                abi: IPAccountImplMerged,
-                address: viem.getAddress(request.ipAsset)
-              };
-              accessController = viem.getAddress(process.env.ACCESS_CONTROLLER || process.env.NEXT_PUBLIC_ACCESS_CONTROLLER || ""); //to
-              _context.next = 5;
-              return this.rpcClient.simulateContract(_objectSpread2(_objectSpread2({}, IPAccountConfig), {}, {
-                functionName: "execute",
-                args: [accessController, 0, viem.encodeFunctionData({
-                  abi: AccessControllerABImerged,
-                  functionName: "setPermission",
-                  args: [viem.getAddress(request.ipAsset),
-                  // 0x Address
-                  viem.getAddress(request.signer),
-                  // 0x Address
-                  viem.getAddress(request.to),
-                  // 0x Address
-                  request.func,
-                  // bytes4
-                  request.permission // uint8
-                  ]
-                })],
-
-                account: this.wallet.account
-              }));
-            case 5:
-              _yield$this$rpcClient = _context.sent;
-              call = _yield$this$rpcClient.request;
-              _context.next = 9;
-              return this.wallet.writeContract(call);
-            case 9:
-              txHash = _context.sent;
-              return _context.abrupt("return", {
-                txHash: txHash
+              _context.next = 3;
+              return this.httpClient.post("/platform/file-upload/request");
+            case 3:
+              preSignUrlResp = _context.sent;
+              data = preSignUrlResp.data; // upload the file to s3
+              _context.next = 7;
+              return this.httpClient.put(data.url, file, {
+                timeout: 0,
+                headers: {
+                  "Content-Type": mimeType
+                }
               });
-            case 13:
-              _context.prev = 13;
-              _context.t0 = _context["catch"](0);
-              handleError(_context.t0, "Failed to set permissions");
+            case 7:
+              uploadResp = _context.sent;
+              if (!(uploadResp.status !== 200)) {
+                _context.next = 10;
+                break;
+              }
+              throw new Error("Failed to upload file to s3. Status: ".concat(uploadResp.status));
+            case 10:
+              _context.next = 12;
+              return this.httpClient.post("/platform/file-upload/confirm", {
+                key: data.key
+              });
+            case 12:
+              confirmResp = _context.sent;
+              return _context.abrupt("return", confirmResp.data);
             case 16:
+              _context.prev = 16;
+              _context.t0 = _context["catch"](0);
+              return _context.abrupt("return", handleError(_context.t0, "Failed to upload file"));
+            case 19:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[0, 13]]);
+        }, _callee, this, [[0, 16]]);
       }));
-      function setPermission(_x) {
-        return _setPermission.apply(this, arguments);
+      function uploadFile(_x, _x2) {
+        return _uploadFile.apply(this, arguments);
       }
-      return setPermission;
+      return uploadFile;
     }()
   }]);
-  return PermissionClient;
-}(PermissionReadOnlyClient);
+  return PlatformClient;
+}();
 
 if (typeof process !== "undefined") {
   dotenv__namespace.config();
@@ -2183,53 +3104,51 @@ if (typeof process !== "undefined") {
 var StoryClient = /*#__PURE__*/function () {
   /**
    * @param config - the configuration for the SDK client
-   * @param isReadOnly
    */
   function StoryClient(config) {
-    var isReadOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     _classCallCheck(this, StoryClient);
-    _defineProperty(this, "isReadOnly", false);
     _defineProperty(this, "_ipAccount", null);
     _defineProperty(this, "_permission", null);
-    _defineProperty(this, "_transaction", null);
+    _defineProperty(this, "_license", null);
+    _defineProperty(this, "_policy", null);
     _defineProperty(this, "_platform", null);
-    _defineProperty(this, "_module", null);
     _defineProperty(this, "_tagging", null);
+    _defineProperty(this, "_dispute", null);
     this.config = config;
-    this.isReadOnly = isReadOnly;
-    var clientConfig = {
-      chain: this.config.chain || chains.sepolia,
-      transport: this.config.transport || viem.http(process.env.RPC_PROVIDER_URL)
-    };
-    this.rpcClient = viem.createPublicClient(clientConfig);
-    if (!isReadOnly) {
-      var account = this.config.account;
-      if (!account) {
-        throw new Error("account is null");
-      }
-      this.wallet = viem.createWalletClient(_objectSpread2(_objectSpread2({}, clientConfig), {}, {
-        account: account
-      }));
+    if (!this.config.transport) {
+      throw new Error("transport is null, please pass in a valid RPC Provider URL as the transport.");
     }
     this.httpClient = axios__default["default"].create({
-      baseURL: process.env.API_BASE_URL || process.env.NEXT_PUBLIC_API_BASE_URL,
-      timeout: HTTP_TIMEOUT,
+      baseURL: "https://stag.api.storyprotocol.net",
+      timeout: 5000,
       headers: {
         version: "v0-alpha"
       }
     });
+    var clientConfig = {
+      chain: chainStringToViemChain(this.config.chainId || "sepolia"),
+      transport: this.config.transport
+    };
+    this.rpcClient = viem.createPublicClient(clientConfig);
+    var account = this.config.account;
+    if (!account) {
+      throw new Error("account is null");
+    }
+    this.wallet = viem.createWalletClient(_objectSpread2(_objectSpread2({}, clientConfig), {}, {
+      account: account
+    }));
   }
 
   /**
-   * Factory method for creating a read only SDK client.
+   * Factory method for creating a SDK client with a signer.
    *
-   * @param config - the configuration for a read only SDK client
+   * @param config - the configuration for a new SDK client
    */
   _createClass(StoryClient, [{
     key: "ipAsset",
     get: function get() {
       if (this._ipAccount === null) {
-        this._ipAccount = this.isReadOnly ? new IPAssetReadOnlyClient(this.httpClient, this.rpcClient) : new IPAssetClient(this.httpClient, this.rpcClient, this.wallet);
+        this._ipAccount = new IPAssetClient(this.rpcClient, this.wallet);
       }
       return this._ipAccount;
     }
@@ -2237,131 +3156,87 @@ var StoryClient = /*#__PURE__*/function () {
     key: "permission",
     get: function get() {
       if (this._permission === null) {
-        this._permission = this.isReadOnly ? new PermissionReadOnlyClient(this.httpClient, this.rpcClient) : new PermissionClient(this.httpClient, this.rpcClient, this.wallet);
+        this._permission = new PermissionClient(this.rpcClient, this.wallet);
       }
       return this._permission;
     }
-
-    /**
-     * Getter for the transaction client. The client is lazily created when
-     * this method is called.
-     *
-     * @returns the TransactionReadOnlyClient or TransactionClient instance
-     */
   }, {
-    key: "transaction",
+    key: "license",
+    get: function get() {
+      if (this._license === null) {
+        this._license = new LicenseClient(this.rpcClient, this.wallet);
+      }
+      return this._license;
+    }
+  }, {
+    key: "policy",
     get: function get() {
-      if (this._transaction === null) {
-        this._transaction = this.isReadOnly ? new TransactionReadOnlyClient(this.httpClient, this.rpcClient) : new TransactionClient(this.httpClient, this.rpcClient, this.wallet);
+      if (this._policy === null) {
+        this._policy = new PolicyClient(this.rpcClient, this.wallet);
       }
-      return this._transaction;
+      return this._policy;
     }
 
     /**
      * Getter for the tagging client. The client is lazily created when
      * this method is called.
      *
-     * @returns the TaggingReadOnlyClient or TaggingClient instance
+     * @returns the TaggingClient instance
      */
   }, {
     key: "tagging",
     get: function get() {
       if (this._tagging === null) {
-        this._tagging = this.isReadOnly ? new TaggingReadOnlyClient(this.httpClient, this.rpcClient) : new TaggingClient(this.httpClient, this.rpcClient, this.wallet);
+        this._tagging = new TaggingClient(this.rpcClient, this.wallet);
       }
       return this._tagging;
     }
 
     /**
-     * Getter for the platform client. The client is lazily created when
+     * Getter for the dispute client. The client is lazily created when
      * this method is called.
      *
-     * @returns the PlatformClient instance
+     * @returns the DisputeClient instance
      */
   }, {
-    key: "platform",
+    key: "dispute",
     get: function get() {
-      if (this._platform === null) {
-        this._platform = new PlatformClient(this.httpClient);
+      if (this._dispute === null) {
+        this._dispute = new DisputeClient(this.rpcClient, this.wallet);
       }
-      return this._platform;
+      return this._dispute;
     }
 
     /**
-     * Getter for the module client. The client is lazily created when
+     * Getter for the platform client. The client is lazily created when
      * this method is called.
      *
-     * @returns the Module instance
+     * @returns the PlatformClient instance
      */
   }, {
-    key: "module",
+    key: "platform",
     get: function get() {
-      if (this._module === null) {
-        this._module = new ModuleReadOnlyClient(this.httpClient, this.rpcClient);
+      if (this._platform === null) {
+        this._platform = new PlatformClient(this.httpClient);
       }
-      return this._module;
+      return this._platform;
     }
   }], [{
-    key: "newReadOnlyClient",
-    value: function newReadOnlyClient(config) {
-      return new StoryClient(config, true);
-    }
-
-    /**
-     * Factory method for creating a SDK client with a signer.
-     *
-     * @param config - the configuration for a new read/write SDK client
-     */
-  }, {
     key: "newClient",
     value: function newClient(config) {
-      return new StoryClient(config, false);
+      return new StoryClient(config);
     }
   }]);
   return StoryClient;
 }();
 
-/**
- * @public
- */
-var ResourceType = /*#__PURE__*/function (ResourceType) {
-  ResourceType["Unspecified"] = "Unspecified";
-  ResourceType["IPOrg"] = "IPOrg";
-  ResourceType["IPAsset"] = "IPAsset";
-  ResourceType["License"] = "License";
-  ResourceType["Relationship"] = "Relationship";
-  ResourceType["RelationshipType"] = "RelationshipType";
-  ResourceType["Module"] = "Module";
-  ResourceType["Hook"] = "Hook";
-  ResourceType["Dispute"] = "Dispute";
-  return ResourceType;
-}({});
-
-/**
- * @public
- */
-var ActionType = /*#__PURE__*/function (ActionType) {
-  ActionType["Unspecified"] = "Unspecified";
-  ActionType["Register"] = "Register";
-  ActionType["Unregister"] = "Unregister";
-  ActionType["Configure"] = "Configure";
-  ActionType["Create"] = "Create";
-  return ActionType;
-}({});
-
-var AddressZero = "0x0000000000000000000000000000000000000000";
-var HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
-
-exports.ActionType = ActionType;
 exports.AddressZero = AddressZero;
+exports.DisputeClient = DisputeClient;
 exports.HashZero = HashZero;
 exports.IPAssetClient = IPAssetClient;
-exports.IPAssetReadOnlyClient = IPAssetReadOnlyClient;
-exports.ModuleReadOnlyClient = ModuleReadOnlyClient;
+exports.LicenseClient = LicenseClient;
 exports.PermissionClient = PermissionClient;
-exports.PermissionReadOnlyClient = PermissionReadOnlyClient;
 exports.PlatformClient = PlatformClient;
-exports.ResourceType = ResourceType;
+exports.PolicyClient = PolicyClient;
 exports.StoryClient = StoryClient;
-exports.TaggingReadOnlyClient = TaggingReadOnlyClient;
-exports.TransactionClient = TransactionClient;
+exports.TaggingClient = TaggingClient;