@secondlayer/stacks 0.0.1

package/dist/src/connect/walletconnect/index.cjs

@@ -0,0 +1,1322 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/connect/walletconnect/index.ts
+var exports_walletconnect = {};
+__export(exports_walletconnect, {
+  showModal: () => showModal,
+  qrSvg: () => qrSvg,
+  hideModal: () => hideModal,
+  WcSession: () => WcSession,
+  WcRelay: () => WcRelay,
+  WalletConnectProvider: () => WalletConnectProvider
+});
+module.exports = __toCommonJS(exports_walletconnect);
+
+// src/connect/walletconnect/crypto.ts
+var import_ed25519 = require("@noble/curves/ed25519.js");
+var import_sha2 = require("@noble/hashes/sha2.js");
+var import_hkdf = require("@noble/hashes/hkdf.js");
+var import_utils = require("@noble/hashes/utils.js");
+var import_aes = require("@noble/ciphers/aes.js");
+
+// ../../node_modules/@scure/base/index.js
+/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(b) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr))
+    return false;
+  if (arr.length === 0)
+    return true;
+  if (isString) {
+    return arr.every((item) => typeof item === "string");
+  } else {
+    return arr.every((item) => Number.isSafeInteger(item));
+  }
+}
+function afn(input) {
+  if (typeof input !== "function")
+    throw new Error("function expected");
+  return true;
+}
+function astr(label, input) {
+  if (typeof input !== "string")
+    throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n))
+    throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input))
+    throw new Error("array expected");
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input))
+    throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input))
+    throw new Error(`${label}: array of numbers expected`);
+}
+function chain(...args) {
+  const id = (a) => a;
+  const wrap = (a, b) => (c) => a(b(c));
+  const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+  const decode = args.map((x) => x.decode).reduce(wrap, id);
+  return { encode, decode };
+}
+function alphabet(letters) {
+  const lettersA = typeof letters === "string" ? letters.split("") : letters;
+  const len = lettersA.length;
+  astrArr("alphabet", lettersA);
+  const indexes = new Map(lettersA.map((l, i) => [l, i]));
+  return {
+    encode: (digits) => {
+      aArr(digits);
+      return digits.map((i) => {
+        if (!Number.isSafeInteger(i) || i < 0 || i >= len)
+          throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
+        return lettersA[i];
+      });
+    },
+    decode: (input) => {
+      aArr(input);
+      return input.map((letter) => {
+        astr("alphabet.decode", letter);
+        const i = indexes.get(letter);
+        if (i === undefined)
+          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i;
+      });
+    }
+  };
+}
+function join(separator = "") {
+  astr("join", separator);
+  return {
+    encode: (from) => {
+      astrArr("join.decode", from);
+      return from.join(separator);
+    },
+    decode: (to) => {
+      astr("join.decode", to);
+      return to.split(separator);
+    }
+  };
+}
+function padding(bits, chr = "=") {
+  anumber(bits);
+  astr("padding", chr);
+  return {
+    encode(data) {
+      astrArr("padding.encode", data);
+      while (data.length * bits % 8)
+        data.push(chr);
+      return data;
+    },
+    decode(input) {
+      astrArr("padding.decode", input);
+      let end = input.length;
+      if (end * bits % 8)
+        throw new Error("padding: invalid, string should have whole number of bytes");
+      for (;end > 0 && input[end - 1] === chr; end--) {
+        const last = end - 1;
+        const byte = last * bits;
+        if (byte % 8 === 0)
+          throw new Error("padding: invalid, string has too much padding");
+      }
+      return input.slice(0, end);
+    }
+  };
+}
+function normalize(fn) {
+  afn(fn);
+  return { encode: (from) => from, decode: (to) => fn(to) };
+}
+function convertRadix(data, from, to) {
+  if (from < 2)
+    throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+  if (to < 2)
+    throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+  aArr(data);
+  if (!data.length)
+    return [];
+  let pos = 0;
+  const res = [];
+  const digits = Array.from(data, (d) => {
+    anumber(d);
+    if (d < 0 || d >= from)
+      throw new Error(`invalid integer: ${d}`);
+    return d;
+  });
+  const dlen = digits.length;
+  while (true) {
+    let carry = 0;
+    let done = true;
+    for (let i = pos;i < dlen; i++) {
+      const digit = digits[i];
+      const fromCarry = from * carry;
+      const digitBase = fromCarry + digit;
+      if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) {
+        throw new Error("convertRadix: carry overflow");
+      }
+      const div = digitBase / to;
+      carry = digitBase % to;
+      const rounded = Math.floor(div);
+      digits[i] = rounded;
+      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+        throw new Error("convertRadix: carry overflow");
+      if (!done)
+        continue;
+      else if (!rounded)
+        pos = i;
+      else
+        done = false;
+    }
+    res.push(carry);
+    if (done)
+      break;
+  }
+  for (let i = 0;i < data.length - 1 && data[i] === 0; i++)
+    res.push(0);
+  return res.reverse();
+}
+var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+var radix2carry = (from, to) => from + (to - gcd(from, to));
+var powers = /* @__PURE__ */ (() => {
+  let res = [];
+  for (let i = 0;i < 40; i++)
+    res.push(2 ** i);
+  return res;
+})();
+function convertRadix2(data, from, to, padding2) {
+  aArr(data);
+  if (from <= 0 || from > 32)
+    throw new Error(`convertRadix2: wrong from=${from}`);
+  if (to <= 0 || to > 32)
+    throw new Error(`convertRadix2: wrong to=${to}`);
+  if (radix2carry(from, to) > 32) {
+    throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`);
+  }
+  let carry = 0;
+  let pos = 0;
+  const max = powers[from];
+  const mask = powers[to] - 1;
+  const res = [];
+  for (const n of data) {
+    anumber(n);
+    if (n >= max)
+      throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+    carry = carry << from | n;
+    if (pos + from > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+    pos += from;
+    for (;pos >= to; pos -= to)
+      res.push((carry >> pos - to & mask) >>> 0);
+    const pow = powers[pos];
+    if (pow === undefined)
+      throw new Error("invalid carry");
+    carry &= pow - 1;
+  }
+  carry = carry << to - pos & mask;
+  if (!padding2 && pos >= from)
+    throw new Error("Excess padding");
+  if (!padding2 && carry > 0)
+    throw new Error(`Non-zero padding: ${carry}`);
+  if (padding2 && pos > 0)
+    res.push(carry >>> 0);
+  return res;
+}
+function radix(num) {
+  anumber(num);
+  const _256 = 2 ** 8;
+  return {
+    encode: (bytes) => {
+      if (!isBytes(bytes))
+        throw new Error("radix.encode input should be Uint8Array");
+      return convertRadix(Array.from(bytes), _256, num);
+    },
+    decode: (digits) => {
+      anumArr("radix.decode", digits);
+      return Uint8Array.from(convertRadix(digits, num, _256));
+    }
+  };
+}
+function radix2(bits, revPadding = false) {
+  anumber(bits);
+  if (bits <= 0 || bits > 32)
+    throw new Error("radix2: bits should be in (0..32]");
+  if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (bytes) => {
+      if (!isBytes(bytes))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+    },
+    decode: (digits) => {
+      anumArr("radix2.decode", digits);
+      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+    }
+  };
+}
+function unsafeWrapper(fn) {
+  afn(fn);
+  return function(...args) {
+    try {
+      return fn.apply(null, args);
+    } catch (e) {}
+  };
+}
+var base16 = chain(radix2(4), alphabet("0123456789ABCDEF"), join(""));
+var base32 = chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding(5), join(""));
+var base32nopad = chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), join(""));
+var base32hex = chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), padding(5), join(""));
+var base32hexnopad = chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), join(""));
+var base32crockford = chain(radix2(5), alphabet("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), join(""), normalize((s) => s.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1")));
+var hasBase64Builtin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toBase64 === "function" && typeof Uint8Array.fromBase64 === "function")();
+var decodeBase64Builtin = (s, isUrl) => {
+  astr("base64", s);
+  const re = isUrl ? /^[A-Za-z0-9=_-]+$/ : /^[A-Za-z0-9=+/]+$/;
+  const alphabet2 = isUrl ? "base64url" : "base64";
+  if (s.length > 0 && !re.test(s))
+    throw new Error("invalid base64");
+  return Uint8Array.fromBase64(s, { alphabet: alphabet2, lastChunkHandling: "strict" });
+};
+var base64 = hasBase64Builtin ? {
+  encode(b) {
+    abytes(b);
+    return b.toBase64();
+  },
+  decode(s) {
+    return decodeBase64Builtin(s, false);
+  }
+} : chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding(6), join(""));
+var base64nopad = chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), join(""));
+var base64url = hasBase64Builtin ? {
+  encode(b) {
+    abytes(b);
+    return b.toBase64({ alphabet: "base64url" });
+  },
+  decode(s) {
+    return decodeBase64Builtin(s, true);
+  }
+} : chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding(6), join(""));
+var base64urlnopad = chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), join(""));
+var genBase58 = (abc) => chain(radix(58), alphabet(abc), join(""));
+var base58 = genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+var base58flickr = genBase58("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ");
+var base58xrp = genBase58("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz");
+var BECH_ALPHABET = chain(alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), join(""));
+var POLYMOD_GENERATORS = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function bech32Polymod(pre) {
+  const b = pre >> 25;
+  let chk = (pre & 33554431) << 5;
+  for (let i = 0;i < POLYMOD_GENERATORS.length; i++) {
+    if ((b >> i & 1) === 1)
+      chk ^= POLYMOD_GENERATORS[i];
+  }
+  return chk;
+}
+function bechChecksum(prefix, words, encodingConst = 1) {
+  const len = prefix.length;
+  let chk = 1;
+  for (let i = 0;i < len; i++) {
+    const c = prefix.charCodeAt(i);
+    if (c < 33 || c > 126)
+      throw new Error(`Invalid prefix (${prefix})`);
+    chk = bech32Polymod(chk) ^ c >> 5;
+  }
+  chk = bech32Polymod(chk);
+  for (let i = 0;i < len; i++)
+    chk = bech32Polymod(chk) ^ prefix.charCodeAt(i) & 31;
+  for (let v of words)
+    chk = bech32Polymod(chk) ^ v;
+  for (let i = 0;i < 6; i++)
+    chk = bech32Polymod(chk);
+  chk ^= encodingConst;
+  return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));
+}
+function genBech32(encoding) {
+  const ENCODING_CONST = encoding === "bech32" ? 1 : 734539939;
+  const _words = radix2(5);
+  const fromWords = _words.decode;
+  const toWords = _words.encode;
+  const fromWordsUnsafe = unsafeWrapper(fromWords);
+  function encode(prefix, words, limit = 90) {
+    astr("bech32.encode prefix", prefix);
+    if (isBytes(words))
+      words = Array.from(words);
+    anumArr("bech32.encode", words);
+    const plen = prefix.length;
+    if (plen === 0)
+      throw new TypeError(`Invalid prefix length ${plen}`);
+    const actualLength = plen + 7 + words.length;
+    if (limit !== false && actualLength > limit)
+      throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
+    const lowered = prefix.toLowerCase();
+    const sum = bechChecksum(lowered, words, ENCODING_CONST);
+    return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
+  }
+  function decode(str, limit = 90) {
+    astr("bech32.decode input", str);
+    const slen = str.length;
+    if (slen < 8 || limit !== false && slen > limit)
+      throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);
+    const lowered = str.toLowerCase();
+    if (str !== lowered && str !== str.toUpperCase())
+      throw new Error(`String must be lowercase or uppercase`);
+    const sepIndex = lowered.lastIndexOf("1");
+    if (sepIndex === 0 || sepIndex === -1)
+      throw new Error(`Letter "1" must be present between prefix and data only`);
+    const prefix = lowered.slice(0, sepIndex);
+    const data = lowered.slice(sepIndex + 1);
+    if (data.length < 6)
+      throw new Error("Data must be at least 6 characters long");
+    const words = BECH_ALPHABET.decode(data).slice(0, -6);
+    const sum = bechChecksum(prefix, words, ENCODING_CONST);
+    if (!data.endsWith(sum))
+      throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
+    return { prefix, words };
+  }
+  const decodeUnsafe = unsafeWrapper(decode);
+  function decodeToBytes(str) {
+    const { prefix, words } = decode(str, false);
+    return { prefix, words, bytes: fromWords(words) };
+  }
+  function encodeFromBytes(prefix, bytes) {
+    return encode(prefix, toWords(bytes));
+  }
+  return {
+    encode,
+    decode,
+    encodeFromBytes,
+    decodeToBytes,
+    decodeUnsafe,
+    fromWords,
+    fromWordsUnsafe,
+    toWords
+  };
+}
+var bech32 = genBech32("bech32");
+var bech32m = genBech32("bech32m");
+var hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+var hexBuiltin = {
+  encode(data) {
+    abytes(data);
+    return data.toHex();
+  },
+  decode(s) {
+    astr("hex", s);
+    return Uint8Array.fromHex(s);
+  }
+};
+var hex = hasHexBuiltin ? hexBuiltin : chain(radix2(4), alphabet("0123456789abcdef"), join(""), normalize((s) => {
+  if (typeof s !== "string" || s.length % 2 !== 0)
+    throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);
+  return s.toLowerCase();
+}));
+
+// src/utils/encoding.ts
+var hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  let hex2 = "";
+  for (const b of bytes) {
+    hex2 += hexes[b];
+  }
+  return hex2;
+}
+function hexToBytes(hex2) {
+  hex2 = without0x(hex2);
+  if (hex2.length % 2)
+    hex2 = `0${hex2}`;
+  const array = new Uint8Array(hex2.length / 2);
+  for (let i = 0;i < array.length; i++) {
+    const j = i * 2;
+    const byte = Number.parseInt(hex2.slice(j, j + 2), 16);
+    if (Number.isNaN(byte) || byte < 0)
+      throw new Error("Invalid byte sequence");
+    array[i] = byte;
+  }
+  return array;
+}
+function without0x(value) {
+  return /^0x/i.test(value) ? value.slice(2) : value;
+}
+
+// src/connect/walletconnect/crypto.ts
+var IV_LENGTH = 12;
+var KEY_LENGTH = 32;
+var TYPE_0 = 0;
+var TYPE_1 = 1;
+function generateKeyPair() {
+  const privateKey = import_utils.randomBytes(KEY_LENGTH);
+  const publicKey = import_ed25519.x25519.getPublicKey(privateKey);
+  return { privateKey, publicKey };
+}
+function generateSymKey() {
+  return import_utils.randomBytes(KEY_LENGTH);
+}
+function deriveSymKey(selfPrivate, peerPublic) {
+  const shared = import_ed25519.x25519.getSharedSecret(selfPrivate, peerPublic);
+  return import_hkdf.hkdf(import_sha2.sha256, shared, undefined, undefined, KEY_LENGTH);
+}
+function symKeyToTopic(symKey) {
+  return bytesToHex(import_sha2.sha256(symKey));
+}
+function encodeBase64(data) {
+  let binary = "";
+  for (let i = 0;i < data.length; i++)
+    binary += String.fromCharCode(data[i]);
+  return btoa(binary);
+}
+function decodeBase64(str) {
+  const binary = atob(str);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++)
+    bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function encryptType0(symKey, plaintext) {
+  const iv = import_utils.randomBytes(IV_LENGTH);
+  const data = new TextEncoder().encode(plaintext);
+  const cipher = import_aes.gcm(symKey, iv);
+  const sealed = cipher.encrypt(data);
+  const envelope = new Uint8Array(1 + IV_LENGTH + sealed.length);
+  envelope[0] = TYPE_0;
+  envelope.set(iv, 1);
+  envelope.set(sealed, 1 + IV_LENGTH);
+  return envelope;
+}
+function decryptType0(symKey, envelope) {
+  if (envelope[0] !== TYPE_0)
+    throw new Error("Not a type-0 envelope");
+  const iv = envelope.subarray(1, 1 + IV_LENGTH);
+  const sealed = envelope.subarray(1 + IV_LENGTH);
+  const cipher = import_aes.gcm(symKey, iv);
+  const plain = cipher.decrypt(sealed);
+  return new TextDecoder().decode(plain);
+}
+function decryptType1(receiverPrivate, envelope) {
+  if (envelope[0] !== TYPE_1)
+    throw new Error("Not a type-1 envelope");
+  const senderPublic = envelope.subarray(1, 1 + KEY_LENGTH);
+  const iv = envelope.subarray(1 + KEY_LENGTH, 1 + KEY_LENGTH + IV_LENGTH);
+  const sealed = envelope.subarray(1 + KEY_LENGTH + IV_LENGTH);
+  const symKey = deriveSymKey(receiverPrivate, senderPublic);
+  const cipher = import_aes.gcm(symKey, iv);
+  const plain = cipher.decrypt(sealed);
+  return new TextDecoder().decode(plain);
+}
+var ED25519_MULTICODEC = new Uint8Array([237, 1]);
+function encodeDidKey(publicKey) {
+  const prefixed = new Uint8Array(ED25519_MULTICODEC.length + publicKey.length);
+  prefixed.set(ED25519_MULTICODEC);
+  prefixed.set(publicKey, ED25519_MULTICODEC.length);
+  return `did:key:z${base58.encode(prefixed)}`;
+}
+function base64urlEncode(data) {
+  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  return base64urlnopad.encode(bytes);
+}
+function createRelayAuthJwt(relayUrl) {
+  const privateKey = import_ed25519.ed25519.utils.randomSecretKey();
+  const publicKey = import_ed25519.ed25519.getPublicKey(privateKey);
+  const clientId = encodeDidKey(publicKey);
+  const now = Math.floor(Date.now() / 1000);
+  const header = base64urlEncode(JSON.stringify({ alg: "EdDSA", typ: "JWT" }));
+  const payload = base64urlEncode(JSON.stringify({
+    iss: clientId,
+    sub: bytesToHex(import_utils.randomBytes(32)),
+    aud: relayUrl,
+    iat: now,
+    exp: now + 86400,
+    act: "client_auth"
+  }));
+  const message = new TextEncoder().encode(`${header}.${payload}`);
+  const signature = base64urlEncode(import_ed25519.ed25519.sign(message, privateKey));
+  return { jwt: `${header}.${payload}.${signature}`, clientId };
+}
+
+// src/connect/walletconnect/relay.ts
+var DEFAULT_RELAY = "wss://relay.walletconnect.com";
+var DEFAULT_TTL = 300;
+
+class WcRelay {
+  ws = null;
+  url;
+  projectId;
+  nextId = Date.now() * 1000 + Math.floor(Math.random() * 1000);
+  pending = new Map;
+  subscriptions = new Map;
+  subIdToTopic = new Map;
+  destroyed = false;
+  reconnecting = false;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  connectPromise = null;
+  connectReject = null;
+  constructor(projectId, relayUrl) {
+    this.projectId = projectId;
+    this.url = relayUrl ?? DEFAULT_RELAY;
+  }
+  async connect() {
+    if (this.ws?.readyState === WebSocket.OPEN)
+      return;
+    if (this.connectPromise)
+      return this.connectPromise;
+    this.connectPromise = new Promise((resolve, reject) => {
+      this.connectReject = reject;
+      const { jwt } = createRelayAuthJwt(this.url);
+      const wsUrl = `${this.url}/?auth=${jwt}&projectId=${this.projectId}`;
+      this.ws = new WebSocket(wsUrl);
+      this.ws.addEventListener("open", () => {
+        this.reconnectAttempt = 0;
+        this.reconnecting = false;
+        this.connectPromise = null;
+        this.connectReject = null;
+        resolve();
+      }, { once: true });
+      this.ws.addEventListener("error", (e) => {
+        this.connectPromise = null;
+        this.connectReject = null;
+        reject(new Error(`WC relay connection failed: ${e}`));
+      }, { once: true });
+      this.ws.addEventListener("message", (event) => {
+        this.handleMessage(typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data));
+      });
+      this.ws.addEventListener("close", () => {
+        this.connectPromise = null;
+        if (!this.destroyed)
+          this.handleDisconnect();
+      });
+    });
+    return this.connectPromise;
+  }
+  async subscribe(topic, handler) {
+    await this.connect();
+    this.subscriptions.set(topic, handler);
+    const subId = await this.rpc("irn_subscribe", { topic });
+    this.subIdToTopic.set(subId, topic);
+    return subId;
+  }
+  async publish(topic, message, tag, ttl = DEFAULT_TTL) {
+    await this.connect();
+    await this.rpc("irn_publish", {
+      topic,
+      message,
+      ttl,
+      tag,
+      prompt: false
+    });
+  }
+  async publishEncrypted(topic, symKey, payload, tag, ttl = DEFAULT_TTL) {
+    const plaintext = JSON.stringify(payload);
+    const envelope = encryptType0(symKey, plaintext);
+    await this.publish(topic, encodeBase64(envelope), tag, ttl);
+  }
+  rpc(method, params) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        return reject(new Error("WC relay not connected"));
+      }
+      const id = this.nextId++;
+      this.pending.set(id, { resolve, reject });
+      this.ws.send(JSON.stringify({ id, jsonrpc: "2.0", method, params }));
+    });
+  }
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if ("id" in msg && msg.id != null && this.pending.has(msg.id)) {
+      const p = this.pending.get(msg.id);
+      this.pending.delete(msg.id);
+      if (msg.error) {
+        p.reject(new Error(`WC relay error: ${msg.error.message}`));
+      } else {
+        p.resolve(msg.result);
+      }
+      return;
+    }
+    if (msg.method === "irn_subscription" && msg.params) {
+      const { id: subId, data } = msg.params;
+      const topic = data?.topic ?? this.subIdToTopic.get(subId);
+      const handler = topic ? this.subscriptions.get(topic) : undefined;
+      if (handler && data) {
+        handler({
+          topic: data.topic,
+          message: data.message,
+          publishedAt: data.publishedAt ?? Date.now(),
+          tag: data.tag ?? 0
+        });
+      }
+      if (msg.id != null) {
+        this.ws?.send(JSON.stringify({ id: msg.id, jsonrpc: "2.0", result: true }));
+      }
+    }
+  }
+  handleDisconnect() {
+    this.ws = null;
+    for (const [, p] of this.pending) {
+      p.reject(new Error("WC relay disconnected"));
+    }
+    this.pending.clear();
+    if (this.subscriptions.size > 0 && this.reconnectAttempt < 5) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.destroyed || this.reconnecting)
+      return;
+    this.reconnecting = true;
+    const delay = 1000 * 2 ** this.reconnectAttempt;
+    this.reconnectAttempt++;
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnecting = false;
+      try {
+        await this.connect();
+        for (const [topic] of this.subscriptions) {
+          const subId = await this.rpc("irn_subscribe", { topic });
+          this.subIdToTopic.set(subId, topic);
+        }
+      } catch {
+        if (!this.destroyed && this.subscriptions.size > 0) {
+          this.handleDisconnect();
+        }
+      }
+    }, delay);
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.reconnectTimer)
+      clearTimeout(this.reconnectTimer);
+    if (this.connectReject) {
+      this.connectReject(new Error("WC relay destroyed"));
+      this.connectReject = null;
+      this.connectPromise = null;
+    }
+    for (const [, p] of this.pending) {
+      p.reject(new Error("WC relay destroyed"));
+    }
+    this.pending.clear();
+    this.subscriptions.clear();
+    this.subIdToTopic.clear();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+}
+
+// src/connect/walletconnect/session.ts
+var STORAGE_KEY = "@secondlayer/wc:session";
+var SESSION_EXPIRY = 7 * 24 * 60 * 60;
+var STACKS_METHODS = [
+  "stx_getAddresses",
+  "stx_transferStx",
+  "stx_callContract",
+  "stx_deployContract",
+  "stx_signMessage",
+  "stx_signTransaction"
+];
+var STACKS_EVENTS = ["chainChanged", "accountsChanged"];
+function getStorage() {
+  return typeof localStorage !== "undefined" ? localStorage : undefined;
+}
+
+class WcSession {
+  relay;
+  config;
+  chains;
+  pairingSymKey = null;
+  pairingTopic = null;
+  selfKeyPair = null;
+  sessionData = null;
+  sessionSymKey = null;
+  pending = new Map;
+  nextId = Date.now();
+  constructor(config) {
+    this.config = config;
+    this.chains = config.chains ?? ["stacks:1"];
+    this.relay = new WcRelay(config.projectId, config.relayUrl);
+  }
+  restore() {
+    try {
+      const raw = getStorage()?.getItem(STORAGE_KEY);
+      if (!raw)
+        return false;
+      const data = JSON.parse(raw);
+      if (data.expiry < Date.now() / 1000) {
+        getStorage()?.removeItem(STORAGE_KEY);
+        return false;
+      }
+      this.sessionData = data;
+      this.sessionSymKey = hexToBytes(data.symKey);
+      this.subscribeSession().catch(() => {});
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async pair() {
+    this.pairingSymKey = generateSymKey();
+    this.pairingTopic = symKeyToTopic(this.pairingSymKey);
+    this.selfKeyPair = generateKeyPair();
+    const symKeyHex = bytesToHex(this.pairingSymKey);
+    const uri = `wc:${this.pairingTopic}@2?relay-protocol=irn&symKey=${symKeyHex}`;
+    const approval = new Promise((resolve, reject) => {
+      this.relay.subscribe(this.pairingTopic, (msg) => {
+        try {
+          this.handlePairingMessage(msg.message, resolve, reject);
+        } catch (err) {
+          reject(err instanceof Error ? err : new Error(String(err)));
+        }
+      }).catch(reject);
+    });
+    return { uri, approval };
+  }
+  async request(method, params) {
+    if (!this.sessionData || !this.sessionSymKey) {
+      throw new Error("No active WC session");
+    }
+    const id = this.nextId++;
+    const payload = {
+      id,
+      jsonrpc: "2.0",
+      method: "wc_sessionRequest",
+      params: {
+        request: { method, params },
+        chainId: this.chains[0]
+      }
+    };
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.relay.publishEncrypted(this.sessionData.topic, this.sessionSymKey, payload, 1108, SESSION_EXPIRY).catch((err) => {
+        this.pending.delete(id);
+        reject(err);
+      });
+    });
+  }
+  disconnect() {
+    if (this.sessionData && this.sessionSymKey) {
+      const id = this.nextId++;
+      const payload = {
+        id,
+        jsonrpc: "2.0",
+        method: "wc_sessionDelete",
+        params: { code: 6000, message: "User disconnected" }
+      };
+      this.relay.publishEncrypted(this.sessionData.topic, this.sessionSymKey, payload, 1112).catch(() => {});
+    }
+    this.sessionData = null;
+    this.sessionSymKey = null;
+    this.pending.clear();
+    getStorage()?.removeItem(STORAGE_KEY);
+    this.relay.destroy();
+  }
+  get session() {
+    return this.sessionData;
+  }
+  handlePairingMessage(message, resolve, reject) {
+    const envelope = decodeBase64(message);
+    let plaintext;
+    if (envelope[0] === 1 && this.selfKeyPair) {
+      plaintext = decryptType1(this.selfKeyPair.privateKey, envelope);
+    } else if (this.pairingSymKey) {
+      plaintext = decryptType0(this.pairingSymKey, envelope);
+    } else {
+      return;
+    }
+    let rpc;
+    try {
+      rpc = JSON.parse(plaintext);
+    } catch {
+      return;
+    }
+    if (rpc.method === "wc_sessionPropose") {
+      this.handleProposal(rpc, resolve, reject).catch(reject);
+    }
+  }
+  async handleProposal(rpc, resolve, reject) {
+    try {
+      const proposal = rpc.params;
+      const peerPublicKey = hexToBytes(proposal.proposer.publicKey);
+      const sessionKp = generateKeyPair();
+      const sessionSymKey = deriveSymKey(sessionKp.privateKey, peerPublicKey);
+      const sessionTopic = symKeyToTopic(sessionSymKey);
+      const expiry = Math.floor(Date.now() / 1000) + SESSION_EXPIRY;
+      const settled = {
+        relay: { protocol: "irn" },
+        namespaces: {
+          stacks: {
+            chains: this.chains,
+            methods: STACKS_METHODS,
+            events: STACKS_EVENTS,
+            accounts: this.chains.map((c) => `${c}:placeholder`)
+          }
+        },
+        controller: {
+          publicKey: bytesToHex(sessionKp.publicKey),
+          metadata: this.config.metadata
+        },
+        expiry
+      };
+      const approvePayload = {
+        id: rpc.id,
+        jsonrpc: "2.0",
+        result: {
+          relay: { protocol: "irn" },
+          responderPublicKey: bytesToHex(sessionKp.publicKey)
+        }
+      };
+      await this.relay.publishEncrypted(this.pairingTopic, this.pairingSymKey, approvePayload, 1101);
+      this.sessionSymKey = sessionSymKey;
+      this.sessionData = {
+        topic: sessionTopic,
+        symKey: bytesToHex(sessionSymKey),
+        peerMeta: proposal.proposer.metadata,
+        expiry,
+        accounts: [],
+        controllerPublicKey: proposal.proposer.publicKey
+      };
+      await this.subscribeSession();
+      const settlePayload = {
+        id: this.nextId++,
+        jsonrpc: "2.0",
+        method: "wc_sessionSettle",
+        params: settled
+      };
+      await this.relay.publishEncrypted(sessionTopic, sessionSymKey, settlePayload, 1104);
+      getStorage()?.setItem(STORAGE_KEY, JSON.stringify(this.sessionData));
+      resolve(settled);
+    } catch (err) {
+      reject(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  async subscribeSession() {
+    if (!this.sessionData || !this.sessionSymKey)
+      return;
+    const symKey = this.sessionSymKey;
+    await this.relay.subscribe(this.sessionData.topic, (msg) => {
+      try {
+        const envelope = decodeBase64(msg.message);
+        const plaintext = decryptType0(symKey, envelope);
+        const rpc = JSON.parse(plaintext);
+        if ("id" in rpc && this.pending.has(rpc.id)) {
+          const p = this.pending.get(rpc.id);
+          this.pending.delete(rpc.id);
+          if (rpc.error) {
+            p.reject(new Error(rpc.error.message ?? "WC request failed"));
+          } else {
+            p.resolve(rpc.result);
+          }
+        }
+        if (rpc.method === "wc_sessionDelete") {
+          this.sessionData = null;
+          this.sessionSymKey = null;
+          this.pending.clear();
+          getStorage()?.removeItem(STORAGE_KEY);
+        }
+      } catch {}
+    });
+  }
+}
+
+// src/connect/walletconnect/provider.ts
+class WalletConnectProvider {
+  session;
+  constructor(config) {
+    this.session = new WcSession(config);
+  }
+  restore() {
+    return this.session.restore();
+  }
+  async pair() {
+    return this.session.pair();
+  }
+  async request(method, params) {
+    return this.session.request(method, params);
+  }
+  disconnect() {
+    this.session.disconnect();
+  }
+  get sessionData() {
+    return this.session.session;
+  }
+}
+// src/connect/walletconnect/qr.ts
+var CAPACITIES = [0, 17, 32, 53, 78, 106, 134, 154, 192, 230, 271];
+var EC_PARAMS = [
+  [0, 0, 0],
+  [26, 7, 1],
+  [44, 10, 1],
+  [70, 15, 1],
+  [100, 20, 1],
+  [134, 26, 1],
+  [172, 18, 2],
+  [196, 20, 2],
+  [242, 24, 2],
+  [292, 30, 2],
+  [346, 18, 4]
+];
+function selectVersion(len) {
+  for (let v = 1;v <= 10; v++) {
+    if (len <= CAPACITIES[v])
+      return v;
+  }
+  throw new Error("QR data too long");
+}
+var GF_EXP = new Uint8Array(512);
+var GF_LOG = new Uint8Array(256);
+{
+  let x = 1;
+  for (let i = 0;i < 255; i++) {
+    GF_EXP[i] = x;
+    GF_LOG[x] = i;
+    x = x << 1 ^ (x >= 128 ? 285 : 0);
+  }
+  for (let i = 255;i < 512; i++)
+    GF_EXP[i] = GF_EXP[i - 255];
+}
+function gfMul(a, b) {
+  if (a === 0 || b === 0)
+    return 0;
+  return GF_EXP[GF_LOG[a] + GF_LOG[b]];
+}
+function rsGenPoly(n) {
+  let poly = new Uint8Array([1]);
+  for (let i = 0;i < n; i++) {
+    const next = new Uint8Array(poly.length + 1);
+    for (let j = 0;j < poly.length; j++) {
+      next[j] ^= poly[j];
+      next[j + 1] ^= gfMul(poly[j], GF_EXP[i]);
+    }
+    poly = next;
+  }
+  return poly;
+}
+function rsEncode(data, ecLen) {
+  const gen = rsGenPoly(ecLen);
+  const result = new Uint8Array(data.length + ecLen);
+  result.set(data);
+  for (let i = 0;i < data.length; i++) {
+    const coef = result[i];
+    if (coef === 0)
+      continue;
+    for (let j = 0;j < gen.length; j++) {
+      result[i + j] ^= gfMul(gen[j], coef);
+    }
+  }
+  return result.subarray(data.length);
+}
+function encodeData(bytes, version) {
+  const [totalCw, ecPerBlock, numBlocks] = EC_PARAMS[version];
+  const dataCw = totalCw - ecPerBlock * numBlocks;
+  const bits = [];
+  const push = (val, len) => {
+    for (let i = len - 1;i >= 0; i--)
+      bits.push(val >> i & 1);
+  };
+  push(4, 4);
+  push(bytes.length, version <= 9 ? 8 : 16);
+  for (const b of bytes)
+    push(b, 8);
+  push(0, 4);
+  while (bits.length % 8 !== 0)
+    bits.push(0);
+  const codewords = new Uint8Array(dataCw);
+  for (let i = 0;i < dataCw; i++) {
+    let byte = 0;
+    for (let j = 0;j < 8; j++) {
+      const idx = i * 8 + j;
+      byte = byte << 1 | (idx < bits.length ? bits[idx] : 0);
+    }
+    codewords[i] = byte;
+  }
+  let padByte = 236;
+  for (let i = Math.ceil(bits.length / 8);i < dataCw; i++) {
+    codewords[i] = padByte;
+    padByte = padByte === 236 ? 17 : 236;
+  }
+  const cwPerBlock = Math.floor(dataCw / numBlocks);
+  const dataBlocks = [];
+  const ecBlocks = [];
+  let offset = 0;
+  for (let b = 0;b < numBlocks; b++) {
+    const blockLen = cwPerBlock + (b < dataCw % numBlocks ? 1 : 0);
+    const block = codewords.subarray(offset, offset + blockLen);
+    dataBlocks.push(block);
+    ecBlocks.push(rsEncode(block, ecPerBlock));
+    offset += blockLen;
+  }
+  const result = [];
+  const maxDataLen = Math.max(...dataBlocks.map((b) => b.length));
+  for (let i = 0;i < maxDataLen; i++) {
+    for (const block of dataBlocks) {
+      if (i < block.length)
+        result.push(block[i]);
+    }
+  }
+  for (let i = 0;i < ecPerBlock; i++) {
+    for (const block of ecBlocks) {
+      if (i < block.length)
+        result.push(block[i]);
+    }
+  }
+  return new Uint8Array(result);
+}
+function createMatrix(size) {
+  return Array.from({ length: size }, () => new Uint8Array(size));
+}
+function setModule(m, r, c, val, reserved) {
+  if (r >= 0 && r < m.length && c >= 0 && c < m.length) {
+    m[r][c] = val;
+    reserved[r][c] = 1;
+  }
+}
+function addFinderPattern(m, r, c, res) {
+  for (let dr = -1;dr <= 7; dr++) {
+    for (let dc = -1;dc <= 7; dc++) {
+      const rr = r + dr, cc = c + dc;
+      if (rr < 0 || rr >= m.length || cc < 0 || cc >= m.length)
+        continue;
+      const inOuter = dr >= 0 && dr <= 6 && dc >= 0 && dc <= 6;
+      const inInner = dr >= 2 && dr <= 4 && dc >= 2 && dc <= 4;
+      const onBorder = dr === 0 || dr === 6 || dc === 0 || dc === 6;
+      const val = inInner || inOuter && onBorder ? 1 : 0;
+      setModule(m, rr, cc, val, res);
+    }
+  }
+}
+function addTimingPatterns(m, res) {
+  for (let i = 8;i < m.length - 8; i++) {
+    const val = i % 2 === 0 ? 1 : 0;
+    if (!res[6][i])
+      setModule(m, 6, i, val, res);
+    if (!res[i][6])
+      setModule(m, i, 6, val, res);
+  }
+}
+function addFormatInfo(m, res) {
+  const fmt = 30660;
+  const n = m.length;
+  for (let i = 0;i < 15; i++) {
+    const bit = fmt >> 14 - i & 1;
+    if (i < 6)
+      setModule(m, 8, i, bit, res);
+    else if (i === 6)
+      setModule(m, 8, 7, bit, res);
+    else if (i === 7)
+      setModule(m, 8, 8, bit, res);
+    else if (i === 8)
+      setModule(m, 7, 8, bit, res);
+    else
+      setModule(m, 14 - i, 8, bit, res);
+    if (i < 8)
+      setModule(m, n - 1 - i, 8, bit, res);
+    else
+      setModule(m, 8, n - 15 + i, bit, res);
+  }
+  setModule(m, n - 8, 8, 1, res);
+}
+function placeData(m, res, data) {
+  const n = m.length;
+  let bitIdx = 0;
+  const totalBits = data.length * 8;
+  let col = n - 1;
+  let upward = true;
+  while (col >= 0) {
+    if (col === 6)
+      col--;
+    const rows = upward ? Array.from({ length: n }, (_, i) => n - 1 - i) : Array.from({ length: n }, (_, i) => i);
+    for (const row of rows) {
+      for (const dc of [0, -1]) {
+        const c = col + dc;
+        if (c < 0 || res[row][c])
+          continue;
+        if (bitIdx < totalBits) {
+          const byteIdx = bitIdx >> 3;
+          const bitPos = 7 - (bitIdx & 7);
+          const bit = data[byteIdx] >> bitPos & 1;
+          m[row][c] = bit ^ ((row + c) % 2 === 0 ? 1 : 0);
+          bitIdx++;
+        }
+      }
+    }
+    col -= 2;
+    upward = !upward;
+  }
+}
+function buildMatrix(version, codewords) {
+  const n = version * 4 + 17;
+  const m = createMatrix(n);
+  const res = createMatrix(n);
+  addFinderPattern(m, 0, 0, res);
+  addFinderPattern(m, 0, n - 7, res);
+  addFinderPattern(m, n - 7, 0, res);
+  addTimingPatterns(m, res);
+  addFormatInfo(m, res);
+  if (version >= 2) {
+    const pos = [6, version * 4 + 10];
+    for (const r of pos) {
+      for (const c of pos) {
+        if (res[r]?.[c])
+          continue;
+        for (let dr = -2;dr <= 2; dr++) {
+          for (let dc = -2;dc <= 2; dc++) {
+            const val = Math.abs(dr) === 2 || Math.abs(dc) === 2 || dr === 0 && dc === 0 ? 1 : 0;
+            setModule(m, r + dr, c + dc, val, res);
+          }
+        }
+      }
+    }
+  }
+  placeData(m, res, codewords);
+  return m;
+}
+function qrSvg(data, opts) {
+  const size = opts?.size ?? 256;
+  const dark = opts?.dark ?? "#000000";
+  const light = opts?.light ?? "#ffffff";
+  const bytes = new TextEncoder().encode(data);
+  const version = selectVersion(bytes.length);
+  const codewords = encodeData(bytes, version);
+  const matrix = buildMatrix(version, codewords);
+  const n = matrix.length;
+  const quiet = 4;
+  const total = n + quiet * 2;
+  const scale = size / total;
+  let paths = "";
+  for (let r = 0;r < n; r++) {
+    for (let c = 0;c < n; c++) {
+      if (matrix[r][c]) {
+        const x = (c + quiet) * scale;
+        const y = (r + quiet) * scale;
+        paths += `M${x},${y}h${scale}v${scale}h-${scale}z`;
+      }
+    }
+  }
+  return [
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" width="${size}" height="${size}">`,
+    `<rect width="${size}" height="${size}" fill="${light}"/>`,
+    `<path d="${paths}" fill="${dark}"/>`,
+    `</svg>`
+  ].join("");
+}
+// src/connect/provider.ts
+function isWalletInstalled() {
+  return typeof window !== "undefined" && !!(window.StacksProvider || window.LeatherProvider || window.XverseProvider || window.HiroWalletProvider);
+}
+
+// src/connect/walletconnect/modal.ts
+var MODAL_ID = "sl-wc-modal";
+var STYLES = `
+  #${MODAL_ID} { position:fixed;inset:0;z-index:99999;display:flex;align-items:center;justify-content:center;background:rgba(0,0,0,.5) }
+  #${MODAL_ID} .sl-wc-box { background:#fff;border-radius:16px;padding:24px;max-width:360px;width:90%;text-align:center;font-family:system-ui,sans-serif }
+  #${MODAL_ID} .sl-wc-title { margin:0 0 16px;font-size:18px;font-weight:600;color:#1a1a1a }
+  #${MODAL_ID} .sl-wc-btn { display:block;width:100%;padding:12px;margin:8px 0;border:1px solid #e5e5e5;border-radius:12px;background:#fff;cursor:pointer;font-size:15px;font-weight:500;color:#1a1a1a;transition:background .15s }
+  #${MODAL_ID} .sl-wc-btn:hover { background:#f5f5f5 }
+  #${MODAL_ID} .sl-wc-divider { margin:16px 0;color:#999;font-size:13px }
+  #${MODAL_ID} .sl-wc-qr { margin:16px auto 0 }
+  #${MODAL_ID} .sl-wc-close { position:absolute;top:12px;right:16px;background:none;border:none;font-size:20px;cursor:pointer;color:#999 }
+`;
+function showModal(opts) {
+  if (typeof document === "undefined")
+    return () => {};
+  document.getElementById(MODAL_ID)?.remove();
+  const overlay = document.createElement("div");
+  overlay.id = MODAL_ID;
+  const style = document.createElement("style");
+  style.textContent = STYLES;
+  overlay.appendChild(style);
+  const box = document.createElement("div");
+  box.className = "sl-wc-box";
+  box.style.position = "relative";
+  const close = document.createElement("button");
+  close.className = "sl-wc-close";
+  close.textContent = "×";
+  close.onclick = dismiss;
+  box.appendChild(close);
+  const title = document.createElement("h2");
+  title.className = "sl-wc-title";
+  title.textContent = "Connect Wallet";
+  box.appendChild(title);
+  if (isWalletInstalled()) {
+    const btn = document.createElement("button");
+    btn.className = "sl-wc-btn";
+    btn.textContent = "Browser Wallet";
+    btn.onclick = () => {
+      dismiss();
+      opts.onSelectInjected?.();
+    };
+    box.appendChild(btn);
+  }
+  if (opts.wcUri) {
+    if (isWalletInstalled()) {
+      const divider = document.createElement("div");
+      divider.className = "sl-wc-divider";
+      divider.textContent = "or scan with mobile wallet";
+      box.appendChild(divider);
+    }
+    const qr = document.createElement("div");
+    qr.className = "sl-wc-qr";
+    qr.innerHTML = qrSvg(opts.wcUri, { size: 240 });
+    box.appendChild(qr);
+  }
+  overlay.appendChild(box);
+  overlay.onclick = (e) => {
+    if (e.target === overlay)
+      dismiss();
+  };
+  document.body.appendChild(overlay);
+  function dismiss() {
+    overlay.remove();
+    opts.onClose?.();
+  }
+  return dismiss;
+}
+function hideModal() {
+  if (typeof document === "undefined")
+    return;
+  document.getElementById(MODAL_ID)?.remove();
+}
+
+//# debugId=91582566EF1D837E64756E2164756E21
+//# sourceMappingURL=index.cjs.map