@walletconnect/modal-sign-html
Version:
#### 🔎 [Examples](https://github.com/WalletConnect/web3modal-examples)
1,504 lines (1,409 loc) • 498 kB
JavaScript
const t=Symbol();const s=Object.getPrototypeOf,c=new WeakMap,l=e=>e&&(c.has(e)?c.get(e):s(e)===Object.prototype||s(e)===Array.prototype),y$1=e=>l(e)&&e[t]||null,h$2=(e,t=!0)=>{c.set(e,t);};
const isObject = (x) => typeof x === "object" && x !== null;
const proxyStateMap = /* @__PURE__ */ new WeakMap();
const refSet = /* @__PURE__ */ new WeakSet();
const buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) => new Proxy(target, handler), canProxy = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer), defaultHandlePromise = (promise) => {
switch (promise.status) {
case "fulfilled":
return promise.value;
case "rejected":
throw promise.reason;
default:
throw promise;
}
}, snapCache = /* @__PURE__ */ new WeakMap(), createSnapshot = (target, version, handlePromise = defaultHandlePromise) => {
const cache = snapCache.get(target);
if ((cache == null ? void 0 : cache[0]) === version) {
return cache[1];
}
const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
h$2(snap, true);
snapCache.set(target, [version, snap]);
Reflect.ownKeys(target).forEach((key) => {
if (Object.getOwnPropertyDescriptor(snap, key)) {
return;
}
const value = Reflect.get(target, key);
const desc = {
value,
enumerable: true,
// This is intentional to avoid copying with proxy-compare.
// It's still non-writable, so it avoids assigning a value.
configurable: true
};
if (refSet.has(value)) {
h$2(value, false);
} else if (value instanceof Promise) {
delete desc.value;
desc.get = () => handlePromise(value);
} else if (proxyStateMap.has(value)) {
const [target2, ensureVersion] = proxyStateMap.get(
value
);
desc.value = createSnapshot(
target2,
ensureVersion(),
handlePromise
);
}
Object.defineProperty(snap, key, desc);
});
return Object.preventExtensions(snap);
}, proxyCache = /* @__PURE__ */ new WeakMap(), versionHolder = [1, 1], proxyFunction = (initialObject) => {
if (!isObject(initialObject)) {
throw new Error("object required");
}
const found = proxyCache.get(initialObject);
if (found) {
return found;
}
let version = versionHolder[0];
const listeners = /* @__PURE__ */ new Set();
const notifyUpdate = (op, nextVersion = ++versionHolder[0]) => {
if (version !== nextVersion) {
version = nextVersion;
listeners.forEach((listener) => listener(op, nextVersion));
}
};
let checkVersion = versionHolder[1];
const ensureVersion = (nextCheckVersion = ++versionHolder[1]) => {
if (checkVersion !== nextCheckVersion && !listeners.size) {
checkVersion = nextCheckVersion;
propProxyStates.forEach(([propProxyState]) => {
const propVersion = propProxyState[1](nextCheckVersion);
if (propVersion > version) {
version = propVersion;
}
});
}
return version;
};
const createPropListener = (prop) => (op, nextVersion) => {
const newOp = [...op];
newOp[1] = [prop, ...newOp[1]];
notifyUpdate(newOp, nextVersion);
};
const propProxyStates = /* @__PURE__ */ new Map();
const addPropListener = (prop, propProxyState) => {
if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && propProxyStates.has(prop)) {
throw new Error("prop listener already exists");
}
if (listeners.size) {
const remove = propProxyState[3](createPropListener(prop));
propProxyStates.set(prop, [propProxyState, remove]);
} else {
propProxyStates.set(prop, [propProxyState]);
}
};
const removePropListener = (prop) => {
var _a;
const entry = propProxyStates.get(prop);
if (entry) {
propProxyStates.delete(prop);
(_a = entry[1]) == null ? void 0 : _a.call(entry);
}
};
const addListener = (listener) => {
listeners.add(listener);
if (listeners.size === 1) {
propProxyStates.forEach(([propProxyState, prevRemove], prop) => {
if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && prevRemove) {
throw new Error("remove already exists");
}
const remove = propProxyState[3](createPropListener(prop));
propProxyStates.set(prop, [propProxyState, remove]);
});
}
const removeListener = () => {
listeners.delete(listener);
if (listeners.size === 0) {
propProxyStates.forEach(([propProxyState, remove], prop) => {
if (remove) {
remove();
propProxyStates.set(prop, [propProxyState]);
}
});
}
};
return removeListener;
};
const baseObject = Array.isArray(initialObject) ? [] : Object.create(Object.getPrototypeOf(initialObject));
const handler = {
deleteProperty(target, prop) {
const prevValue = Reflect.get(target, prop);
removePropListener(prop);
const deleted = Reflect.deleteProperty(target, prop);
if (deleted) {
notifyUpdate(["delete", [prop], prevValue]);
}
return deleted;
},
set(target, prop, value, receiver) {
const hasPrevValue = Reflect.has(target, prop);
const prevValue = Reflect.get(target, prop, receiver);
if (hasPrevValue && (objectIs(prevValue, value) || proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value)))) {
return true;
}
removePropListener(prop);
if (isObject(value)) {
value = y$1(value) || value;
}
let nextValue = value;
if (value instanceof Promise) {
value.then((v) => {
value.status = "fulfilled";
value.value = v;
notifyUpdate(["resolve", [prop], v]);
}).catch((e) => {
value.status = "rejected";
value.reason = e;
notifyUpdate(["reject", [prop], e]);
});
} else {
if (!proxyStateMap.has(value) && canProxy(value)) {
nextValue = proxyFunction(value);
}
const childProxyState = !refSet.has(nextValue) && proxyStateMap.get(nextValue);
if (childProxyState) {
addPropListener(prop, childProxyState);
}
}
Reflect.set(target, prop, nextValue, receiver);
notifyUpdate(["set", [prop], value, prevValue]);
return true;
}
};
const proxyObject = newProxy(baseObject, handler);
proxyCache.set(initialObject, proxyObject);
const proxyState = [
baseObject,
ensureVersion,
createSnapshot,
addListener
];
proxyStateMap.set(proxyObject, proxyState);
Reflect.ownKeys(initialObject).forEach((key) => {
const desc = Object.getOwnPropertyDescriptor(
initialObject,
key
);
if ("value" in desc) {
proxyObject[key] = initialObject[key];
delete desc.value;
delete desc.writable;
}
Object.defineProperty(baseObject, key, desc);
});
return proxyObject;
}) => [
// public functions
proxyFunction,
// shared state
proxyStateMap,
refSet,
// internal things
objectIs,
newProxy,
canProxy,
defaultHandlePromise,
snapCache,
createSnapshot,
proxyCache,
versionHolder
];
const [defaultProxyFunction] = buildProxyFunction();
function proxy(initialObject = {}) {
return defaultProxyFunction(initialObject);
}
function subscribe(proxyObject, callback, notifyInSync) {
const proxyState = proxyStateMap.get(proxyObject);
if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !proxyState) {
console.warn("Please use proxy object");
}
let promise;
const ops = [];
const addListener = proxyState[3];
let isListenerActive = false;
const listener = (op) => {
ops.push(op);
if (notifyInSync) {
callback(ops.splice(0));
return;
}
if (!promise) {
promise = Promise.resolve().then(() => {
promise = void 0;
if (isListenerActive) {
callback(ops.splice(0));
}
});
}
};
const removeListener = addListener(listener);
isListenerActive = true;
return () => {
isListenerActive = false;
removeListener();
};
}
function snapshot(proxyObject, handlePromise) {
const proxyState = proxyStateMap.get(proxyObject);
if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !proxyState) {
console.warn("Please use proxy object");
}
const [target, ensureVersion, createSnapshot] = proxyState;
return createSnapshot(target, ensureVersion(), handlePromise);
}
const state$7 = proxy({
history: ["ConnectWallet"],
view: "ConnectWallet",
data: void 0
});
const RouterCtrl = {
state: state$7,
subscribe(callback) {
return subscribe(state$7, () => callback(state$7));
},
push(view, data) {
if (view !== state$7.view) {
state$7.view = view;
if (data) {
state$7.data = data;
}
state$7.history.push(view);
}
},
reset(view) {
state$7.view = view;
state$7.history = [view];
},
replace(view) {
if (state$7.history.length > 1) {
state$7.history[state$7.history.length - 1] = view;
state$7.view = view;
}
},
goBack() {
if (state$7.history.length > 1) {
state$7.history.pop();
const [last] = state$7.history.slice(-1);
state$7.view = last;
}
},
setData(data) {
state$7.data = data;
}
};
const CoreUtil = {
WALLETCONNECT_DEEPLINK_CHOICE: "WALLETCONNECT_DEEPLINK_CHOICE",
WCM_VERSION: "WCM_VERSION",
RECOMMENDED_WALLET_AMOUNT: 9,
isMobile() {
if (typeof window !== "undefined") {
return Boolean(
window.matchMedia("(pointer:coarse)").matches || /Android|webOS|iPhone|iPad|iPod|BlackBerry|Opera Mini/u.test(navigator.userAgent)
);
}
return false;
},
isAndroid() {
return CoreUtil.isMobile() && navigator.userAgent.toLowerCase().includes("android");
},
isIos() {
const ua = navigator.userAgent.toLowerCase();
return CoreUtil.isMobile() && (ua.includes("iphone") || ua.includes("ipad"));
},
isHttpUrl(url) {
return url.startsWith("http://") || url.startsWith("https://");
},
isArray(data) {
return Array.isArray(data) && data.length > 0;
},
isTelegram() {
return typeof window !== "undefined" && // eslint-disable-next-line @typescript-eslint/no-explicit-any
(Boolean(window.TelegramWebviewProxy) || // eslint-disable-next-line @typescript-eslint/no-explicit-any
Boolean(window.Telegram) || // eslint-disable-next-line @typescript-eslint/no-explicit-any
Boolean(window.TelegramWebviewProxyProto));
},
formatNativeUrl(appUrl, wcUri, name) {
if (CoreUtil.isHttpUrl(appUrl)) {
return this.formatUniversalUrl(appUrl, wcUri, name);
}
let safeAppUrl = appUrl;
if (!safeAppUrl.includes("://")) {
safeAppUrl = appUrl.replaceAll("/", "").replaceAll(":", "");
safeAppUrl = `${safeAppUrl}://`;
}
if (!safeAppUrl.endsWith("/")) {
safeAppUrl = `${safeAppUrl}/`;
}
this.setWalletConnectDeepLink(safeAppUrl, name);
const encodedWcUrl = encodeURIComponent(wcUri);
return `${safeAppUrl}wc?uri=${encodedWcUrl}`;
},
formatUniversalUrl(appUrl, wcUri, name) {
if (!CoreUtil.isHttpUrl(appUrl)) {
return this.formatNativeUrl(appUrl, wcUri, name);
}
let safeAppUrl = appUrl;
if (safeAppUrl.startsWith("https://t.me")) {
const formattedUri = Buffer.from(wcUri).toString("base64").replace(/[=]/g, "");
if (safeAppUrl.endsWith("/")) {
safeAppUrl = safeAppUrl.slice(0, -1);
}
this.setWalletConnectDeepLink(safeAppUrl, name);
const url = new URL(safeAppUrl);
url.searchParams.set("startapp", formattedUri);
const link = url.toString();
return link;
}
if (!safeAppUrl.endsWith("/")) {
safeAppUrl = `${safeAppUrl}/`;
}
this.setWalletConnectDeepLink(safeAppUrl, name);
const encodedWcUrl = encodeURIComponent(wcUri);
return `${safeAppUrl}wc?uri=${encodedWcUrl}`;
},
async wait(miliseconds) {
return new Promise((resolve) => {
setTimeout(resolve, miliseconds);
});
},
openHref(href, target) {
const adjustedTarget = this.isTelegram() ? "_blank" : target;
window.open(href, adjustedTarget, "noreferrer noopener");
},
setWalletConnectDeepLink(href, name) {
try {
localStorage.setItem(CoreUtil.WALLETCONNECT_DEEPLINK_CHOICE, JSON.stringify({ href, name }));
} catch (e) {
console.info("Unable to set WalletConnect deep link");
}
},
setWalletConnectAndroidDeepLink(wcUri) {
try {
const [href] = wcUri.split("?");
localStorage.setItem(
CoreUtil.WALLETCONNECT_DEEPLINK_CHOICE,
JSON.stringify({ href, name: "Android" })
);
} catch (e) {
console.info("Unable to set WalletConnect android deep link");
}
},
removeWalletConnectDeepLink() {
try {
localStorage.removeItem(CoreUtil.WALLETCONNECT_DEEPLINK_CHOICE);
} catch (e) {
console.info("Unable to remove WalletConnect deep link");
}
},
setModalVersionInStorage() {
try {
if (typeof localStorage !== "undefined") {
localStorage.setItem(CoreUtil.WCM_VERSION, "2.7.0");
}
} catch (e) {
console.info("Unable to set Web3Modal version in storage");
}
},
getWalletRouterData() {
var _a;
const routerData = (_a = RouterCtrl.state.data) == null ? void 0 : _a.Wallet;
if (!routerData) {
throw new Error('Missing "Wallet" view data');
}
return routerData;
}
};
const isEnabled = typeof location !== "undefined" && (location.hostname.includes("localhost") || location.protocol.includes("https"));
const state$6 = proxy({
enabled: isEnabled,
userSessionId: "",
events: [],
connectedWalletId: void 0
});
const EventsCtrl = {
state: state$6,
subscribe(callback) {
return subscribe(state$6.events, () => callback(snapshot(state$6.events[state$6.events.length - 1])));
},
initialize() {
if (state$6.enabled && typeof (crypto == null ? void 0 : crypto.randomUUID) !== "undefined") {
state$6.userSessionId = crypto.randomUUID();
}
},
setConnectedWalletId(connectedWalletId) {
state$6.connectedWalletId = connectedWalletId;
},
click(data) {
if (state$6.enabled) {
const event = {
type: "CLICK",
name: data.name,
userSessionId: state$6.userSessionId,
timestamp: Date.now(),
data
};
state$6.events.push(event);
}
},
track(data) {
if (state$6.enabled) {
const event = {
type: "TRACK",
name: data.name,
userSessionId: state$6.userSessionId,
timestamp: Date.now(),
data
};
state$6.events.push(event);
}
},
view(data) {
if (state$6.enabled) {
const event = {
type: "VIEW",
name: data.name,
userSessionId: state$6.userSessionId,
timestamp: Date.now(),
data
};
state$6.events.push(event);
}
}
};
const state$5 = proxy({
chains: void 0,
walletConnectUri: void 0,
isAuth: false,
isCustomDesktop: false,
isCustomMobile: false,
isDataLoaded: false,
isUiLoaded: false
});
const OptionsCtrl = {
state: state$5,
subscribe(callback) {
return subscribe(state$5, () => callback(state$5));
},
setChains(chains) {
state$5.chains = chains;
},
setWalletConnectUri(walletConnectUri) {
state$5.walletConnectUri = walletConnectUri;
},
setIsCustomDesktop(isCustomDesktop) {
state$5.isCustomDesktop = isCustomDesktop;
},
setIsCustomMobile(isCustomMobile) {
state$5.isCustomMobile = isCustomMobile;
},
setIsDataLoaded(isDataLoaded) {
state$5.isDataLoaded = isDataLoaded;
},
setIsUiLoaded(isUiLoaded) {
state$5.isUiLoaded = isUiLoaded;
},
setIsAuth(isAuth) {
state$5.isAuth = isAuth;
}
};
const state$4 = proxy({
projectId: "",
mobileWallets: void 0,
desktopWallets: void 0,
walletImages: void 0,
chains: void 0,
enableAuthMode: false,
enableExplorer: true,
explorerExcludedWalletIds: void 0,
explorerRecommendedWalletIds: void 0,
termsOfServiceUrl: void 0,
privacyPolicyUrl: void 0
});
const ConfigCtrl = {
state: state$4,
subscribe(callback) {
return subscribe(state$4, () => callback(state$4));
},
setConfig(config) {
var _a, _b;
EventsCtrl.initialize();
OptionsCtrl.setChains(config.chains);
OptionsCtrl.setIsAuth(Boolean(config.enableAuthMode));
OptionsCtrl.setIsCustomMobile(Boolean((_a = config.mobileWallets) == null ? void 0 : _a.length));
OptionsCtrl.setIsCustomDesktop(Boolean((_b = config.desktopWallets) == null ? void 0 : _b.length));
CoreUtil.setModalVersionInStorage();
Object.assign(state$4, config);
}
};
var __defProp$2 = Object.defineProperty;
var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$2 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$2.call(b, prop))
__defNormalProp$2(a, prop, b[prop]);
if (__getOwnPropSymbols$2)
for (var prop of __getOwnPropSymbols$2(b)) {
if (__propIsEnum$2.call(b, prop))
__defNormalProp$2(a, prop, b[prop]);
}
return a;
};
const W3M_API = "https://explorer-api.walletconnect.com";
const SDK_TYPE = "wcm";
const SDK_VERSION = `js-${"2.7.0"}`;
async function fetchListings(endpoint, params) {
const allParams = __spreadValues$2({ sdkType: SDK_TYPE, sdkVersion: SDK_VERSION }, params);
const url = new URL(endpoint, W3M_API);
url.searchParams.append("projectId", ConfigCtrl.state.projectId);
Object.entries(allParams).forEach(([key, value]) => {
if (value) {
url.searchParams.append(key, String(value));
}
});
const request = await fetch(url);
return request.json();
}
const ExplorerUtil = {
async getDesktopListings(params) {
return fetchListings("/w3m/v1/getDesktopListings", params);
},
async getMobileListings(params) {
return fetchListings("/w3m/v1/getMobileListings", params);
},
async getInjectedListings(params) {
return fetchListings("/w3m/v1/getInjectedListings", params);
},
async getAllListings(params) {
return fetchListings("/w3m/v1/getAllListings", params);
},
getWalletImageUrl(imageId) {
return `${W3M_API}/w3m/v1/getWalletImage/${imageId}?projectId=${ConfigCtrl.state.projectId}&sdkType=${SDK_TYPE}&sdkVersion=${SDK_VERSION}`;
},
getAssetImageUrl(imageId) {
return `${W3M_API}/w3m/v1/getAssetImage/${imageId}?projectId=${ConfigCtrl.state.projectId}&sdkType=${SDK_TYPE}&sdkVersion=${SDK_VERSION}`;
}
};
var __defProp$1 = Object.defineProperty;
var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$1 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$1.call(b, prop))
__defNormalProp$1(a, prop, b[prop]);
if (__getOwnPropSymbols$1)
for (var prop of __getOwnPropSymbols$1(b)) {
if (__propIsEnum$1.call(b, prop))
__defNormalProp$1(a, prop, b[prop]);
}
return a;
};
const isMobile = CoreUtil.isMobile();
const state$3 = proxy({
wallets: { listings: [], total: 0, page: 1 },
search: { listings: [], total: 0, page: 1 },
recomendedWallets: []
});
const ExplorerCtrl = {
state: state$3,
async getRecomendedWallets() {
const { explorerRecommendedWalletIds, explorerExcludedWalletIds } = ConfigCtrl.state;
if (explorerRecommendedWalletIds === "NONE" || explorerExcludedWalletIds === "ALL" && !explorerRecommendedWalletIds) {
return state$3.recomendedWallets;
}
if (CoreUtil.isArray(explorerRecommendedWalletIds)) {
const recommendedIds = explorerRecommendedWalletIds.join(",");
const params = { recommendedIds };
const { listings } = await ExplorerUtil.getAllListings(params);
const listingsArr = Object.values(listings);
listingsArr.sort((a, b) => {
const aIndex = explorerRecommendedWalletIds.indexOf(a.id);
const bIndex = explorerRecommendedWalletIds.indexOf(b.id);
return aIndex - bIndex;
});
state$3.recomendedWallets = listingsArr;
} else {
const { chains, isAuth } = OptionsCtrl.state;
const chainsFilter = chains == null ? void 0 : chains.join(",");
const isExcluded = CoreUtil.isArray(explorerExcludedWalletIds);
const params = {
page: 1,
sdks: isAuth ? "auth_v1" : void 0,
entries: CoreUtil.RECOMMENDED_WALLET_AMOUNT,
chains: chainsFilter,
version: 2,
excludedIds: isExcluded ? explorerExcludedWalletIds.join(",") : void 0
};
const { listings } = isMobile ? await ExplorerUtil.getMobileListings(params) : await ExplorerUtil.getDesktopListings(params);
state$3.recomendedWallets = Object.values(listings);
}
return state$3.recomendedWallets;
},
async getWallets(params) {
const extendedParams = __spreadValues$1({}, params);
const { explorerRecommendedWalletIds, explorerExcludedWalletIds } = ConfigCtrl.state;
const { recomendedWallets } = state$3;
if (explorerExcludedWalletIds === "ALL") {
return state$3.wallets;
}
if (recomendedWallets.length) {
extendedParams.excludedIds = recomendedWallets.map((wallet) => wallet.id).join(",");
} else if (CoreUtil.isArray(explorerRecommendedWalletIds)) {
extendedParams.excludedIds = explorerRecommendedWalletIds.join(",");
}
if (CoreUtil.isArray(explorerExcludedWalletIds)) {
extendedParams.excludedIds = [extendedParams.excludedIds, explorerExcludedWalletIds].filter(Boolean).join(",");
}
if (OptionsCtrl.state.isAuth) {
extendedParams.sdks = "auth_v1";
}
const { page, search } = params;
const { listings: listingsObj, total } = isMobile ? await ExplorerUtil.getMobileListings(extendedParams) : await ExplorerUtil.getDesktopListings(extendedParams);
const listings = Object.values(listingsObj);
const type = search ? "search" : "wallets";
state$3[type] = {
listings: [...state$3[type].listings, ...listings],
total,
page: page != null ? page : 1
};
return { listings, total };
},
getWalletImageUrl(imageId) {
return ExplorerUtil.getWalletImageUrl(imageId);
},
getAssetImageUrl(imageId) {
return ExplorerUtil.getAssetImageUrl(imageId);
},
resetSearch() {
state$3.search = { listings: [], total: 0, page: 1 };
}
};
const state$2 = proxy({
open: false
});
const ModalCtrl = {
state: state$2,
subscribe(callback) {
return subscribe(state$2, () => callback(state$2));
},
async open(options) {
return new Promise((resolve) => {
const { isUiLoaded, isDataLoaded } = OptionsCtrl.state;
CoreUtil.removeWalletConnectDeepLink();
OptionsCtrl.setWalletConnectUri(options == null ? void 0 : options.uri);
OptionsCtrl.setChains(options == null ? void 0 : options.chains);
RouterCtrl.reset("ConnectWallet");
if (isUiLoaded && isDataLoaded) {
state$2.open = true;
resolve();
} else {
const interval = setInterval(() => {
const opts = OptionsCtrl.state;
if (opts.isUiLoaded && opts.isDataLoaded) {
clearInterval(interval);
state$2.open = true;
resolve();
}
}, 200);
}
});
},
close() {
state$2.open = false;
}
};
var __defProp$3 = Object.defineProperty;
var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$3 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$3.call(b, prop))
__defNormalProp$3(a, prop, b[prop]);
if (__getOwnPropSymbols$3)
for (var prop of __getOwnPropSymbols$3(b)) {
if (__propIsEnum$3.call(b, prop))
__defNormalProp$3(a, prop, b[prop]);
}
return a;
};
function isDarkMode() {
return typeof matchMedia !== "undefined" && matchMedia("(prefers-color-scheme: dark)").matches;
}
const state$1 = proxy({
themeMode: isDarkMode() ? "dark" : "light"
});
const ThemeCtrl = {
state: state$1,
subscribe(callback) {
return subscribe(state$1, () => callback(state$1));
},
setThemeConfig(theme) {
const { themeMode, themeVariables } = theme;
if (themeMode) {
state$1.themeMode = themeMode;
}
if (themeVariables) {
state$1.themeVariables = __spreadValues$3({}, themeVariables);
}
}
};
const state = proxy({
open: false,
message: "",
variant: "success"
});
const ToastCtrl = {
state,
subscribe(callback) {
return subscribe(state, () => callback(state));
},
openToast(message, variant) {
state.open = true;
state.message = message;
state.variant = variant;
},
closeToast() {
state.open = false;
}
};
class WalletConnectModal {
constructor(config) {
this.openModal = ModalCtrl.open;
this.closeModal = ModalCtrl.close;
this.subscribeModal = ModalCtrl.subscribe;
this.setTheme = ThemeCtrl.setThemeConfig;
ThemeCtrl.setThemeConfig(config);
ConfigCtrl.setConfig(config);
this.initUi();
}
async initUi() {
if (typeof window !== "undefined") {
await import('./index-fb46b9c0.js');
const modal = document.createElement("wcm-modal");
document.body.insertAdjacentElement("beforeend", modal);
OptionsCtrl.setIsUiLoaded(true);
}
}
}
var domain;
// This constructor is used to store event handlers. Instantiating this is
// faster than explicitly calling `Object.create(null)` to get a "clean" empty
// object (tested with v8 v4.9).
function EventHandlers() {}
EventHandlers.prototype = Object.create(null);
function EventEmitter() {
EventEmitter.init.call(this);
}
// nodejs oddity
// require('events') === require('events').EventEmitter
EventEmitter.EventEmitter = EventEmitter;
EventEmitter.usingDomains = false;
EventEmitter.prototype.domain = undefined;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;
// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
EventEmitter.defaultMaxListeners = 10;
EventEmitter.init = function() {
this.domain = null;
if (EventEmitter.usingDomains) {
// if there is an active domain, then attach to it.
if (domain.active ) ;
}
if (!this._events || this._events === Object.getPrototypeOf(this)._events) {
this._events = new EventHandlers();
this._eventsCount = 0;
}
this._maxListeners = this._maxListeners || undefined;
};
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
if (typeof n !== 'number' || n < 0 || isNaN(n))
throw new TypeError('"n" argument must be a positive number');
this._maxListeners = n;
return this;
};
function $getMaxListeners(that) {
if (that._maxListeners === undefined)
return EventEmitter.defaultMaxListeners;
return that._maxListeners;
}
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
return $getMaxListeners(this);
};
// These standalone emit* functions are used to optimize calling of event
// handlers for fast cases because emit() itself often has a variable number of
// arguments and can be deoptimized because of that. These functions always have
// the same number of arguments and thus do not get deoptimized, so the code
// inside them can execute faster.
function emitNone(handler, isFn, self) {
if (isFn)
handler.call(self);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].call(self);
}
}
function emitOne(handler, isFn, self, arg1) {
if (isFn)
handler.call(self, arg1);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].call(self, arg1);
}
}
function emitTwo(handler, isFn, self, arg1, arg2) {
if (isFn)
handler.call(self, arg1, arg2);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].call(self, arg1, arg2);
}
}
function emitThree(handler, isFn, self, arg1, arg2, arg3) {
if (isFn)
handler.call(self, arg1, arg2, arg3);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].call(self, arg1, arg2, arg3);
}
}
function emitMany(handler, isFn, self, args) {
if (isFn)
handler.apply(self, args);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
listeners[i].apply(self, args);
}
}
EventEmitter.prototype.emit = function emit(type) {
var er, handler, len, args, i, events, domain;
var doError = (type === 'error');
events = this._events;
if (events)
doError = (doError && events.error == null);
else if (!doError)
return false;
domain = this.domain;
// If there is no 'error' event listener then throw.
if (doError) {
er = arguments[1];
if (domain) {
if (!er)
er = new Error('Uncaught, unspecified "error" event');
er.domainEmitter = this;
er.domain = domain;
er.domainThrown = false;
domain.emit('error', er);
} else if (er instanceof Error) {
throw er; // Unhandled 'error' event
} else {
// At least give some kind of context to the user
var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
err.context = er;
throw err;
}
return false;
}
handler = events[type];
if (!handler)
return false;
var isFn = typeof handler === 'function';
len = arguments.length;
switch (len) {
// fast cases
case 1:
emitNone(handler, isFn, this);
break;
case 2:
emitOne(handler, isFn, this, arguments[1]);
break;
case 3:
emitTwo(handler, isFn, this, arguments[1], arguments[2]);
break;
case 4:
emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
break;
// slower
default:
args = new Array(len - 1);
for (i = 1; i < len; i++)
args[i - 1] = arguments[i];
emitMany(handler, isFn, this, args);
}
return true;
};
function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;
if (typeof listener !== 'function')
throw new TypeError('"listener" argument must be a function');
events = target._events;
if (!events) {
events = target._events = new EventHandlers();
target._eventsCount = 0;
} else {
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (events.newListener) {
target.emit('newListener', type,
listener.listener ? listener.listener : listener);
// Re-assign `events` because a newListener handler could have caused the
// this._events to be assigned to a new object
events = target._events;
}
existing = events[type];
}
if (!existing) {
// Optimize the case of one listener. Don't need the extra array object.
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === 'function') {
// Adding the second element, need to change to array.
existing = events[type] = prepend ? [listener, existing] :
[existing, listener];
} else {
// If we've already got an array, just append.
if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
}
// Check for listener leak
if (!existing.warned) {
m = $getMaxListeners(target);
if (m && m > 0 && existing.length > m) {
existing.warned = true;
var w = new Error('Possible EventEmitter memory leak detected. ' +
existing.length + ' ' + type + ' listeners added. ' +
'Use emitter.setMaxListeners() to increase limit');
w.name = 'MaxListenersExceededWarning';
w.emitter = target;
w.type = type;
w.count = existing.length;
emitWarning(w);
}
}
}
return target;
}
function emitWarning(e) {
typeof console.warn === 'function' ? console.warn(e) : console.log(e);
}
EventEmitter.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.prependListener =
function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};
function _onceWrap(target, type, listener) {
var fired = false;
function g() {
target.removeListener(type, g);
if (!fired) {
fired = true;
listener.apply(target, arguments);
}
}
g.listener = listener;
return g;
}
EventEmitter.prototype.once = function once(type, listener) {
if (typeof listener !== 'function')
throw new TypeError('"listener" argument must be a function');
this.on(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.prependOnceListener =
function prependOnceListener(type, listener) {
if (typeof listener !== 'function')
throw new TypeError('"listener" argument must be a function');
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
// emits a 'removeListener' event iff the listener was removed
EventEmitter.prototype.removeListener =
function removeListener(type, listener) {
var list, events, position, i, originalListener;
if (typeof listener !== 'function')
throw new TypeError('"listener" argument must be a function');
events = this._events;
if (!events)
return this;
list = events[type];
if (!list)
return this;
if (list === listener || (list.listener && list.listener === listener)) {
if (--this._eventsCount === 0)
this._events = new EventHandlers();
else {
delete events[type];
if (events.removeListener)
this.emit('removeListener', type, list.listener || listener);
}
} else if (typeof list !== 'function') {
position = -1;
for (i = list.length; i-- > 0;) {
if (list[i] === listener ||
(list[i].listener && list[i].listener === listener)) {
originalListener = list[i].listener;
position = i;
break;
}
}
if (position < 0)
return this;
if (list.length === 1) {
list[0] = undefined;
if (--this._eventsCount === 0) {
this._events = new EventHandlers();
return this;
} else {
delete events[type];
}
} else {
spliceOne(list, position);
}
if (events.removeListener)
this.emit('removeListener', type, originalListener || listener);
}
return this;
};
// Alias for removeListener added in NodeJS 10.0
// https://nodejs.org/api/events.html#events_emitter_off_eventname_listener
EventEmitter.prototype.off = function(type, listener){
return this.removeListener(type, listener);
};
EventEmitter.prototype.removeAllListeners =
function removeAllListeners(type) {
var listeners, events;
events = this._events;
if (!events)
return this;
// not listening for removeListener, no need to emit
if (!events.removeListener) {
if (arguments.length === 0) {
this._events = new EventHandlers();
this._eventsCount = 0;
} else if (events[type]) {
if (--this._eventsCount === 0)
this._events = new EventHandlers();
else
delete events[type];
}
return this;
}
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
var keys = Object.keys(events);
for (var i = 0, key; i < keys.length; ++i) {
key = keys[i];
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = new EventHandlers();
this._eventsCount = 0;
return this;
}
listeners = events[type];
if (typeof listeners === 'function') {
this.removeListener(type, listeners);
} else if (listeners) {
// LIFO order
do {
this.removeListener(type, listeners[listeners.length - 1]);
} while (listeners[0]);
}
return this;
};
EventEmitter.prototype.listeners = function listeners(type) {
var evlistener;
var ret;
var events = this._events;
if (!events)
ret = [];
else {
evlistener = events[type];
if (!evlistener)
ret = [];
else if (typeof evlistener === 'function')
ret = [evlistener.listener || evlistener];
else
ret = unwrapListeners(evlistener);
}
return ret;
};
EventEmitter.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === 'function') {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
};
EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events = this._events;
if (events) {
var evlistener = events[type];
if (typeof evlistener === 'function') {
return 1;
} else if (evlistener) {
return evlistener.length;
}
}
return 0;
}
EventEmitter.prototype.eventNames = function eventNames() {
return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
};
// About 1.5x faster than the two-arg version of Array#splice().
function spliceOne(list, index) {
for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
list[i] = list[k];
list.pop();
}
function arrayClone(arr, i) {
var copy = new Array(i);
while (i--)
copy[i] = arr[i];
return copy;
}
function unwrapListeners(arr) {
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
}
var _polyfillNode_events = /*#__PURE__*/Object.freeze({
__proto__: null,
EventEmitter: EventEmitter,
default: EventEmitter
});
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
function getAugmentedNamespace(n) {
if (n.__esModule) return n;
var f = n.default;
if (typeof f == "function") {
var a = function a () {
if (this instanceof a) {
return Reflect.construct(f, arguments, this.constructor);
}
return f.apply(this, arguments);
};
a.prototype = f.prototype;
} else a = {};
Object.defineProperty(a, '__esModule', {value: true});
Object.keys(n).forEach(function (k) {
var d = Object.getOwnPropertyDescriptor(n, k);
Object.defineProperty(a, k, d.get ? d : {
enumerable: true,
get: function () {
return n[k];
}
});
});
return a;
}
var browser$2 = {};
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics$4 = function(d, b) {
extendStatics$4 = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics$4(d, b);
};
function __extends$4(d, b) {
extendStatics$4(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign$4 = function() {
__assign$4 = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign$4.apply(this, arguments);
};
function __rest$4(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate$4(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param$4(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
}
function __metadata$4(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter$4(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator$4(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
function __createBinding$4(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}
function __exportStar$4(m, exports) {
for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
}
function __values$4(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read$4(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
function __spread$4() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read$4(arguments[i]));
return ar;
}
function __spreadArrays$4() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
function __await$4(v) {
return this instanceof __await$4 ? (this.v = v, this) : new __await$4(v);
}
function __asyncGenerator$4(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
function step(r) { r.value instanceof __await$4 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
}
function __asyncDelegator$4(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await$4(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues$4(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values$4 === "function" ? __values$4(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject$4(cooked, raw) {
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
return cooked;
}
function __importStar$4(mod) {
if (mod && mod.__esModule) return mod;
va