nftychat-universe 0.1.0

package/dist/index.cjs.js

@@ -0,0 +1,836 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var rainbowkit = require('@rainbow-me/rainbowkit');
+require('@rainbow-me/rainbowkit/styles.css');
+var toast = require('react-hot-toast');
+var wagmi = require('wagmi');
+var _public = require('wagmi/providers/public');
+var react = require('@iconify/react');
+var Popover = require('@mui/material/Popover');
+var css = require('@emotion/css');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var toast__default = /*#__PURE__*/_interopDefaultLegacy(toast);
+var Popover__default = /*#__PURE__*/_interopDefaultLegacy(Popover);
+
+function _regeneratorRuntime() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+
+  _regeneratorRuntime = function () {
+    return exports;
+  };
+
+  var exports = {},
+      Op = Object.prototype,
+      hasOwn = Op.hasOwnProperty,
+      $Symbol = "function" == typeof Symbol ? Symbol : {},
+      iteratorSymbol = $Symbol.iterator || "@@iterator",
+      asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+      toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+  function define(obj, key, value) {
+    return Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), obj[key];
+  }
+
+  try {
+    define({}, "");
+  } catch (err) {
+    define = function (obj, key, value) {
+      return obj[key] = value;
+    };
+  }
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+        generator = Object.create(protoGenerator.prototype),
+        context = new Context(tryLocsList || []);
+    return generator._invoke = function (innerFn, self, context) {
+      var state = "suspendedStart";
+      return function (method, arg) {
+        if ("executing" === state) throw new Error("Generator is already running");
+
+        if ("completed" === state) {
+          if ("throw" === method) throw arg;
+          return doneResult();
+        }
+
+        for (context.method = method, context.arg = arg;;) {
+          var delegate = context.delegate;
+
+          if (delegate) {
+            var delegateResult = maybeInvokeDelegate(delegate, context);
+
+            if (delegateResult) {
+              if (delegateResult === ContinueSentinel) continue;
+              return delegateResult;
+            }
+          }
+
+          if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+            if ("suspendedStart" === state) throw state = "completed", context.arg;
+            context.dispatchException(context.arg);
+          } else "return" === context.method && context.abrupt("return", context.arg);
+          state = "executing";
+          var record = tryCatch(innerFn, self, context);
+
+          if ("normal" === record.type) {
+            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+            return {
+              value: record.arg,
+              done: context.done
+            };
+          }
+
+          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+        }
+      };
+    }(innerFn, self, context), generator;
+  }
+
+  function tryCatch(fn, obj, arg) {
+    try {
+      return {
+        type: "normal",
+        arg: fn.call(obj, arg)
+      };
+    } catch (err) {
+      return {
+        type: "throw",
+        arg: err
+      };
+    }
+  }
+
+  exports.wrap = wrap;
+  var ContinueSentinel = {};
+
+  function Generator() {}
+
+  function GeneratorFunction() {}
+
+  function GeneratorFunctionPrototype() {}
+
+  var IteratorPrototype = {};
+  define(IteratorPrototype, iteratorSymbol, function () {
+    return this;
+  });
+  var getProto = Object.getPrototypeOf,
+      NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      define(prototype, method, function (arg) {
+        return this._invoke(method, arg);
+      });
+    });
+  }
+
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+
+      if ("throw" !== record.type) {
+        var result = record.arg,
+            value = result.value;
+        return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+          invoke("next", value, resolve, reject);
+        }, function (err) {
+          invoke("throw", err, resolve, reject);
+        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+          result.value = unwrapped, resolve(result);
+        }, function (error) {
+          return invoke("throw", error, resolve, reject);
+        });
+      }
+
+      reject(record.arg);
+    }
+
+    var previousPromise;
+
+    this._invoke = function (method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new PromiseImpl(function (resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
+
+      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    };
+  }
+
+  function maybeInvokeDelegate(delegate, context) {
+    var method = delegate.iterator[context.method];
+
+    if (undefined === method) {
+      if (context.delegate = null, "throw" === context.method) {
+        if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
+        context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
+      }
+
+      return ContinueSentinel;
+    }
+
+    var record = tryCatch(method, delegate.iterator, context.arg);
+    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+    var info = record.arg;
+    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+  }
+
+  function pushTryEntry(locs) {
+    var entry = {
+      tryLoc: locs[0]
+    };
+    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal", delete record.arg, entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+  }
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) return iteratorMethod.call(iterable);
+      if ("function" == typeof iterable.next) return iterable;
+
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+            next = function next() {
+          for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+
+          return next.value = undefined, next.done = !0, next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    return {
+      next: doneResult
+    };
+  }
+
+  function doneResult() {
+    return {
+      value: undefined,
+      done: !0
+    };
+  }
+
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+    var ctor = "function" == typeof genFun && genFun.constructor;
+    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+  }, exports.mark = function (genFun) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+  }, exports.awrap = function (arg) {
+    return {
+      __await: arg
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+    return this;
+  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    void 0 === PromiseImpl && (PromiseImpl = Promise);
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+    return this;
+  }), define(Gp, "toString", function () {
+    return "[object Generator]";
+  }), exports.keys = function (object) {
+    var keys = [];
+
+    for (var key in object) keys.push(key);
+
+    return keys.reverse(), function next() {
+      for (; keys.length;) {
+        var key = keys.pop();
+        if (key in object) return next.value = key, next.done = !1, next;
+      }
+
+      return next.done = !0, next;
+    };
+  }, exports.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (skipTempReset) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+    },
+    stop: function () {
+      this.done = !0;
+      var rootRecord = this.tryEntries[0].completion;
+      if ("throw" === rootRecord.type) throw rootRecord.arg;
+      return this.rval;
+    },
+    dispatchException: function (exception) {
+      if (this.done) throw exception;
+      var context = this;
+
+      function handle(loc, caught) {
+        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i],
+            record = entry.completion;
+        if ("root" === entry.tryLoc) return handle("end");
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc"),
+              hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+          } else {
+            if (!hasFinally) throw new Error("try statement without catch or finally");
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+      var record = finallyEntry ? finallyEntry.completion : {};
+      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+    },
+    complete: function (record, afterLoc) {
+      if ("throw" === record.type) throw record.arg;
+      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+    },
+    finish: function (finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+      }
+    },
+    catch: function (tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+
+          if ("throw" === record.type) {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+
+          return thrown;
+        }
+      }
+
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function (iterable, resultName, nextLoc) {
+      return this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+    }
+  }, exports;
+}
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}
+
+function _taggedTemplateLiteral(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  return Object.freeze(Object.defineProperties(strings, {
+    raw: {
+      value: Object.freeze(raw)
+    }
+  }));
+}
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArrayLimit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+  if (_i == null) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+
+  var _s, _e;
+
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+var _rect, _rect2, _defs;
+
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+var SvgBestagonCircle = function SvgBestagonCircle(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends({
+    width: 23,
+    height: 23,
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    xmlnsXlink: "http://www.w3.org/1999/xlink"
+  }, props), _rect || (_rect = /*#__PURE__*/React__namespace.createElement("rect", {
+    width: 23,
+    height: 23,
+    rx: 11.5,
+    fill: "#33BAA2"
+  })), _rect2 || (_rect2 = /*#__PURE__*/React__namespace.createElement("rect", {
+    width: 23,
+    height: 23,
+    rx: 11.5,
+    fill: "url(#bestagon_circle_svg__a)"
+  })), _defs || (_defs = /*#__PURE__*/React__namespace.createElement("defs", null, /*#__PURE__*/React__namespace.createElement("pattern", {
+    id: "bestagon_circle_svg__a",
+    patternContentUnits: "objectBoundingBox",
+    width: 1,
+    height: 1
+  }, /*#__PURE__*/React__namespace.createElement("use", {
+    xlinkHref: "#bestagon_circle_svg__b",
+    transform: "translate(.05 .053) scale(.00074)"
+  })), /*#__PURE__*/React__namespace.createElement("image", {
+    id: "bestagon_circle_svg__b",
+    width: 1200,
+    height: 1200,
+    xlinkHref: "data:image/png;base64,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"
+  }))));
+};
+
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10, _templateObject11, _templateObject12, _templateObject13, _templateObject14;
+function DmButton(props) {
+  var _useAccount = wagmi.useAccount(),
+      wagmiAddress = _useAccount.address;
+
+  var _useSignMessage = wagmi.useSignMessage(),
+      signMessageAsync = _useSignMessage.signMessageAsync;
+
+  var _useState = React.useState(0),
+      _useState2 = _slicedToArray(_useState, 2),
+      numberOfNotifications = _useState2[0],
+      setNumberOfNotifications = _useState2[1];
+
+  var mainUrl = "https://nftychat-staging.herokuapp.com";
+
+  var _useState3 = React.useState(null),
+      _useState4 = _slicedToArray(_useState3, 2),
+      accessToken = _useState4[0],
+      setAccessToken = _useState4[1];
+
+  var _useState5 = React.useState(""),
+      _useState6 = _slicedToArray(_useState5, 2),
+      messageText = _useState6[0],
+      setMessageText = _useState6[1];
+
+  var _useState7 = React.useState(null),
+      _useState8 = _slicedToArray(_useState7, 2),
+      popoverAnchor = _useState8[0],
+      setPopoverAnchor = _useState8[1]; // const displayName = "Poapdispenser.eth";
+  // const address = "0x11B002247efc78A149F4e6aDc9F143b47bE9123D"
+
+
+  React.useEffect(function () {
+    fetch(mainUrl + "/v1/unread_message_count?address=" + props.address, {
+      method: "get"
+    }).then(function (payload) {
+      return payload.json();
+    }).then(function (data) {
+      console.log(data);
+      setNumberOfNotifications(data);
+    });
+  }, [props.address]); // useEffect to close popover if user is same as props.address
+
+  React.useEffect(function () {
+    if (props.address === wagmiAddress) {
+      setPopoverAnchor(null);
+    }
+  }, [props.address, wagmiAddress]);
+
+  function sendClick() {
+    return _sendClick.apply(this, arguments);
+  }
+
+  function _sendClick() {
+    _sendClick = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      var tempAccessToken, message_response, data, login_message, signature, payload;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              tempAccessToken = accessToken;
+
+              if (!(accessToken === null)) {
+                _context.next = 15;
+                break;
+              }
+
+              _context.next = 4;
+              return fetch(mainUrl + "/v1/siwe_message?address=" + wagmiAddress, {
+                method: "post"
+              });
+
+            case 4:
+              message_response = _context.sent;
+              _context.next = 7;
+              return message_response.json();
+
+            case 7:
+              data = _context.sent;
+              login_message = data.login_message;
+              _context.next = 11;
+              return signMessageAsync({
+                message: login_message
+              });
+
+            case 11:
+              signature = _context.sent;
+              _context.next = 14;
+              return checkSignature(wagmiAddress, signature);
+
+            case 14:
+              tempAccessToken = _context.sent;
+
+            case 15:
+              payload = {
+                address: props.address,
+                message_text: messageText
+              };
+              fetch(mainUrl + "/v1/send_message", {
+                method: "POST",
+                headers: {
+                  Accept: "application/json",
+                  "Content-Type": "application/json",
+                  Authorization: "Bearer " + tempAccessToken
+                },
+                body: JSON.stringify(payload)
+              }).then(function (response) {
+                if (!response.ok) {
+                  response.json().then(function (data) {
+                    toast__default["default"].error(data["detail"]);
+                  }); // TODO: Unsure what error is trying to throw
+
+                  throw new Error("error");
+                }
+
+                return response.json();
+              }).then(function () {
+                toast__default["default"].success("Message sent!");
+                setNumberOfNotifications(function (num) {
+                  return num + 1;
+                });
+                setMessageText("");
+                setPopoverAnchor(null);
+              });
+
+            case 17:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+    return _sendClick.apply(this, arguments);
+  }
+
+  function checkSignature() {
+    return _checkSignature.apply(this, arguments);
+  }
+
+  function _checkSignature() {
+    _checkSignature = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+      var tempAddress,
+          signature,
+          signatureUrl,
+          loginResponse,
+          loginData,
+          _args2 = arguments;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              tempAddress = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : wagmiAddress;
+              signature = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : "0x";
+              signatureUrl = "".concat(mainUrl, "/v1/authenticate?address=").concat(tempAddress, "&signature=").concat(signature, "&source=").concat(window.location.hostname);
+              _context2.next = 5;
+              return fetch(signatureUrl);
+
+            case 5:
+              loginResponse = _context2.sent;
+
+              if (loginResponse.ok) {
+                _context2.next = 9;
+                break;
+              }
+
+              loginResponse.json().then(function (data) {
+                toast__default["default"].error(data["detail"]);
+              });
+              throw new Error(loginResponse.status);
+
+            case 9:
+              _context2.next = 11;
+              return loginResponse.json();
+
+            case 11:
+              loginData = _context2.sent;
+
+              if (!(loginData["status"] === "pending")) {
+                _context2.next = 15;
+                break;
+              }
+
+              toast__default["default"].error("Multisig not enabled");
+              return _context2.abrupt("return");
+
+            case 15:
+              setAccessToken(loginData["token"]);
+              return _context2.abrupt("return", loginData["token"]);
+
+            case 17:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+    return _checkSignature.apply(this, arguments);
+  }
+
+  return /*#__PURE__*/jsxRuntime.jsx(rainbowkit.ConnectButton.Custom, {
+    children: function children(_ref) {
+      var openConnectModal = _ref.openConnectModal;
+      return /*#__PURE__*/jsxRuntime.jsxs("div", {
+        className: css.css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n          position: relative;\n          "]))),
+        children: [/*#__PURE__*/jsxRuntime.jsxs("button", {
+          className: css.css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n              display: flex;\n              align-items: center;\n              justify-content: center;\n              gap: 8px;\n              border-radius: 9999px;\n              background-color: white;\n              padding: 8px 16px;\n              color: #467EE5;\n              border: none;\n              box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);\n              transition: color 200ms, background-color 200ms;\n              font-family: Inter,sans-serif;\n              &:hover {\n                background-color: #f9fafb;\n              }\n              "]))),
+          type: "button",
+          onClick: function onClick(event) {
+            if (wagmiAddress === props.address) {
+              window.open('https://nftychat.xyz/dms', '_blank');
+            } else {
+              if (!wagmiAddress) {
+                openConnectModal();
+              }
+
+              setPopoverAnchor(event.currentTarget);
+            }
+          },
+          children: [/*#__PURE__*/jsxRuntime.jsxs("div", {
+            className: css.css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n              position: relative;\n              display: flex;\n              height: 24px;\n              width: 24px;\n              align-items: center;\n              justify-content: center;\n              "]))),
+            children: [numberOfNotifications > 0 && /*#__PURE__*/jsxRuntime.jsx("div", {
+              className: css.css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n                  position: absolute;\n                  top: -4px;\n                  right: -4px;\n                  display: flex;\n                  width: 14px;\n                  height: 14px;\n                  align-items: center;\n                  justify-content: center; \n                  border-radius: 9999px;\n                  background-color: #FA2449;\n                  color: white;\n                  font-size: 10px; \n                  "]))),
+              children: numberOfNotifications
+            }), /*#__PURE__*/jsxRuntime.jsx(react.Icon, {
+              className: css.css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n                  height: 100%;\n                  width: 100%;\n                  "]))),
+              icon: "ant-design:message-outlined"
+            })]
+          }), /*#__PURE__*/jsxRuntime.jsx("span", {
+            className: css.css(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["    \n              font-size: 16px;\n              line-height: 1.5rem;\n              font-weight: 400;"]))),
+            children: wagmiAddress === props.address ? "Check Messages" : "DM ".concat(props.displayName)
+          })]
+        }), /*#__PURE__*/jsxRuntime.jsx(Popover__default["default"], {
+          anchorEl: popoverAnchor,
+          anchorOrigin: {
+            vertical: "bottom",
+            horizontal: "center"
+          },
+          className: css.css(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n              border-radius: 6px;\n              margin-top: 8px;"]))),
+          onClose: function onClose() {
+            return setPopoverAnchor(null);
+          },
+          open: popoverAnchor !== null && ![null, undefined].includes(wagmiAddress),
+          transformOrigin: {
+            vertical: "top",
+            horizontal: "center"
+          },
+          children: /*#__PURE__*/jsxRuntime.jsxs("div", {
+            className: css.css(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["display:flex;\n              width: 384px;\n              flex-direction: column;\n              background-color: white;\n              padding: 16px 16px 8px 16px;\n              "]))),
+            children: [/*#__PURE__*/jsxRuntime.jsx("textarea", {
+              className: css.css(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["\n                  margin-bottom: 6px;\n                  min-height: 66px;\n                  resize: none;\n                  padding: 8px;\n                  border: solid #e2e8f0 1px;\n                  border-radius: 6px;\n                  color: #467EE5;\n                  outline: none;\n                  transition: color 200ms, background-color 200ms;\n                  font-family: Inter,sans-serif;\n                  font-size: 1rem;\n                  line-height: 1.5rem;\n                  &:focus {\n                    border-color: #cbd5e1;\n                  }\n                  "]))),
+              spellCheck: false,
+              value: messageText,
+              onChange: function onChange(e) {
+                return setMessageText(e.target.value);
+              }
+            }), /*#__PURE__*/jsxRuntime.jsxs("div", {
+              className: css.css(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral(["\n                display: flex;\n                align-items: center;\n                justify-content: space-between;\n                "]))),
+              children: [/*#__PURE__*/jsxRuntime.jsxs("div", {
+                className: css.css(_templateObject11 || (_templateObject11 = _taggedTemplateLiteral(["\n                  display: flex;\n                  align-items: center;\n                  gap: 8px;\n                  "]))),
+                children: [/*#__PURE__*/jsxRuntime.jsx(SvgBestagonCircle, {}), /*#__PURE__*/jsxRuntime.jsx("span", {
+                  className: css.css(_templateObject12 || (_templateObject12 = _taggedTemplateLiteral(["color: #B58FD9;\n                              font-family: Inter,sans-serif;\n                              font-size: 1rem;\n                              line-height: 1.5rem;\n                              "]))),
+                  children: "Sent via nfty chat"
+                })]
+              }), /*#__PURE__*/jsxRuntime.jsx("button", {
+                className: css.css(_templateObject13 || (_templateObject13 = _taggedTemplateLiteral(["\n                    display: flex;\n                    align-items: center;\n                    justify-content: center;\n                    height: 32px;\n                    width: 32px;\n                    border-radius: 9999px;\n                    border: none;\n                    padding: 6px;\n                    color: #B58FD9; \n                    transition: color 200ms, background-color 200ms;\n                    background-color: transparent;\n                    &:hover {\n                      background-color: #f9fafb;\n                    }\n                    "]))),
+                onClick: sendClick,
+                children: /*#__PURE__*/jsxRuntime.jsx(react.Icon, {
+                  className: css.css(_templateObject14 || (_templateObject14 = _taggedTemplateLiteral(["\n                      height: 100%;\n                      width: 100%;\n                      "]))),
+                  icon: "ant-design:send-outlined"
+                })
+              })]
+            })]
+          })
+        })]
+      });
+    }
+  });
+}
+
+var _configureChains = wagmi.configureChains([wagmi.chain.mainnet, wagmi.chain.polygon, wagmi.chain.optimism, wagmi.chain.arbitrum], [_public.publicProvider()]),
+    chains = _configureChains.chains,
+    provider = _configureChains.provider;
+
+var _getDefaultWallets = rainbowkit.getDefaultWallets({
+  appName: "nftyembed",
+  chains: chains
+}),
+    connectors = _getDefaultWallets.connectors;
+
+var wagmiClient = wagmi.createClient({
+  autoConnect: true,
+  connectors: connectors,
+  provider: provider
+});
+function UniversalDm(props) {
+  return /*#__PURE__*/jsxRuntime.jsx(wagmi.WagmiConfig, {
+    client: wagmiClient,
+    children: /*#__PURE__*/jsxRuntime.jsxs(rainbowkit.RainbowKitProvider, {
+      chains: chains,
+      children: [/*#__PURE__*/jsxRuntime.jsx(toast.Toaster, {}), /*#__PURE__*/jsxRuntime.jsx(DmButton, {
+        address: props.address,
+        displayName: props.displayName
+      })]
+    })
+  });
+}
+
+exports.UniversalDm = UniversalDm;