starknetkit
Version:
<!-- logo --> <p align="center"> <img width='300' src="https://starknetkit-website-git-blo-1541-argentlabs.vercel.app/starknetKit-logo.svg"> </p>
1,934 lines (1,933 loc) • 47.3 kB
JavaScript
var Q = Object.defineProperty;
var X = (r, e, t) => e in r ? Q(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
var A = (r, e, t) => (X(r, typeof e != "symbol" ? e + "" : e, t), t);
import { m as U } from "./core-d21d2e96.js";
import { WalletAccount as K, constants as P } from "starknet";
import { C as Z, a as y, b as R, U as E } from "./connector-d58f0dd8.js";
import { g as H } from "./trpc-870d4938.js";
import { P as $, r as J } from "./lastConnected-c0cae438.js";
import { ArgentX as Y } from "./argentX.js";
import { A as O } from "./index-af1aed3e.js";
const ee = {
mainnet: "https://starknet-mainnet.public.blastapi.io",
testnet: "https://starknet-sepolia.public.blastapi.io"
}, te = {
mainnet: "https://rpc.starknet.lava.build",
testnet: "https://rpc.starknet-sepolia.lava.build"
}, x = [ee, te];
function re() {
const r = Math.floor(Math.random() * x.length);
return x[r];
}
const se = () => Object.keys(localStorage).some(
(r) => r === "walletconnect" || r.startsWith("wc@2:")
), T = () => {
if (se()) {
delete localStorage.walletconnect;
for (const r in localStorage)
r.startsWith("wc@2:") && delete localStorage[r];
}
}, L = "f2e613881f7a0e811295cdd57999e31b", I = `<svg
width="32"
height="32"
viewBox="0 0 32 32"
fill="none"
xmlns="http://www.w3.org/2000/svg"
>
<rect width="32" height="32" rx="8" fill="#FF875B" />
<path
d="M18.316 8H13.684C13.5292 8 13.4052 8.1272 13.4018 8.28531C13.3082 12.7296 11.0323 16.9477 7.11513 19.9355C6.99077 20.0303 6.96243 20.2085 7.05335 20.3369L9.76349 24.1654C9.85569 24.2957 10.0353 24.3251 10.1618 24.2294C12.6111 22.3734 14.5812 20.1345 16 17.6529C17.4187 20.1345 19.389 22.3734 21.8383 24.2294C21.9646 24.3251 22.1443 24.2957 22.2366 24.1654L24.9467 20.3369C25.0375 20.2085 25.0092 20.0303 24.885 19.9355C20.9676 16.9477 18.6918 12.7296 18.5983 8.28531C18.5949 8.1272 18.4708 8 18.316 8Z"
fill="white"
/>
</svg>`;
function ie() {
if (!(typeof window > "u"))
return window?.starknet_argentX;
}
const q = () => {
if (typeof window > "u")
return !1;
const r = ie();
return r ? r.isInAppBrowser : !1;
};
var ne = typeof global == "object" && global && global.Object === Object && global;
const oe = ne;
var ae = typeof self == "object" && self && self.Object === Object && self, ce = oe || ae || Function("return this")();
const de = ce;
var le = de.Symbol;
const k = le;
var z = Object.prototype, ue = z.hasOwnProperty, fe = z.toString, _ = k ? k.toStringTag : void 0;
function he(r) {
var e = ue.call(r, _), t = r[_];
try {
r[_] = void 0;
var i = !0;
} catch {
}
var n = fe.call(r);
return i && (e ? r[_] = t : delete r[_]), n;
}
var ge = Object.prototype, me = ge.toString;
function we(r) {
return me.call(r);
}
var pe = "[object Null]", be = "[object Undefined]", W = k ? k.toStringTag : void 0;
function ve(r) {
return r == null ? r === void 0 ? be : pe : W && W in Object(r) ? he(r) : we(r);
}
function Me(r) {
return r != null && typeof r == "object";
}
var ye = Array.isArray;
const Se = ye;
var Be = "[object String]";
function N(r) {
return typeof r == "string" || !Se(r) && Me(r) && ve(r) == Be;
}
function C(r) {
return r.isCompoundConnector;
}
function S(r, e = !1) {
return C(r) ? e ? r.fallbackConnector : r.connector : r;
}
function Fe(r, e) {
const t = r.find((i) => i ? S(i)?.id === e : !1);
return t ? S(t) : null;
}
const _e = {
"Amazon Silk": "amazon_silk",
"Android Browser": "android",
Bada: "bada",
BlackBerry: "blackberry",
Chrome: "chrome",
Chromium: "chromium",
Electron: "electron",
Epiphany: "epiphany",
Firefox: "firefox",
Focus: "focus",
Generic: "generic",
"Google Search": "google_search",
Googlebot: "googlebot",
"Internet Explorer": "ie",
"K-Meleon": "k_meleon",
Maxthon: "maxthon",
"Microsoft Edge": "edge",
"MZ Browser": "mz",
"NAVER Whale Browser": "naver",
Opera: "opera",
"Opera Coast": "opera_coast",
PhantomJS: "phantomjs",
Puffin: "puffin",
QupZilla: "qupzilla",
QQ: "qq",
QQLite: "qqlite",
Safari: "safari",
Sailfish: "sailfish",
"Samsung Internet for Android": "samsung_internet",
SeaMonkey: "seamonkey",
Sleipnir: "sleipnir",
Swing: "swing",
Tizen: "tizen",
"UC Browser": "uc",
Vivaldi: "vivaldi",
"WebOS Browser": "webos",
WeChat: "wechat",
"Yandex Browser": "yandex",
Roku: "roku"
}, D = {
amazon_silk: "Amazon Silk",
android: "Android Browser",
bada: "Bada",
blackberry: "BlackBerry",
chrome: "Chrome",
chromium: "Chromium",
electron: "Electron",
epiphany: "Epiphany",
firefox: "Firefox",
focus: "Focus",
generic: "Generic",
googlebot: "Googlebot",
google_search: "Google Search",
ie: "Internet Explorer",
k_meleon: "K-Meleon",
maxthon: "Maxthon",
edge: "Microsoft Edge",
mz: "MZ Browser",
naver: "NAVER Whale Browser",
opera: "Opera",
opera_coast: "Opera Coast",
phantomjs: "PhantomJS",
puffin: "Puffin",
qupzilla: "QupZilla",
qq: "QQ Browser",
qqlite: "QQ Browser Lite",
safari: "Safari",
sailfish: "Sailfish",
samsung_internet: "Samsung Internet for Android",
seamonkey: "SeaMonkey",
sleipnir: "Sleipnir",
swing: "Swing",
tizen: "Tizen",
uc: "UC Browser",
vivaldi: "Vivaldi",
webos: "WebOS Browser",
wechat: "WeChat",
yandex: "Yandex Browser"
}, u = {
tablet: "tablet",
mobile: "mobile",
desktop: "desktop",
tv: "tv"
}, m = {
WindowsPhone: "Windows Phone",
Windows: "Windows",
MacOS: "macOS",
iOS: "iOS",
Android: "Android",
WebOS: "WebOS",
BlackBerry: "BlackBerry",
Bada: "Bada",
Tizen: "Tizen",
Linux: "Linux",
ChromeOS: "Chrome OS",
PlayStation4: "PlayStation 4",
Roku: "Roku"
}, M = {
EdgeHTML: "EdgeHTML",
Blink: "Blink",
Trident: "Trident",
Presto: "Presto",
Gecko: "Gecko",
WebKit: "WebKit"
};
class s {
/**
* Get first matched item for a string
* @param {RegExp} regexp
* @param {String} ua
* @return {Array|{index: number, input: string}|*|boolean|string}
*/
static getFirstMatch(e, t) {
const i = t.match(e);
return i && i.length > 0 && i[1] || "";
}
/**
* Get second matched item for a string
* @param regexp
* @param {String} ua
* @return {Array|{index: number, input: string}|*|boolean|string}
*/
static getSecondMatch(e, t) {
const i = t.match(e);
return i && i.length > 1 && i[2] || "";
}
/**
* Match a regexp and return a constant or undefined
* @param {RegExp} regexp
* @param {String} ua
* @param {*} _const Any const that will be returned if regexp matches the string
* @return {*}
*/
static matchAndReturnConst(e, t, i) {
if (e.test(t))
return i;
}
static getWindowsVersionName(e) {
switch (e) {
case "NT":
return "NT";
case "XP":
return "XP";
case "NT 5.0":
return "2000";
case "NT 5.1":
return "XP";
case "NT 5.2":
return "2003";
case "NT 6.0":
return "Vista";
case "NT 6.1":
return "7";
case "NT 6.2":
return "8";
case "NT 6.3":
return "8.1";
case "NT 10.0":
return "10";
default:
return;
}
}
/**
* Get macOS version name
* 10.5 - Leopard
* 10.6 - Snow Leopard
* 10.7 - Lion
* 10.8 - Mountain Lion
* 10.9 - Mavericks
* 10.10 - Yosemite
* 10.11 - El Capitan
* 10.12 - Sierra
* 10.13 - High Sierra
* 10.14 - Mojave
* 10.15 - Catalina
*
* @example
* getMacOSVersionName("10.14") // 'Mojave'
*
* @param {string} version
* @return {string} versionName
*/
static getMacOSVersionName(e) {
const t = e.split(".").splice(0, 2).map((i) => parseInt(i, 10) || 0);
if (t.push(0), t[0] === 10)
switch (t[1]) {
case 5:
return "Leopard";
case 6:
return "Snow Leopard";
case 7:
return "Lion";
case 8:
return "Mountain Lion";
case 9:
return "Mavericks";
case 10:
return "Yosemite";
case 11:
return "El Capitan";
case 12:
return "Sierra";
case 13:
return "High Sierra";
case 14:
return "Mojave";
case 15:
return "Catalina";
default:
return;
}
}
/**
* Get Android version name
* 1.5 - Cupcake
* 1.6 - Donut
* 2.0 - Eclair
* 2.1 - Eclair
* 2.2 - Froyo
* 2.x - Gingerbread
* 3.x - Honeycomb
* 4.0 - Ice Cream Sandwich
* 4.1 - Jelly Bean
* 4.4 - KitKat
* 5.x - Lollipop
* 6.x - Marshmallow
* 7.x - Nougat
* 8.x - Oreo
* 9.x - Pie
*
* @example
* getAndroidVersionName("7.0") // 'Nougat'
*
* @param {string} version
* @return {string} versionName
*/
static getAndroidVersionName(e) {
const t = e.split(".").splice(0, 2).map((i) => parseInt(i, 10) || 0);
if (t.push(0), !(t[0] === 1 && t[1] < 5)) {
if (t[0] === 1 && t[1] < 6)
return "Cupcake";
if (t[0] === 1 && t[1] >= 6)
return "Donut";
if (t[0] === 2 && t[1] < 2)
return "Eclair";
if (t[0] === 2 && t[1] === 2)
return "Froyo";
if (t[0] === 2 && t[1] > 2)
return "Gingerbread";
if (t[0] === 3)
return "Honeycomb";
if (t[0] === 4 && t[1] < 1)
return "Ice Cream Sandwich";
if (t[0] === 4 && t[1] < 4)
return "Jelly Bean";
if (t[0] === 4 && t[1] >= 4)
return "KitKat";
if (t[0] === 5)
return "Lollipop";
if (t[0] === 6)
return "Marshmallow";
if (t[0] === 7)
return "Nougat";
if (t[0] === 8)
return "Oreo";
if (t[0] === 9)
return "Pie";
}
}
/**
* Get version precisions count
*
* @example
* getVersionPrecision("1.10.3") // 3
*
* @param {string} version
* @return {number}
*/
static getVersionPrecision(e) {
return e.split(".").length;
}
/**
* Calculate browser version weight
*
* @example
* compareVersions('1.10.2.1', '1.8.2.1.90') // 1
* compareVersions('1.010.2.1', '1.09.2.1.90'); // 1
* compareVersions('1.10.2.1', '1.10.2.1'); // 0
* compareVersions('1.10.2.1', '1.0800.2'); // -1
* compareVersions('1.10.2.1', '1.10', true); // 0
*
* @param {String} versionA versions versions to compare
* @param {String} versionB versions versions to compare
* @param {boolean} [isLoose] enable loose comparison
* @return {Number} comparison result: -1 when versionA is lower,
* 1 when versionA is bigger, 0 when both equal
*/
/* eslint consistent-return: 1 */
static compareVersions(e, t, i = !1) {
const n = s.getVersionPrecision(e), c = s.getVersionPrecision(t);
let a = Math.max(n, c), f = 0;
const l = s.map([e, t], (d) => {
const h = a - s.getVersionPrecision(d), p = d + new Array(h + 1).join(".0");
return s.map(p.split("."), (g) => new Array(20 - g.length).join("0") + g).reverse();
});
for (i && (f = a - Math.min(n, c)), a -= 1; a >= f; ) {
if (l[0][a] > l[1][a])
return 1;
if (l[0][a] === l[1][a]) {
if (a === f)
return 0;
a -= 1;
} else if (l[0][a] < l[1][a])
return -1;
}
}
/**
* Array::map polyfill
*
* @param {Array} arr
* @param {Function} iterator
* @return {Array}
*/
static map(e, t) {
const i = [];
let n;
if (Array.prototype.map)
return Array.prototype.map.call(e, t);
for (n = 0; n < e.length; n += 1)
i.push(t(e[n]));
return i;
}
/**
* Array::find polyfill
*
* @param {Array} arr
* @param {Function} predicate
* @return {Array}
*/
static find(e, t) {
let i, n;
if (Array.prototype.find)
return Array.prototype.find.call(e, t);
for (i = 0, n = e.length; i < n; i += 1) {
const c = e[i];
if (t(c, i))
return c;
}
}
/**
* Object::assign polyfill
*
* @param {Object} obj
* @param {Object} ...objs
* @return {Object}
*/
static assign(e, ...t) {
const i = e;
let n, c;
if (Object.assign)
return Object.assign(e, ...t);
for (n = 0, c = t.length; n < c; n += 1) {
const a = t[n];
typeof a == "object" && a !== null && Object.keys(a).forEach((l) => {
i[l] = a[l];
});
}
return e;
}
/**
* Get short version/alias for a browser name
*
* @example
* getBrowserAlias('Microsoft Edge') // edge
*
* @param {string} browserName
* @return {string}
*/
static getBrowserAlias(e) {
return _e[e];
}
/**
* Get short version/alias for a browser name
*
* @example
* getBrowserAlias('edge') // Microsoft Edge
*
* @param {string} browserAlias
* @return {string}
*/
static getBrowserTypeByAlias(e) {
return D[e] || "";
}
}
const o = /version\/(\d+(\.?_?\d+)+)/i, ke = [
/* Googlebot */
{
test: [/googlebot/i],
describe(r) {
const e = {
name: "Googlebot"
}, t = s.getFirstMatch(/googlebot\/(\d+(\.\d+))/i, r) || s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
/* Opera < 13.0 */
{
test: [/opera/i],
describe(r) {
const e = {
name: "Opera"
}, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:opera)[\s/](\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
/* Opera > 13.0 */
{
test: [/opr\/|opios/i],
describe(r) {
const e = {
name: "Opera"
}, t = s.getFirstMatch(/(?:opr|opios)[\s/](\S+)/i, r) || s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
{
test: [/SamsungBrowser/i],
describe(r) {
const e = {
name: "Samsung Internet for Android"
}, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:SamsungBrowser)[\s/](\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/Whale/i],
describe(r) {
const e = {
name: "NAVER Whale Browser"
}, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:whale)[\s/](\d+(?:\.\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/MZBrowser/i],
describe(r) {
const e = {
name: "MZ Browser"
}, t = s.getFirstMatch(/(?:MZBrowser)[\s/](\d+(?:\.\d+)+)/i, r) || s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
{
test: [/focus/i],
describe(r) {
const e = {
name: "Focus"
}, t = s.getFirstMatch(/(?:focus)[\s/](\d+(?:\.\d+)+)/i, r) || s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
{
test: [/swing/i],
describe(r) {
const e = {
name: "Swing"
}, t = s.getFirstMatch(/(?:swing)[\s/](\d+(?:\.\d+)+)/i, r) || s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
{
test: [/coast/i],
describe(r) {
const e = {
name: "Opera Coast"
}, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:coast)[\s/](\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/opt\/\d+(?:.?_?\d+)+/i],
describe(r) {
const e = {
name: "Opera Touch"
}, t = s.getFirstMatch(/(?:opt)[\s/](\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
{
test: [/yabrowser/i],
describe(r) {
const e = {
name: "Yandex Browser"
}, t = s.getFirstMatch(/(?:yabrowser)[\s/](\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
{
test: [/ucbrowser/i],
describe(r) {
const e = {
name: "UC Browser"
}, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:ucbrowser)[\s/](\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/Maxthon|mxios/i],
describe(r) {
const e = {
name: "Maxthon"
}, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:Maxthon|mxios)[\s/](\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/epiphany/i],
describe(r) {
const e = {
name: "Epiphany"
}, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:epiphany)[\s/](\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/puffin/i],
describe(r) {
const e = {
name: "Puffin"
}, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:puffin)[\s/](\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/sleipnir/i],
describe(r) {
const e = {
name: "Sleipnir"
}, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:sleipnir)[\s/](\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/k-meleon/i],
describe(r) {
const e = {
name: "K-Meleon"
}, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:k-meleon)[\s/](\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/micromessenger/i],
describe(r) {
const e = {
name: "WeChat"
}, t = s.getFirstMatch(/(?:micromessenger)[\s/](\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
{
test: [/qqbrowser/i],
describe(r) {
const e = {
name: /qqbrowserlite/i.test(r) ? "QQ Browser Lite" : "QQ Browser"
}, t = s.getFirstMatch(/(?:qqbrowserlite|qqbrowser)[/](\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
{
test: [/msie|trident/i],
describe(r) {
const e = {
name: "Internet Explorer"
}, t = s.getFirstMatch(/(?:msie |rv:)(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/\sedg\//i],
describe(r) {
const e = {
name: "Microsoft Edge"
}, t = s.getFirstMatch(/\sedg\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/edg([ea]|ios)/i],
describe(r) {
const e = {
name: "Microsoft Edge"
}, t = s.getSecondMatch(/edg([ea]|ios)\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/vivaldi/i],
describe(r) {
const e = {
name: "Vivaldi"
}, t = s.getFirstMatch(/vivaldi\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/seamonkey/i],
describe(r) {
const e = {
name: "SeaMonkey"
}, t = s.getFirstMatch(/seamonkey\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/sailfish/i],
describe(r) {
const e = {
name: "Sailfish"
}, t = s.getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/silk/i],
describe(r) {
const e = {
name: "Amazon Silk"
}, t = s.getFirstMatch(/silk\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/phantom/i],
describe(r) {
const e = {
name: "PhantomJS"
}, t = s.getFirstMatch(/phantomjs\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/slimerjs/i],
describe(r) {
const e = {
name: "SlimerJS"
}, t = s.getFirstMatch(/slimerjs\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/blackberry|\bbb\d+/i, /rim\stablet/i],
describe(r) {
const e = {
name: "BlackBerry"
}, t = s.getFirstMatch(o, r) || s.getFirstMatch(/blackberry[\d]+\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/(web|hpw)[o0]s/i],
describe(r) {
const e = {
name: "WebOS Browser"
}, t = s.getFirstMatch(o, r) || s.getFirstMatch(/w(?:eb)?[o0]sbrowser\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/bada/i],
describe(r) {
const e = {
name: "Bada"
}, t = s.getFirstMatch(/dolfin\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/tizen/i],
describe(r) {
const e = {
name: "Tizen"
}, t = s.getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
{
test: [/qupzilla/i],
describe(r) {
const e = {
name: "QupZilla"
}, t = s.getFirstMatch(/(?:qupzilla)[\s/](\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
{
test: [/firefox|iceweasel|fxios/i],
describe(r) {
const e = {
name: "Firefox"
}, t = s.getFirstMatch(/(?:firefox|iceweasel|fxios)[\s/](\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/electron/i],
describe(r) {
const e = {
name: "Electron"
}, t = s.getFirstMatch(/(?:electron)\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/MiuiBrowser/i],
describe(r) {
const e = {
name: "Miui"
}, t = s.getFirstMatch(/(?:MiuiBrowser)[\s/](\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/chromium/i],
describe(r) {
const e = {
name: "Chromium"
}, t = s.getFirstMatch(/(?:chromium)[\s/](\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
{
test: [/chrome|crios|crmo/i],
describe(r) {
const e = {
name: "Chrome"
}, t = s.getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
{
test: [/GSA/i],
describe(r) {
const e = {
name: "Google Search"
}, t = s.getFirstMatch(/(?:GSA)\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
/* Android Browser */
{
test(r) {
const e = !r.test(/like android/i), t = r.test(/android/i);
return e && t;
},
describe(r) {
const e = {
name: "Android Browser"
}, t = s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
/* PlayStation 4 */
{
test: [/playstation 4/i],
describe(r) {
const e = {
name: "PlayStation 4"
}, t = s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
/* Safari */
{
test: [/safari|applewebkit/i],
describe(r) {
const e = {
name: "Safari"
}, t = s.getFirstMatch(o, r);
return t && (e.version = t), e;
}
},
/* Something else */
{
test: [/.*/i],
describe(r) {
const e = /^(.*)\/(.*) /, t = /^(.*)\/(.*)[ \t]\((.*)/, n = r.search("\\(") !== -1 ? t : e;
return {
name: s.getFirstMatch(n, r),
version: s.getSecondMatch(n, r)
};
}
}
], Ae = [
/* Roku */
{
test: [/Roku\/DVP/],
describe(r) {
const e = s.getFirstMatch(/Roku\/DVP-(\d+\.\d+)/i, r);
return {
name: m.Roku,
version: e
};
}
},
/* Windows Phone */
{
test: [/windows phone/i],
describe(r) {
const e = s.getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i, r);
return {
name: m.WindowsPhone,
version: e
};
}
},
/* Windows */
{
test: [/windows /i],
describe(r) {
const e = s.getFirstMatch(/Windows ((NT|XP)( \d\d?.\d)?)/i, r), t = s.getWindowsVersionName(e);
return {
name: m.Windows,
version: e,
versionName: t
};
}
},
/* Firefox on iPad */
{
test: [/Macintosh(.*?) FxiOS(.*?)\//],
describe(r) {
const e = {
name: m.iOS
}, t = s.getSecondMatch(/(Version\/)(\d[\d.]+)/, r);
return t && (e.version = t), e;
}
},
/* macOS */
{
test: [/macintosh/i],
describe(r) {
const e = s.getFirstMatch(/mac os x (\d+(\.?_?\d+)+)/i, r).replace(/[_\s]/g, "."), t = s.getMacOSVersionName(e), i = {
name: m.MacOS,
version: e
};
return t && (i.versionName = t), i;
}
},
/* iOS */
{
test: [/(ipod|iphone|ipad)/i],
describe(r) {
const e = s.getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i, r).replace(/[_\s]/g, ".");
return {
name: m.iOS,
version: e
};
}
},
/* Android */
{
test(r) {
const e = !r.test(/like android/i), t = r.test(/android/i);
return e && t;
},
describe(r) {
const e = s.getFirstMatch(/android[\s/-](\d+(\.\d+)*)/i, r), t = s.getAndroidVersionName(e), i = {
name: m.Android,
version: e
};
return t && (i.versionName = t), i;
}
},
/* WebOS */
{
test: [/(web|hpw)[o0]s/i],
describe(r) {
const e = s.getFirstMatch(/(?:web|hpw)[o0]s\/(\d+(\.\d+)*)/i, r), t = {
name: m.WebOS
};
return e && e.length && (t.version = e), t;
}
},
/* BlackBerry */
{
test: [/blackberry|\bbb\d+/i, /rim\stablet/i],
describe(r) {
const e = s.getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i, r) || s.getFirstMatch(/blackberry\d+\/(\d+([_\s]\d+)*)/i, r) || s.getFirstMatch(/\bbb(\d+)/i, r);
return {
name: m.BlackBerry,
version: e
};
}
},
/* Bada */
{
test: [/bada/i],
describe(r) {
const e = s.getFirstMatch(/bada\/(\d+(\.\d+)*)/i, r);
return {
name: m.Bada,
version: e
};
}
},
/* Tizen */
{
test: [/tizen/i],
describe(r) {
const e = s.getFirstMatch(/tizen[/\s](\d+(\.\d+)*)/i, r);
return {
name: m.Tizen,
version: e
};
}
},
/* Linux */
{
test: [/linux/i],
describe() {
return {
name: m.Linux
};
}
},
/* Chrome OS */
{
test: [/CrOS/],
describe() {
return {
name: m.ChromeOS
};
}
},
/* Playstation 4 */
{
test: [/PlayStation 4/],
describe(r) {
const e = s.getFirstMatch(/PlayStation 4[/\s](\d+(\.\d+)*)/i, r);
return {
name: m.PlayStation4,
version: e
};
}
}
], Oe = [
/* Googlebot */
{
test: [/googlebot/i],
describe() {
return {
type: "bot",
vendor: "Google"
};
}
},
/* Huawei */
{
test: [/huawei/i],
describe(r) {
const e = s.getFirstMatch(/(can-l01)/i, r) && "Nova", t = {
type: u.mobile,
vendor: "Huawei"
};
return e && (t.model = e), t;
}
},
/* Nexus Tablet */
{
test: [/nexus\s*(?:7|8|9|10).*/i],
describe() {
return {
type: u.tablet,
vendor: "Nexus"
};
}
},
/* iPad */
{
test: [/ipad/i],
describe() {
return {
type: u.tablet,
vendor: "Apple",
model: "iPad"
};
}
},
/* Firefox on iPad */
{
test: [/Macintosh(.*?) FxiOS(.*?)\//],
describe() {
return {
type: u.tablet,
vendor: "Apple",
model: "iPad"
};
}
},
/* Amazon Kindle Fire */
{
test: [/kftt build/i],
describe() {
return {
type: u.tablet,
vendor: "Amazon",
model: "Kindle Fire HD 7"
};
}
},
/* Another Amazon Tablet with Silk */
{
test: [/silk/i],
describe() {
return {
type: u.tablet,
vendor: "Amazon"
};
}
},
/* Tablet */
{
test: [/tablet(?! pc)/i],
describe() {
return {
type: u.tablet
};
}
},
/* iPod/iPhone */
{
test(r) {
const e = r.test(/ipod|iphone/i), t = r.test(/like (ipod|iphone)/i);
return e && !t;
},
describe(r) {
const e = s.getFirstMatch(/(ipod|iphone)/i, r);
return {
type: u.mobile,
vendor: "Apple",
model: e
};
}
},
/* Nexus Mobile */
{
test: [/nexus\s*[0-6].*/i, /galaxy nexus/i],
describe() {
return {
type: u.mobile,
vendor: "Nexus"
};
}
},
/* Mobile */
{
test: [/[^-]mobi/i],
describe() {
return {
type: u.mobile
};
}
},
/* BlackBerry */
{
test(r) {
return r.getBrowserName(!0) === "blackberry";
},
describe() {
return {
type: u.mobile,
vendor: "BlackBerry"
};
}
},
/* Bada */
{
test(r) {
return r.getBrowserName(!0) === "bada";
},
describe() {
return {
type: u.mobile
};
}
},
/* Windows Phone */
{
test(r) {
return r.getBrowserName() === "windows phone";
},
describe() {
return {
type: u.mobile,
vendor: "Microsoft"
};
}
},
/* Android Tablet */
{
test(r) {
const e = Number(String(r.getOSVersion()).split(".")[0]);
return r.getOSName(!0) === "android" && e >= 3;
},
describe() {
return {
type: u.tablet
};
}
},
/* Android Mobile */
{
test(r) {
return r.getOSName(!0) === "android";
},
describe() {
return {
type: u.mobile
};
}
},
/* desktop */
{
test(r) {
return r.getOSName(!0) === "macos";
},
describe() {
return {
type: u.desktop,
vendor: "Apple"
};
}
},
/* Windows */
{
test(r) {
return r.getOSName(!0) === "windows";
},
describe() {
return {
type: u.desktop
};
}
},
/* Linux */
{
test(r) {
return r.getOSName(!0) === "linux";
},
describe() {
return {
type: u.desktop
};
}
},
/* PlayStation 4 */
{
test(r) {
return r.getOSName(!0) === "playstation 4";
},
describe() {
return {
type: u.tv
};
}
},
/* Roku */
{
test(r) {
return r.getOSName(!0) === "roku";
},
describe() {
return {
type: u.tv
};
}
}
], Ne = [
/* EdgeHTML */
{
test(r) {
return r.getBrowserName(!0) === "microsoft edge";
},
describe(r) {
if (/\sedg\//i.test(r))
return {
name: M.Blink
};
const t = s.getFirstMatch(/edge\/(\d+(\.?_?\d+)+)/i, r);
return {
name: M.EdgeHTML,
version: t
};
}
},
/* Trident */
{
test: [/trident/i],
describe(r) {
const e = {
name: M.Trident
}, t = s.getFirstMatch(/trident\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
/* Presto */
{
test(r) {
return r.test(/presto/i);
},
describe(r) {
const e = {
name: M.Presto
}, t = s.getFirstMatch(/presto\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
/* Gecko */
{
test(r) {
const e = r.test(/gecko/i), t = r.test(/like gecko/i);
return e && !t;
},
describe(r) {
const e = {
name: M.Gecko
}, t = s.getFirstMatch(/gecko\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
},
/* Blink */
{
test: [/(apple)?webkit\/537\.36/i],
describe() {
return {
name: M.Blink
};
}
},
/* WebKit */
{
test: [/(apple)?webkit/i],
describe(r) {
const e = {
name: M.WebKit
}, t = s.getFirstMatch(/webkit\/(\d+(\.?_?\d+)+)/i, r);
return t && (e.version = t), e;
}
}
];
class j {
/**
* Create instance of Parser
*
* @param {String} UA User-Agent string
* @param {Boolean} [skipParsing=false] parser can skip parsing in purpose of performance
* improvements if you need to make a more particular parsing
* like {@link Parser#parseBrowser} or {@link Parser#parsePlatform}
*
* @throw {Error} in case of empty UA String
*
* @constructor
*/
constructor(e, t = !1) {
if (e == null || e === "")
throw new Error("UserAgent parameter can't be empty");
this._ua = e, this.parsedResult = {}, t !== !0 && this.parse();
}
/**
* Get UserAgent string of current Parser instance
* @return {String} User-Agent String of the current <Parser> object
*
* @public
*/
getUA() {
return this._ua;
}
/**
* Test a UA string for a regexp
* @param {RegExp} regex
* @return {Boolean}
*/
test(e) {
return e.test(this._ua);
}
/**
* Get parsed browser object
* @return {Object}
*/
parseBrowser() {
this.parsedResult.browser = {};
const e = s.find(ke, (t) => {
if (typeof t.test == "function")
return t.test(this);
if (t.test instanceof Array)
return t.test.some((i) => this.test(i));
throw new Error("Browser's test function is not valid");
});
return e && (this.parsedResult.browser = e.describe(this.getUA())), this.parsedResult.browser;
}
/**
* Get parsed browser object
* @return {Object}
*
* @public
*/
getBrowser() {
return this.parsedResult.browser ? this.parsedResult.browser : this.parseBrowser();
}
/**
* Get browser's name
* @return {String} Browser's name or an empty string
*
* @public
*/
getBrowserName(e) {
return e ? String(this.getBrowser().name).toLowerCase() || "" : this.getBrowser().name || "";
}
/**
* Get browser's version
* @return {String} version of browser
*
* @public
*/
getBrowserVersion() {
return this.getBrowser().version;
}
/**
* Get OS
* @return {Object}
*
* @example
* this.getOS();
* {
* name: 'macOS',
* version: '10.11.12'
* }
*/
getOS() {
return this.parsedResult.os ? this.parsedResult.os : this.parseOS();
}
/**
* Parse OS and save it to this.parsedResult.os
* @return {*|{}}
*/
parseOS() {
this.parsedResult.os = {};
const e = s.find(Ae, (t) => {
if (typeof t.test == "function")
return t.test(this);
if (t.test instanceof Array)
return t.test.some((i) => this.test(i));
throw new Error("Browser's test function is not valid");
});
return e && (this.parsedResult.os = e.describe(this.getUA())), this.parsedResult.os;
}
/**
* Get OS name
* @param {Boolean} [toLowerCase] return lower-cased value
* @return {String} name of the OS — macOS, Windows, Linux, etc.
*/
getOSName(e) {
const { name: t } = this.getOS();
return e ? String(t).toLowerCase() || "" : t || "";
}
/**
* Get OS version
* @return {String} full version with dots ('10.11.12', '5.6', etc)
*/
getOSVersion() {
return this.getOS().version;
}
/**
* Get parsed platform
* @return {{}}
*/
getPlatform() {
return this.parsedResult.platform ? this.parsedResult.platform : this.parsePlatform();
}
/**
* Get platform name
* @param {Boolean} [toLowerCase=false]
* @return {*}
*/
getPlatformType(e = !1) {
const { type: t } = this.getPlatform();
return e ? String(t).toLowerCase() || "" : t || "";
}
/**
* Get parsed platform
* @return {{}}
*/
parsePlatform() {
this.parsedResult.platform = {};
const e = s.find(Oe, (t) => {
if (typeof t.test == "function")
return t.test(this);
if (t.test instanceof Array)
return t.test.some((i) => this.test(i));
throw new Error("Browser's test function is not valid");
});
return e && (this.parsedResult.platform = e.describe(this.getUA())), this.parsedResult.platform;
}
/**
* Get parsed engine
* @return {{}}
*/
getEngine() {
return this.parsedResult.engine ? this.parsedResult.engine : this.parseEngine();
}
/**
* Get engines's name
* @return {String} Engines's name or an empty string
*
* @public
*/
getEngineName(e) {
return e ? String(this.getEngine().name).toLowerCase() || "" : this.getEngine().name || "";
}
/**
* Get parsed platform
* @return {{}}
*/
parseEngine() {
this.parsedResult.engine = {};
const e = s.find(Ne, (t) => {
if (typeof t.test == "function")
return t.test(this);
if (t.test instanceof Array)
return t.test.some((i) => this.test(i));
throw new Error("Browser's test function is not valid");
});
return e && (this.parsedResult.engine = e.describe(this.getUA())), this.parsedResult.engine;
}
/**
* Parse full information about the browser
* @returns {Parser}
*/
parse() {
return this.parseBrowser(), this.parseOS(), this.parsePlatform(), this.parseEngine(), this;
}
/**
* Get parsed result
* @return {ParsedResult}
*/
getResult() {
return s.assign({}, this.parsedResult);
}
/**
* Check if parsed browser matches certain conditions
*
* @param {Object} checkTree It's one or two layered object,
* which can include a platform or an OS on the first layer
* and should have browsers specs on the bottom-laying layer
*
* @returns {Boolean|undefined} Whether the browser satisfies the set conditions or not.
* Returns `undefined` when the browser is no described in the checkTree object.
*
* @example
* const browser = Bowser.getParser(window.navigator.userAgent);
* if (browser.satisfies({chrome: '>118.01.1322' }))
* // or with os
* if (browser.satisfies({windows: { chrome: '>118.01.1322' } }))
* // or with platforms
* if (browser.satisfies({desktop: { chrome: '>118.01.1322' } }))
*/
satisfies(e) {
const t = {};
let i = 0;
const n = {};
let c = 0;
if (Object.keys(e).forEach((f) => {
const l = e[f];
typeof l == "string" ? (n[f] = l, c += 1) : typeof l == "object" && (t[f] = l, i += 1);
}), i > 0) {
const f = Object.keys(t), l = s.find(f, (h) => this.isOS(h));
if (l) {
const h = this.satisfies(t[l]);
if (h !== void 0)
return h;
}
const d = s.find(
f,
(h) => this.isPlatform(h)
);
if (d) {
const h = this.satisfies(t[d]);
if (h !== void 0)
return h;
}
}
if (c > 0) {
const f = Object.keys(n), l = s.find(f, (d) => this.isBrowser(d, !0));
if (l !== void 0)
return this.compareVersion(n[l]);
}
}
/**
* Check if the browser name equals the passed string
* @param browserName The string to compare with the browser name
* @param [includingAlias=false] The flag showing whether alias will be included into comparison
* @returns {boolean}
*/
isBrowser(e, t = !1) {
const i = this.getBrowserName().toLowerCase();
let n = e.toLowerCase();
const c = s.getBrowserTypeByAlias(n);
return t && c && (n = c.toLowerCase()), n === i;
}
compareVersion(e) {
let t = [0], i = e, n = !1;
const c = this.getBrowserVersion();
if (typeof c == "string")
return e[0] === ">" || e[0] === "<" ? (i = e.substr(1), e[1] === "=" ? (n = !0, i = e.substr(2)) : t = [], e[0] === ">" ? t.push(1) : t.push(-1)) : e[0] === "=" ? i = e.substr(1) : e[0] === "~" && (n = !0, i = e.substr(1)), t.indexOf(
s.compareVersions(c, i, n)
) > -1;
}
isOS(e) {
return this.getOSName(!0) === String(e).toLowerCase();
}
isPlatform(e) {
return this.getPlatformType(!0) === String(e).toLowerCase();
}
isEngine(e) {
return this.getEngineName(!0) === String(e).toLowerCase();
}
/**
* Is anything? Check if the browser is called "anything",
* the OS called "anything" or the platform called "anything"
* @param {String} anything
* @param [includingAlias=false] The flag showing whether alias will be included into comparison
* @returns {Boolean}
*/
is(e, t = !1) {
return this.isBrowser(e, t) || this.isOS(e) || this.isPlatform(e);
}
/**
* Check if any of the given values satisfies this.is(anything)
* @param {String[]} anythings
* @returns {Boolean}
*/
some(e = []) {
return e.some((t) => this.is(t));
}
}
/*!
* Bowser - a browser detector
* https://github.com/lancedikson/bowser
* MIT License | (c) Dustin Diaz 2012-2015
* MIT License | (c) Denis Demchenko 2015-2019
*/
class Ce {
/**
* Creates a {@link Parser} instance
*
* @param {String} UA UserAgent string
* @param {Boolean} [skipParsing=false] Will make the Parser postpone parsing until you ask it
* explicitly. Same as `skipParsing` for {@link Parser}.
* @returns {Parser}
* @throws {Error} when UA is not a String
*
* @example
* const parser = Bowser.getParser(window.navigator.userAgent);
* const result = parser.getResult();
*/
static getParser(e, t = !1) {
if (typeof e != "string")
throw new Error("UserAgent should be a string");
return new j(e, t);
}
/**
* Creates a {@link Parser} instance and runs {@link Parser.getResult} immediately
*
* @param UA
* @return {ParsedResult}
*
* @example
* const result = Bowser.parse(window.navigator.userAgent);
*/
static parse(e) {
return new j(e).getResult();
}
static get BROWSER_MAP() {
return D;
}
static get ENGINE_MAP() {
return M;
}
static get OS_MAP() {
return m;
}
static get PLATFORMS_MAP() {
return u;
}
}
const V = typeof window < "u" ? window : null;
function Pe() {
if (!V)
return null;
switch (Ce.getParser(V.navigator.userAgent).getBrowserName()?.toLowerCase()) {
case "firefox":
return "firefox";
case "microsoft edge":
return "edge";
case "android browser":
case "chrome":
case "chromium":
case "electron":
case "opera":
case "vivaldi":
return "chrome";
default:
return null;
}
}
function G(r, e, t) {
let i = t;
i || (i = Pe());
const n = S(
r
), c = C(r), a = e?.find(
(f) => f.id === (n.id === "argentMobile" ? "argentX" : n.id)
)?.downloads;
return {
name: c ? r.name : n.name,
id: n.id,
icon: c ? r.icon : n.icon,
connector: r,
installed: !0,
title: "title" in n && N(n.title) ? n.title : void 0,
subtitle: "subtitle" in n && N(n.subtitle) ? n.subtitle : void 0,
download: a?.[i],
downloads: a
};
}
const qe = ({
availableConnectors: r,
installedWallets: e,
discoveryWallets: t,
storeVersion: i,
customOrder: n
}) => {
if (q())
return [];
const a = e.map(
(d) => Fe(r, d.id)
);
return (n ? r : [
...r.filter(
(d) => a.includes(S(d))
),
...r.filter(
(d) => !a.includes(S(d))
)
]).map((d) => {
const h = C(d), p = S(d), g = e.find((w) => w.id === p?.id);
if (g) {
let w, b;
h ? (w = d.icon, b = d.name) : (w = g.id === "argentX" ? { light: O, dark: O } : N(g.icon) ? { light: g.icon, dark: g.icon } : g.icon, b = g.id === "argentX" ? "Ready Wallet (formerly Argent)" : g.name);
const B = t.find(
(F) => F.id === (g.id === "argentMobile" ? "argentX" : p?.id)
)?.downloads;
return {
name: b,
id: g.id,
icon: w,
connector: d,
installed: !0,
download: B?.[i],
downloads: B
};
}
const v = t.filter(
(w) => !!w.downloads[i]
).find((w) => w.id === p?.id);
if (v) {
const { downloads: w } = v, b = v.id === "argentX" ? O : v.icon;
return {
name: v.name,
id: v.id,
icon: { light: b, dark: b },
connector: d,
installed: !1,
download: w[i],
downloads: w
};
}
return !p || !p.id || !p.name ? null : G(d, t);
}).filter((d) => d !== null);
};
class Re extends Z {
constructor(t) {
super();
A(this, "_wallet", null);
A(this, "_options");
this._options = t;
}
available() {
return !0;
}
async ready() {
if (!this._wallet)
return !1;
try {
return (await this._wallet.request({
type: "wallet_getPermissions"
})).includes($.ACCOUNTS);
} catch {
return !1;
}
}
get id() {
return "argentMobile";
}
get name() {
return "Ready (formerly Argent)";
}
get icon() {
return {
dark: I,
light: I
};
}
get wallet() {
if (!this._wallet)
throw new y();
return this._wallet;
}
async connect(t = {}) {
if (await this.ensureWallet({ onlyQRCode: t?.onlyQRCode }), !this._wallet)
throw new R();
const i = await this._wallet.request({
type: "wallet_requestAccounts"
}), n = await this.chainId();
return {
account: i[0],
chainId: n
};
}
async disconnect() {
if (await this._wallet.disable(), T(), !this.available() && !this._wallet)
throw new R();
this._wallet = null;
}
async account(t) {
if (!this._wallet)
throw new y();
const i = await this._wallet.request({
type: "wallet_requestAccounts",
params: { silent_mode: !0 }
});
return new K(t, this._wallet, i[0], void 0);
}
async chainId() {
if (!this._wallet)
throw new y();
const t = await this._wallet.request({
type: "wallet_requestChainId"
}), i = H(t);
return BigInt(i);
}
async request(t) {
if (!this._wallet)
throw new y();
try {
return await this._wallet.request(t);
} catch {
throw new E();
}
}
// needed, methods required by starknet-react. Otherwise an exception is throwd
async initEventListener(t) {
if (!this._wallet)
throw new y();
this._wallet.on("accountsChanged", t);
}
// needed, methods required by starknet-react. Otherwise an exception is throwd
async removeEventListener(t) {
if (!this._wallet)
throw new y();
this._wallet.off("accountsChanged", t), this._wallet = null;
}
async ensureWallet(t) {
const { getStarknetWindowObject: i } = await import("./index-e35b9ce9.js"), { chainId: n, projectId: c, dappName: a, description: f, url: l, icons: d, rpcUrl: h } = this._options, p = re(), g = h ?? (!n || n === P.NetworkName.SN_MAIN ? p.mainnet : p.testnet), v = (await U.getDiscoveryWallets()).map((F) => F.id.toLowerCase() === "argentx" ? {
...F,
name: "Ready Wallet (formerly Argent)"
} : F), w = {
onlyQRCode: t?.onlyQRCode,
chainId: n ?? P.NetworkName.SN_MAIN,
name: a,
projectId: c ?? L,
description: f,
url: l,
icons: d,
rpcUrl: g,
modalWallet: G(this, v)
};
c === L && (console.log("========= NOTICE ========="), console.log(
"While your application will continue to function, we highly recommended"
), console.log("signing up for your own API keys."), console.log(
"Go to WalletConnect Cloud (https://cloud.walletconnect.com) and create a new account."
), console.log(
"Once your account is created, create a new project and collect the Project ID"
), console.log("=========================="));
const b = await i(w);
if (!b)
throw new E();
this._wallet = b;
const B = this._wallet;
await B.enable(), B.client.on("session_delete", () => {
T(), this._wallet = null, J(), document.dispatchEvent(new Event("wallet_disconnected"));
});
}
}
class ze {
static init({
options: e,
inAppBrowserOptions: t
}) {
return q() ? new Y(t) : new Re(e);
}
}
export {
Re as A,
q as a,
G as b,
ze as c,
S as e,
Fe as f,
Pe as g,
C as i,
qe as m,
T as r
};