@txnlab/use-wallet-solid 3.0.0-beta.6

package/dist/dev.jsx

@@ -0,0 +1,3164 @@
+import {
+  esm_default,
+  init_esm
+} from "./chunk/NK6TZ2ZJ.jsx";
+import "./chunk/2PWOQULK.jsx";
+import "./chunk/PIH3UREM.jsx";
+
+// ../../node_modules/.pnpm/@tanstack+store@0.3.1/node_modules/@tanstack/store/dist/esm/index.js
+var Store = class {
+  constructor(initialState, options) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this._batching = false;
+    this._flushing = 0;
+    this.subscribe = (listener) => {
+      var _a, _b;
+      this.listeners.add(listener);
+      const unsub = (_b = (_a = this.options) == null ? void 0 : _a.onSubscribe) == null ? void 0 : _b.call(_a, listener, this);
+      return () => {
+        this.listeners.delete(listener);
+        unsub == null ? void 0 : unsub();
+      };
+    };
+    this.setState = (updater) => {
+      var _a, _b, _c;
+      const previous = this.state;
+      this.state = ((_a = this.options) == null ? void 0 : _a.updateFn) ? this.options.updateFn(previous)(updater) : updater(previous);
+      (_c = (_b = this.options) == null ? void 0 : _b.onUpdate) == null ? void 0 : _c.call(_b);
+      this._flush();
+    };
+    this._flush = () => {
+      if (this._batching)
+        return;
+      const flushId = ++this._flushing;
+      this.listeners.forEach((listener) => {
+        if (this._flushing !== flushId)
+          return;
+        listener();
+      });
+    };
+    this.batch = (cb) => {
+      if (this._batching)
+        return cb();
+      this._batching = true;
+      cb();
+      this._batching = false;
+      this._flush();
+    };
+    this.state = initialState;
+    this.options = options;
+  }
+};
+
+// ../use-wallet/dist/index.js
+init_esm();
+init_esm();
+init_esm();
+init_esm();
+init_esm();
+init_esm();
+init_esm();
+init_esm();
+init_esm();
+init_esm();
+var NetworkId = /* @__PURE__ */ ((NetworkId2) => {
+  NetworkId2["MAINNET"] = "mainnet";
+  NetworkId2["TESTNET"] = "testnet";
+  NetworkId2["BETANET"] = "betanet";
+  NetworkId2["LOCALNET"] = "localnet";
+  return NetworkId2;
+})(NetworkId || {});
+function isValidNetworkId(networkId) {
+  return Object.values(NetworkId).includes(networkId);
+}
+function isNetworkConfigMap(config) {
+  const networkKeys = Object.values(NetworkId);
+  return Object.keys(config).some((key) => networkKeys.includes(key));
+}
+var nodeServerMap = {
+  [
+    "mainnet"
+    /* MAINNET */
+  ]: "https://mainnet-api.algonode.cloud",
+  [
+    "testnet"
+    /* TESTNET */
+  ]: "https://testnet-api.algonode.cloud",
+  [
+    "betanet"
+    /* BETANET */
+  ]: "https://betanet-api.algonode.cloud"
+};
+function createDefaultNetworkConfig() {
+  const localnetConfig = {
+    token: "a".repeat(64),
+    baseServer: "http://localhost",
+    port: 4001,
+    headers: {}
+  };
+  return Object.values(NetworkId).reduce((configMap, value) => {
+    const network = value;
+    const isLocalnet = network === "localnet";
+    configMap[network] = isLocalnet ? localnetConfig : {
+      token: "",
+      baseServer: nodeServerMap[network],
+      port: "",
+      headers: {}
+    };
+    return configMap;
+  }, {});
+}
+var caipChainId = {
+  [
+    "mainnet"
+    /* MAINNET */
+  ]: "algorand:wGHE2Pwdvd7S12BL5FaOP20EGYesN73k",
+  [
+    "testnet"
+    /* TESTNET */
+  ]: "algorand:SGO1GKSzyE7IEPItTxCByw9x8FmnrCDe",
+  [
+    "betanet"
+    /* BETANET */
+  ]: "algorand:mFgazF-2uRS1tMiL9dsj01hJGySEmPN2"
+};
+var StorageAdapter = class {
+  static getItem(key) {
+    if (typeof window === "undefined") {
+      return null;
+    }
+    return localStorage.getItem(key);
+  }
+  static setItem(key, value) {
+    if (typeof window === "undefined") {
+      return;
+    }
+    localStorage.setItem(key, value);
+  }
+};
+var BaseWallet = class {
+  id;
+  metadata;
+  store;
+  getAlgodClient;
+  subscribe;
+  constructor({
+    id,
+    metadata,
+    store,
+    subscribe,
+    getAlgodClient
+  }) {
+    this.id = id;
+    this.store = store;
+    this.subscribe = subscribe;
+    this.getAlgodClient = getAlgodClient;
+    const ctor = this.constructor;
+    this.metadata = { ...ctor.defaultMetadata, ...metadata };
+  }
+  static defaultMetadata = { name: "Base Wallet", icon: "" };
+  setActive = () => {
+    console.info(`[Wallet] Set active wallet: ${this.id}`);
+    setActiveWallet(this.store, { walletId: this.id });
+  };
+  setActiveAccount = (account) => {
+    console.info(`[Wallet] Set active account: ${account}`);
+    setActiveAccount(this.store, {
+      walletId: this.id,
+      address: account
+    });
+  };
+  // ---------- Derived Properties ------------------------------------ //
+  get name() {
+    return this.id.toUpperCase();
+  }
+  get accounts() {
+    const state = this.store.state;
+    const walletState = state.wallets[this.id];
+    return walletState ? walletState.accounts : [];
+  }
+  get addresses() {
+    return this.accounts.map((account) => account.address);
+  }
+  get activeAccount() {
+    const state = this.store.state;
+    const walletState = state.wallets[this.id];
+    return walletState ? walletState.activeAccount : null;
+  }
+  get activeAddress() {
+    return this.activeAccount?.address ?? null;
+  }
+  get activeNetwork() {
+    const state = this.store.state;
+    return state.activeNetwork;
+  }
+  get isConnected() {
+    const state = this.store.state;
+    const walletState = state.wallets[this.id];
+    return walletState ? walletState.accounts.length > 0 : false;
+  }
+  get isActive() {
+    const state = this.store.state;
+    return state.activeWallet === this.id;
+  }
+  // ---------- Protected Methods ------------------------------------- //
+  onDisconnect() {
+    removeWallet(this.store, { walletId: this.id });
+  }
+};
+var WalletId = /* @__PURE__ */ ((WalletId2) => {
+  WalletId2["DEFLY"] = "defly";
+  WalletId2["EXODUS"] = "exodus";
+  WalletId2["KIBISIS"] = "kibisis";
+  WalletId2["KMD"] = "kmd";
+  WalletId2["LUTE"] = "lute";
+  WalletId2["MNEMONIC"] = "mnemonic";
+  WalletId2["PERA"] = "pera";
+  WalletId2["WALLETCONNECT"] = "walletconnect";
+  return WalletId2;
+})(WalletId || {});
+var icon = "data:image/svg+xml;base64,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";
+var ExodusWallet = class extends BaseWallet {
+  client = null;
+  options;
+  store;
+  constructor({
+    id,
+    store,
+    subscribe,
+    getAlgodClient,
+    options = {},
+    metadata = {}
+  }) {
+    super({ id, metadata, getAlgodClient, store, subscribe });
+    this.options = options;
+    this.store = store;
+  }
+  static defaultMetadata = { name: "Exodus", icon };
+  async initializeClient() {
+    console.info("[ExodusWallet] Initializing client...");
+    if (typeof window === "undefined" || window.algorand === void 0) {
+      throw new Error("Exodus is not available.");
+    }
+    const client = window.algorand;
+    this.client = client;
+    return client;
+  }
+  connect = async () => {
+    console.info("[ExodusWallet] Connecting...");
+    try {
+      const client = this.client || await this.initializeClient();
+      const { accounts } = await client.enable(this.options);
+      if (accounts.length === 0) {
+        throw new Error("No accounts found!");
+      }
+      const walletAccounts = accounts.map((address, idx) => ({
+        name: `Exodus Wallet ${idx + 1}`,
+        address
+      }));
+      const activeAccount = walletAccounts[0];
+      addWallet(this.store, {
+        walletId: this.id,
+        wallet: {
+          accounts: walletAccounts,
+          activeAccount
+        }
+      });
+      return walletAccounts;
+    } catch (error) {
+      if (error.name === "UserRejectedRequestError") {
+        console.info("[ExodusWallet] Connection cancelled.");
+      } else {
+        console.error(`[ExodusWallet] Error connecting: ${error.message}`);
+      }
+      return [];
+    }
+  };
+  disconnect = async () => {
+    console.info("[ExodusWallet] Disconnecting...");
+    this.onDisconnect();
+  };
+  resumeSession = async () => {
+    try {
+      const state = this.store.state;
+      const walletState = state.wallets[this.id];
+      if (!walletState) {
+        return;
+      }
+      console.info("[ExodusWallet] Resuming session...");
+      const client = await this.initializeClient();
+      if (!client.isConnected) {
+        throw new Error("Exodus is not connected.");
+      }
+    } catch (error) {
+      console.error(`[ExodusWallet] Error resuming session: ${error.message}`);
+      this.onDisconnect();
+    }
+  };
+  signTransactions = async (txnGroup, indexesToSign, returnGroup = true) => {
+    if (!this.client) {
+      throw new Error("[ExodusWallet] Client not initialized!");
+    }
+    const txnsToSign = [];
+    const signedIndexes = [];
+    const msgpackTxnGroup = normalizeTxnGroup(txnGroup);
+    const decodedObjects = msgpackTxnGroup.map((txn) => {
+      return esm_default.decodeObj(txn);
+    });
+    decodedObjects.forEach((txnObject, idx) => {
+      const isSigned = isSignedTxnObject(txnObject);
+      const shouldSign = shouldSignTxnObject(txnObject, this.addresses, indexesToSign, idx);
+      const txnBuffer = msgpackTxnGroup[idx];
+      const txn = isSigned ? esm_default.decodeSignedTransaction(txnBuffer).txn : esm_default.decodeUnsignedTransaction(txnBuffer);
+      const txnBase64 = byteArrayToBase64(txn.toByte());
+      if (shouldSign) {
+        txnsToSign.push({ txn: txnBase64 });
+        signedIndexes.push(idx);
+      } else {
+        txnsToSign.push({ txn: txnBase64, signers: [] });
+      }
+    });
+    const signTxnsResult = await this.client.signTxns(txnsToSign);
+    const signedTxnsBase64 = signTxnsResult.filter(Boolean);
+    const signedTxns = signedTxnsBase64.map((txn) => base64ToByteArray(txn));
+    const txnGroupSigned = mergeSignedTxnsWithGroup(
+      signedTxns,
+      msgpackTxnGroup,
+      signedIndexes,
+      returnGroup
+    );
+    return txnGroupSigned;
+  };
+  transactionSigner = async (txnGroup, indexesToSign) => {
+    if (!this.client) {
+      throw new Error("[ExodusWallet] Client not initialized!");
+    }
+    const txnsToSign = txnGroup.reduce((acc, txn, idx) => {
+      const txnBase64 = byteArrayToBase64(txn.toByte());
+      if (indexesToSign.includes(idx)) {
+        acc.push({ txn: txnBase64 });
+      } else {
+        acc.push({ txn: txnBase64, signers: [] });
+      }
+      return acc;
+    }, []);
+    const signTxnsResult = await this.client.signTxns(txnsToSign);
+    const signedTxnsBase64 = signTxnsResult.filter(Boolean);
+    const signedTxns = signedTxnsBase64.map((txn) => base64ToByteArray(txn));
+    return signedTxns;
+  };
+};
+var ARC_0027_PREFIX = "arc0027";
+var ARC_0027_CHANNEL_NAME = `${ARC_0027_PREFIX}:channel`;
+var ARC_0027_ENABLE_REQUEST = `${ARC_0027_PREFIX}:enable:request`;
+var ARC_0027_GET_PROVIDERS_REQUEST = `${ARC_0027_PREFIX}:get_providers:request`;
+var ARC_0027_PROVIDER_ID = "f6d1c86b-4493-42fb-b88d-a62407b4cdf6";
+var ARC_0027_SIGN_TXNS_REQUEST = `${ARC_0027_PREFIX}:sign_txns:request`;
+var UNKNOWN_ERROR = 4e3;
+var METHOD_TIMED_OUT_ERROR = 4002;
+var METHOD_NOT_SUPPORTED_ERROR = 4003;
+var NETWORK_NOT_SUPPORTED_ERROR = 4004;
+var DEFAULT_REQUEST_TIMEOUT = 18e4;
+var LOWER_REQUEST_TIMEOUT = 750;
+var icon2 = "data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
   version="1.1"
   id="svg2"
   viewBox="0 0 1365.3333 1365.3333"
   xmlns="http://www.w3.org/2000/svg">
  <path
    d="m 667.99998,1048.6662 c 0,-64.16698 -0.62044,-128.81698 -1.37877,-143.6667 -2.81107,-55.04737 -12.06749,-93.05259 -33.24059,-136.47992 -21.50734,-44.11289 -51.07057,-82.63022 -84.73686,-110.40198 -23.64821,-19.50771 -29.39484,-23.57963 -53.59707,-37.97755 -10.35553,-6.16049 -45.97102,-22.80673 -48.79622,-22.80673 -0.94443,0 -2.28715,-0.55289 -2.98381,-1.22865 -1.49195,-1.44716 -34.00787,-11.07847 -44.6,-13.21064 -19.50928,-3.92718 -46.10131,-6.86412 -65.92915,-7.28152 l -13.26249,-0.27919 -1.7944,12.66667 c -2.47233,17.45225 -2.99432,48.31543 -3.00487,177.66666 l -0.009,111.66666 h -28 -28 l 0.0289,-130.33333 c 0.0264,-118.93357 0.25284,-132.49082 2.58856,-154.99999 2.65523,-25.58826 6.36768,-48.68686 9.85759,-61.33334 7.05452,-25.56358 10.62579,-37.26221 12.82143,-42 0.6797,-1.46666 2.12633,-5.36666 3.21473,-8.66666 6.69676,-20.30447 26.44015,-58.78136 43.48873,-84.75303 28.07737,-42.77281 60.34669,-76.88074 104.66667,-110.63026 4.68777,-3.56972 29.48305,-20.07199 39.65998,-26.39532 13.56241,-8.42689 51.8048,-26.68925 65.00668,-31.04345 3.3,-1.0884 7.2,-2.5312 8.66667,-3.20623 7.66133,-3.52609 41.20988,-13.19069 56,-16.13237 79.95878,-15.90339 157.97892,-10.76771 233.99999,15.40306 41.91861,14.43076 75.99649,32.17779 114.75166,59.76019 16.88047,12.01399 47.22176,38.98231 59.91116,53.25103 5.4193,6.09383 11.5108,12.77503 13.5365,14.8471 3.5636,3.64509 24.2294,30.54649 29.8278,38.82787 24.1677,35.74973 45.9126,81.87894 57.2291,121.40474 1.2598,4.4 2.8124,9.5 3.4504,11.33333 1.6148,4.64078 6.5309,28.2356 8.0563,38.66667 0.6971,4.76667 1.5803,9.51695 1.9626,10.55616 0.3824,1.03923 1.5716,13.03923 2.6427,26.66667 1.5197,19.33483 1.9495,52.67283 1.9563,151.77717 l 0.01,126.99999 h -27.9075 -27.9076 l -0.6392,-139.66666 c -0.5016,-109.57863 -1.0339,-142.10817 -2.4711,-151 l -1.8318,-11.33333 -12.6214,0.23304 c -41.1925,0.76057 -80.77972,8.52421 -118.96833,23.33147 l -14.34687,5.56286 1.01354,8.76964 c 0.55744,4.82331 1.01353,98.76965 1.01353,208.76965 V 1022 l -27.66667,0.3604 -27.66666,0.3603 V 829.21771 c 0,-164.92591 -0.27452,-193.39769 -1.85888,-192.78971 -8.26627,3.17206 -43.58517,34.17332 -59.26032,52.01589 -37.00596,42.12283 -63.2251,90.4213 -76.19445,140.35841 -11.33531,43.64536 -12.08592,57.98044 -11.07543,211.5173 l 0.82278,125.0137 h -28.21686 -28.21684 z m 40.14696,-307.1138 c 16.27048,-34.25598 35.15362,-62.1439 61.95641,-91.50158 13.40096,-14.67833 35.11755,-35.1939 45.22996,-42.72853 2.93334,-2.18558 5.63334,-4.3314 6,-4.76846 1.23395,-1.47087 24.88758,-18.25331 28.79636,-20.43126 2.12867,-1.18608 4.77031,-2.73178 5.87031,-3.43489 12.95169,-8.27868 34.57728,-19.50523 56.66666,-29.41752 10.81399,-4.85263 36.46823,-13.49716 51.33334,-17.29745 27.4759,-7.02427 48.25932,-10.24746 73.88342,-11.4582 10.6974,-0.50546 19.4499,-1.32891 19.4499,-1.8299 0,-6.44876 -18.2611,-48.25566 -30.718,-70.32563 -8.0122,-14.19544 -22.4358,-36.51048 -25.2246,-39.02566 -0.4066,-0.36666 -2.49612,-3.06666 -4.64343,-6 -19.70091,-26.91238 -55.03669,-60.38449 -86.74729,-82.17206 -59.74239,-41.04755 -130.73576,-63.81051 -206.23392,-66.12583 -47.60648,-1.45996 -100.20019,8.09475 -149.76607,27.20804 -25.94699,10.00551 -69.31731,34.56026 -90,50.95482 -49.53411,39.26422 -82.65688,79.90693 -110.4048,135.47026 -7.33047,14.67874 -20.26186,45.95237 -20.26186,49.0018 0,1.55306 3.72096,2.11661 18.95377,2.87058 17.53638,0.868 45.42285,4.04374 47.66237,5.42783 0.52933,0.32715 4.20724,1.14152 8.17313,1.80972 14.93084,2.51565 55.94471,14.86908 65.47784,19.722 1.98026,1.00807 4.13546,1.83284 4.78935,1.83284 0.65389,0 2.77945,-4.05 4.72345,-9 3.43291,-8.74117 15.75027,-30.58893 21.41884,-37.9914 16.18291,-21.13291 24.58009,-30.25938 39.46791,-42.89572 15.20517,-12.90569 21.18029,-17.01928 39.57184,-27.24334 38.05215,-21.15363 86.78361,-31.79744 129.22511,-28.22507 33.24759,2.79849 55.08487,8.61855 82.53637,21.99753 36.08704,17.58766 63.48564,40.6231 88.77871,74.64096 8.79708,11.83161 8.77466,12.077 -1.44537,15.82228 -3.3,1.20933 -13.46387,6.34285 -22.58638,11.40783 -9.1225,5.06497 -17.34417,8.91824 -18.27037,8.56282 -0.9262,-0.35541 -3.48367,-3.45073 -5.68325,-6.87849 -5.72215,-8.9172 -29.71267,-31.94085 -41.46,-39.78908 -35.15967,-23.48966 -74.14367,-33.38888 -116.99736,-29.70914 -59.00047,5.06622 -114.77348,44.51395 -141.72094,100.23789 -2.90494,6.00702 -5.2817,11.99141 -5.2817,13.29864 0,1.42466 2.10534,3.45082 5.25567,5.058 14.95501,7.62948 46.47975,33.03684 69.48549,56.00185 27.71011,27.66102 45.78993,50.90598 65.26615,83.91165 8.61696,14.60287 12.45974,22.45113 22.12106,45.17868 l 2.4312,5.71922 2.55432,-5.71922 c 1.40488,-3.14558 6.06976,-13.12064 10.3664,-22.16681 z m -245.48028,96.66981 c 0,-101.44445 0.35001,-184.79445 0.7778,-185.22224 1.96604,-1.96605 21.31041,9.57859 41.22219,24.60125 l 14.66667,11.06543 0.33851,167 0.33849,166.99995 h -28.67183 -28.67183 z"
    fill="#ffffff" />
  <path
    d="M 0,682.66665 V 0 H 682.66665 1365.3333 V 682.66665 1365.3333 H 682.66665 0 Z M 724.31186,1025 c 0.35268,-127.16682 0.62556,-142.82667 2.66614,-153.00002 1.25029,-6.23333 3.24665,-17.03333 4.43634,-24 2.16934,-12.70313 5.92839,-27.27872 9.28444,-36 0.9877,-2.56667 2.52744,-7.06667 3.42167,-10 0.89423,-2.93333 3.63295,-9.68587 6.08604,-15.00564 2.45309,-5.31976 4.46016,-10.07235 4.46016,-10.56129 0,-0.79015 6.02644,-13.25635 9.39438,-19.43307 0.69975,-1.28333 1.84658,-3.38333 2.5485,-4.66667 3.19304,-5.83793 14.00864,-23.73489 14.70525,-24.33333 0.42683,-0.36666 3.74159,-4.86666 7.36615,-10 3.62454,-5.13333 7.58488,-10.53333 8.80072,-12 19.29624,-23.27701 36.11289,-40.52984 48.77253,-50.03758 4.26019,-3.19952 8.3458,-6.46344 9.07913,-7.25316 0.73334,-0.78971 4.48334,-3.72346 8.33334,-6.51944 l 7,-5.0836 v 192.78022 192.78018 h 29.36974 29.36976 l -0.50057,-205.66662 c -0.27532,-113.11666 -0.74171,-207.04878 -1.03643,-208.73803 -0.45497,-2.60782 0.47033,-3.48762 6.13083,-5.82935 3.66666,-1.51688 8.55734,-3.58476 10.86817,-4.59529 2.31083,-1.01052 5.18473,-1.83732 6.38645,-1.83732 1.20172,0 4.41104,-1.09491 7.13183,-2.43312 13.95896,-6.86568 61.75347,-15.65211 91.74867,-16.86684 l 20.1352,-0.81542 0.8678,8.39102 c 0.4774,4.61506 1.4469,12.59102 2.1546,17.72436 0.7517,5.45282 1.3133,64.49186 1.3507,141.99999 0.035,72.96667 0.548,133.42916 1.1395,134.36111 0.8261,1.3015 7.5464,1.6107 28.9796,1.33333 l 27.9041,-0.36111 -0.097,-136.66666 c -0.094,-132.77025 -0.1816,-137.35092 -3.0572,-160.66666 -3.1982,-25.93164 -5.3365,-37.35066 -10.4864,-56 -1.8225,-6.6 -3.4399,-12.6 -3.594,-13.33334 -1.58,-7.51577 -3.0996,-12.2983 -6.9374,-21.83424 -2.4719,-6.14216 -4.4944,-11.99044 -4.4944,-12.99617 0,-3.12641 -23.5111,-52.10944 -28.6483,-59.68569 -1.5478,-2.28281 -3.2077,-5.17791 -3.6885,-6.43356 -1.7821,-4.6538 -26.3419,-40.5152 -32.3299,-47.20705 -0.7333,-0.81954 -4.3333,-5.24312 -8,-9.8302 -8.6111,-10.77274 -41.51559,-44.08064 -52.5576,-53.20203 -4.70668,-3.88802 -9.38875,-7.90028 -10.4046,-8.91613 -1.88196,-1.88195 -5.9573,-4.743 -28.37112,-19.91772 -6.96667,-4.7166 -13.32856,-9.13235 -14.13755,-9.81277 -0.80899,-0.68042 -5.30899,-3.21343 -10,-5.62892 -4.69101,-2.4155 -8.82912,-4.76454 -9.19579,-5.22008 -2.29568,-2.85222 -50.51323,-24.55016 -63.99999,-28.80007 -24.50114,-7.72073 -36.41424,-11.18047 -43.33334,-12.58465 -4.4,-0.89295 -11.9,-2.6806 -16.66666,-3.97256 -39.92045,-10.82007 -138.66639,-10.5152 -179.33333,0.55369 -3.66667,0.998 -11.46667,2.85771 -17.33333,4.13267 -5.86667,1.27496 -16.43624,4.35152 -23.48794,6.8368 -7.0517,2.48528 -13.56102,4.51869 -14.46517,4.51869 -0.90413,0 -3.53456,0.85664 -5.84539,1.90364 -10.55421,4.78195 -16.78252,7.42969 -17.47686,7.42969 -2.22768,0 -53.3482,26.1356 -56.82195,29.05048 -1.04648,0.87812 -8.20269,5.79796 -15.90269,10.93298 -29.30767,19.54481 -41.85027,29.79922 -66.02928,53.98333 -18.63801,18.64194 -28.44184,29.94284 -41.55199,47.89706 -3.80302,5.20822 -8.67102,11.86948 -10.81778,14.80282 -2.14676,2.93333 -5.61493,8.33333 -7.70705,12 -2.09212,3.66666 -4.61131,7.49673 -5.59822,8.51124 -0.98689,1.01452 -3.17358,4.61452 -4.8593,8 -1.68572,3.38549 -6.4741,12.75542 -10.64083,20.82209 -4.16673,8.06667 -9.99083,20.36667 -12.94241,27.33333 -2.9516,6.96667 -6.22603,14.55735 -7.27651,16.86817 -1.05048,2.31083 -1.92673,5.01083 -1.94723,6 -0.0205,0.98918 -1.84905,6.8985 -4.06348,13.13183 -3.69322,10.39603 -5.29117,16.30048 -11.18624,41.33333 -8.34681,35.44398 -9.24678,56.6025 -8.81888,207.33333 0.19986,70.4 0.64084,128.45 0.97998,129 0.79664,1.29199 52.64238,1.27261 54.63697,-0.0204 1.10148,-0.71407 1.72211,-38.38596 2.28959,-138.97958 0.6902,-122.34366 1.63085,-161.20929 3.95801,-163.53647 1.27033,-1.27032 48.18516,2.01814 58.90798,4.12911 5.86667,1.15495 15.46667,3.03797 21.33334,4.18449 19.70825,3.85159 45.96932,12.55162 61.59188,20.40479 4.5422,2.28328 9.0722,4.15141 10.06666,4.15141 0.99447,0 2.37812,0.52034 3.07479,1.1563 0.69667,0.63596 6.38513,3.84669 12.64104,7.13495 6.25589,3.28827 16.68092,9.51794 23.1667,13.84371 6.4858,4.32577 14.1826,9.43523 17.104,11.35436 2.92142,1.91912 5.69639,4.02157 6.16663,4.67211 0.47023,0.65054 5.05496,4.54081 10.18829,8.64502 17.1745,13.73143 41.9613,39.78551 53.60592,56.34663 1.6166,2.29915 3.44883,4.78025 4.07163,5.51359 6.22307,7.3275 20.14761,30.77688 29.69066,49.99999 8.80256,17.73154 20.15559,47.1823 21.84452,56.66667 0.52236,2.93333 1.7697,8.33333 2.77186,12 8.46457,30.96997 9.98312,63.10922 10.00109,211.66664 l 0.0143,118.3333 h 28.62616 28.62616 z M 690.97754,756.63417 c -11.2437,-29.05673 -36.97408,-69.97481 -62.86053,-99.96484 -8.56836,-9.92665 -43.62093,-44.6051 -45.11702,-44.63549 -0.91667,-0.0187 -1.66667,-0.60503 -1.66667,-1.30313 0,-0.69811 -2.85,-3.21603 -6.33333,-5.59539 -3.48334,-2.37937 -6.93334,-5.01516 -7.66667,-5.85731 -0.73333,-0.84216 -3.43333,-2.94532 -6,-4.6737 -2.56667,-1.72838 -4.96667,-3.52699 -5.33333,-3.99692 -0.99291,-1.27252 -14.52226,-10.6074 -15.37366,-10.6074 -1.70414,0 -8.62634,-5.96747 -8.62634,-7.43658 0,-1.74832 10.46426,-23.48185 11.82681,-24.56342 0.46192,-0.36667 2.29511,-3.36667 4.07375,-6.66667 1.77864,-3.3 3.60754,-6.3 4.06424,-6.66667 0.45669,-0.36666 2.24942,-2.76666 3.98385,-5.33333 4.59703,-6.80281 25.07355,-27.44316 32.05135,-32.30775 3.3,-2.30061 6.3,-4.56726 6.66666,-5.03702 0.36667,-0.46976 3.36667,-2.30936 6.66667,-4.088 3.3,-1.77864 6.3,-3.57864 6.66667,-4 2.68844,-3.08944 27.84783,-14.08632 39.33333,-17.19213 33.63024,-9.09404 55.1398,-9.38251 90,-1.20699 16.81683,3.94395 36.72495,12.25293 52.05337,21.72534 14.26138,8.81304 40.60658,34.10844 48.3672,46.43988 1.26916,2.01667 3.42072,3.66667 4.78124,3.66667 1.3605,0 7.49668,-2.79531 13.63592,-6.21179 6.13925,-3.41648 16.86226,-8.88181 23.82893,-12.14518 6.96667,-3.26338 12.86461,-6.11602 13.10653,-6.3392 1.4462,-1.33416 -17.92538,-26.1947 -30.6663,-39.35561 -18.88996,-19.51267 -36.39015,-32.93164 -56.77415,-43.53386 -6.41635,-3.33729 -12.33145,-6.59901 -13.14468,-7.24826 -0.81323,-0.64924 -4.11323,-2.02276 -7.33333,-3.05226 -3.22011,-1.0295 -9.15474,-3.1648 -13.18807,-4.74512 -9.87499,-3.86913 -18.80515,-6.20818 -30,-7.85778 -5.13333,-0.75642 -13.23333,-2.09068 -18,-2.96502 -12.58961,-2.3093 -43.79428,-2.06017 -57.33333,0.45775 -6.23333,1.15924 -14.33333,2.51076 -18,3.00337 -9.0462,1.21538 -17.58605,3.58932 -32.97853,9.16751 -13.15661,4.76792 -38.64191,16.85327 -42.33625,20.07623 -1.1102,0.96854 -4.11855,2.81132 -6.68522,4.09505 -4.55192,2.27668 -5.44998,2.93809 -11.66666,8.59228 -1.65,1.50071 -3.36027,2.72856 -3.80059,2.72856 -1.812,0 -21.55885,18.70875 -29.73959,28.17613 -16.20242,18.75073 -17.56958,20.46515 -21.12484,26.49053 -1.94716,3.3 -3.95778,6.3 -4.46806,6.66667 -1.52882,1.09855 -15.86692,29.66788 -15.86692,31.61556 0,2.78469 -3.69512,3.55027 -7.01029,1.45241 -6.49263,-4.10854 -45.25275,-16.1076 -61.65638,-19.08709 -6.6,-1.19879 -17.7,-3.30105 -24.66666,-4.67169 -6.96667,-1.37064 -21.51667,-2.91278 -32.33334,-3.42698 -10.81666,-0.51418 -19.66666,-1.46612 -19.66666,-2.1154 0,-0.64926 1.42767,-4.61242 3.1726,-8.80698 1.74493,-4.19458 3.6271,-9.1265 4.18261,-10.95983 0.55549,-1.83333 3.32783,-8.29487 6.16073,-14.35896 2.8329,-6.06409 5.15072,-11.87868 5.15072,-12.9213 0,-1.04263 0.65967,-2.30339 1.46592,-2.80168 0.80626,-0.4983 3.09504,-4.2837 5.0862,-8.41202 17.2361,-35.73613 57.40118,-86.1652 88.78122,-111.46881 4.4,-3.54799 9.2,-7.54928 10.66666,-8.89176 5.56832,-5.09685 29.65399,-21.86884 38.96783,-27.13513 2.03436,-1.15029 5.49884,-3.21231 7.69884,-4.58225 10.4895,-6.5319 46.88989,-23.56135 56.77826,-26.56299 2.50528,-0.76049 9.35507,-3.11591 15.22174,-5.23427 5.86666,-2.11836 15.46666,-4.92036 21.33333,-6.22666 5.86667,-1.30632 14.86667,-3.46812 20,-4.80402 5.13333,-1.33589 16.23333,-3.21742 24.66666,-4.18118 19.97748,-2.28303 83.90895,-2.30776 103.33334,-0.04 29.44775,3.43801 72.86169,15.74508 102.66666,29.10414 15.83343,7.0968 38.12728,18.69999 39.33333,20.47167 0.36667,0.53863 2.16667,1.75229 4,2.69703 4.95184,2.55173 21.79683,13.63742 23.33333,15.35566 0.73334,0.82007 5.02834,3.98888 9.54446,7.04179 4.5161,3.05292 8.4161,6.01575 8.66666,6.58407 0.25055,0.56833 3.45174,3.43331 7.11375,6.36665 10.50117,8.41164 31.33919,29.49292 42.83328,43.33333 11.97244,14.41641 25.26221,31.93116 27.59701,36.37035 0.868,1.65028 3.0233,5.01834 4.7896,7.48456 1.7664,2.46622 4.9931,7.85778 7.1706,11.98124 10.7318,20.32249 18.5736,36.13963 20.9039,42.16385 1.4184,3.66666 4.4093,11.07884 6.6465,16.47148 2.2371,5.39265 4.0676,10.5558 4.0676,11.47366 0,1.21783 -5.3151,1.9259 -19.6667,2.61994 -10.8167,0.5231 -24.1667,1.84622 -29.6667,2.94028 -5.5,1.09404 -12.99996,2.4884 -16.66662,3.09856 -3.66667,0.61016 -10.26667,1.81097 -14.66667,2.66845 -12.81304,2.49705 -54.06,15.65579 -58.66667,18.71603 -0.73333,0.48716 -4.33333,1.98709 -8,3.33318 -6.01769,2.20919 -23.62673,10.96127 -43.33333,21.5376 -50.3214,27.00702 -112.18594,87.32824 -141.33333,137.80751 -3.18817,5.52148 -4.87261,8.49321 -6.61292,11.66666 -0.70377,1.28334 -2.65956,4.73334 -4.34621,7.66667 -2.80165,4.87253 -13.38321,27.36492 -16.60731,35.30085 -1.24049,3.05344 -1.64946,2.50376 -5.456,-7.33333 z m -170.99797,99.69914 c -0.0107,-91.48333 -0.46122,-167.0049 -1,-167.8257 -1.27748,-1.9462 -20.33372,-17.04469 -23.96632,-18.9888 -1.54293,-0.82575 -3.60212,-2.27943 -4.57596,-3.23039 -3.49041,-3.40836 -21.83683,-13.21226 -25.10397,-13.41496 l -3.33333,-0.20681 -0.33801,185 -0.33802,184.99995 h 29.33801 29.33802 z"
    fill="#8c019a" />
</svg>
";
+function isResponseError(error) {
+  return typeof error === "object" && "code" in error && "message" in error;
+}
+var KibisisWallet = class _KibisisWallet extends BaseWallet {
+  methods = [];
+  store;
+  constructor({
+    id,
+    store,
+    subscribe,
+    getAlgodClient,
+    metadata = {}
+  }) {
+    super({ id, metadata, getAlgodClient, store, subscribe });
+    this.store = store;
+  }
+  static defaultMetadata = {
+    name: "Kibisis",
+    icon: icon2
+  };
+  static async sendRequestWithTimeout({
+    method,
+    params,
+    timeout,
+    reference
+  }) {
+    return new Promise((resolve, reject) => {
+      const channel = new BroadcastChannel(ARC_0027_CHANNEL_NAME);
+      const requestId = generateUuid();
+      let timer;
+      channel.onmessage = (message) => {
+        if (!message.data || message.data.requestId !== requestId) {
+          return;
+        }
+        window.clearTimeout(timer);
+        if (message.data.error) {
+          reject(message.data.error);
+          return channel.close();
+        }
+        resolve(message.data.result);
+        return channel.close();
+      };
+      timer = window.setTimeout(() => {
+        channel.close();
+        reject({
+          code: METHOD_TIMED_OUT_ERROR,
+          data: {
+            method
+          },
+          message: `No response from provider "${"kibisis".toUpperCase()}"`,
+          providerId: ARC_0027_PROVIDER_ID
+        });
+      }, timeout || DEFAULT_REQUEST_TIMEOUT);
+      channel.postMessage({
+        id: requestId,
+        params,
+        reference
+      });
+    });
+  }
+  /**
+   * Calls the enable method on the provider that returns the authorized accounts.
+   * @returns {Arc0027Account[]} the authorized accounts.
+   * @throws {METHOD_CANCELED_ERROR} if the method was cancelled by the user.
+   * @throws {METHOD_NOT_SUPPORTED_ERROR} if the method is not supported for the configured network.
+   * @throws {METHOD_TIMED_OUT_ERROR} if the method timed out by lack of response.
+   * @throws {NETWORK_NOT_SUPPORTED_ERROR} if the network is not supported for the configured network.
+   * @throws {UNKNOWN_ERROR} if the response result was empty.
+   */
+  async enable() {
+    const method = "enable";
+    this.validateMethod(method);
+    const genesisHash = await this.getGenesisHash();
+    const result = await _KibisisWallet.sendRequestWithTimeout({
+      method,
+      params: {
+        genesisHash,
+        providerId: ARC_0027_PROVIDER_ID
+      },
+      reference: ARC_0027_ENABLE_REQUEST
+    });
+    if (!result) {
+      throw {
+        code: UNKNOWN_ERROR,
+        message: `Received response, but "${method}" request details were empty for provider "${this.name}"`,
+        providerId: ARC_0027_PROVIDER_ID
+      };
+    }
+    return result.accounts;
+  }
+  /**
+   * Gets the genesis hash of the algod client's configured network.
+   * @returns {string} the genesis hash
+   */
+  async getGenesisHash() {
+    const algodClient = this.getAlgodClient();
+    const version = await algodClient.versionsCheck().do();
+    const genesisHash = version.genesis_hash_b64;
+    return genesisHash;
+  }
+  /**
+   * Gets the provider information and updates the supported methods. This should be called
+   * before interacting with the provider to ensure methods are supported.
+   * @throws {METHOD_TIMED_OUT_ERROR} if the method timed out by lack of response.
+   * @throws {NETWORK_NOT_SUPPORTED_ERROR} if the network is not supported for the configured network.
+   * @throws {UNKNOWN_ERROR} if the response result was empty.
+   */
+  async getSupportedMethods() {
+    const genesisHash = await this.getGenesisHash();
+    const result = await _KibisisWallet.sendRequestWithTimeout({
+      method: "getProviders",
+      params: {
+        providerId: ARC_0027_PROVIDER_ID
+      },
+      reference: ARC_0027_GET_PROVIDERS_REQUEST,
+      timeout: LOWER_REQUEST_TIMEOUT
+    });
+    if (!result) {
+      throw {
+        code: UNKNOWN_ERROR,
+        message: `Received response, but provider details were empty for provider "${this.name}"`,
+        providerId: ARC_0027_PROVIDER_ID
+      };
+    }
+    const networkConfiguration = result.networks.find((value) => value.genesisHash === genesisHash);
+    if (!networkConfiguration) {
+      throw {
+        code: NETWORK_NOT_SUPPORTED_ERROR,
+        data: {
+          genesisHash
+        },
+        message: `Network "${this.activeNetwork}" not supported on provider "${this.name}"`,
+        providerId: ARC_0027_PROVIDER_ID
+      };
+    }
+    this.methods = networkConfiguration.methods;
+  }
+  /**
+   * Calls the signTxns methods to sign the supplied transactions.
+   * @param {Arc0001SignTxns[]} txns -  the unsigned or signed transactions as defined in ARC-0001.
+   * @returns {(string | null)[]} the authorized accounts.
+   * @throws {INVALID_INPUT_ERROR} if computed group ID for the txns does not match the assigned group ID.
+   * @throws {INVALID_GROUP_ID_ERROR} if the unsigned txns is malformed or not conforming to ARC-0001.
+   * @throws {METHOD_CANCELED_ERROR} if the method was cancelled by the user.
+   * @throws {METHOD_NOT_SUPPORTED_ERROR} if the method is not supported for the configured network.
+   * @throws {METHOD_TIMED_OUT_ERROR} if the method timed out by lack of response.
+   * @throws {NETWORK_NOT_SUPPORTED_ERROR} if the network is not supported for the configured network.
+   * @throws {UNAUTHORIZED_SIGNER_ERROR} if a signer in the request is not authorized by the provider.
+   * @throws {UNKNOWN_ERROR} if the response result was empty.
+   */
+  async signTxns(txns) {
+    const method = "signTxns";
+    this.validateMethod(method);
+    const result = await _KibisisWallet.sendRequestWithTimeout({
+      method,
+      params: {
+        providerId: ARC_0027_PROVIDER_ID,
+        txns
+      },
+      reference: ARC_0027_SIGN_TXNS_REQUEST
+    });
+    if (!result) {
+      throw {
+        code: UNKNOWN_ERROR,
+        message: `Received response, but "${method}" request details were empty for provider "${this.name}"`,
+        providerId: ARC_0027_PROVIDER_ID
+      };
+    }
+    return result.stxns;
+  }
+  /**
+   * Validates whether a method is supported with the provider.
+   * @param {ProviderMethod} method -  the method to validate.
+   * @throws {METHOD_NOT_SUPPORTED_ERROR} if the method is not supported for the configured network.
+   */
+  validateMethod(method) {
+    if (!this.methods.includes(method)) {
+      throw {
+        code: METHOD_NOT_SUPPORTED_ERROR,
+        data: {
+          method
+        },
+        message: `"${method}" operation not supported on "${this.activeNetwork}" for provider "${this.name}"`,
+        providerId: ARC_0027_PROVIDER_ID
+      };
+    }
+  }
+  connect = async () => {
+    console.info("[KibisisWallet] Connecting...");
+    try {
+      await this.getSupportedMethods();
+      const accounts = await this.enable();
+      const walletAccounts = accounts.map(({ address, name }, idx) => ({
+        name: name || `Kibisis Wallet ${idx + 1}`,
+        address
+      }));
+      const activeAccount = walletAccounts[0];
+      addWallet(this.store, {
+        walletId: this.id,
+        wallet: {
+          accounts: walletAccounts,
+          activeAccount
+        }
+      });
+      return walletAccounts;
+    } catch (error) {
+      console.error(`[KibisisWallet] Error connecting: ${error.message}`);
+      return [];
+    }
+  };
+  disconnect = async () => {
+    console.info("[KibisisWallet] Disconnecting...");
+    this.onDisconnect();
+  };
+  resumeSession = () => {
+    return Promise.resolve();
+  };
+  signTransactions = async (txnGroup, indexesToSign, returnGroup = true) => {
+    try {
+      await this.getSupportedMethods();
+      const txnsToSign = [];
+      const signedIndexes = [];
+      const msgpackTxnGroup = normalizeTxnGroup(txnGroup);
+      const decodedObjects = msgpackTxnGroup.map((txn) => {
+        return esm_default.decodeObj(txn);
+      });
+      decodedObjects.forEach((txnObject, idx) => {
+        const isSigned = isSignedTxnObject(txnObject);
+        const shouldSign = shouldSignTxnObject(txnObject, this.addresses, indexesToSign, idx);
+        const txnBuffer = msgpackTxnGroup[idx];
+        const txn = isSigned ? esm_default.decodeSignedTransaction(txnBuffer).txn : esm_default.decodeUnsignedTransaction(txnBuffer);
+        const txnBase64 = byteArrayToBase64(txn.toByte());
+        if (shouldSign) {
+          txnsToSign.push({ txn: txnBase64 });
+          signedIndexes.push(idx);
+        } else {
+          txnsToSign.push({ txn: txnBase64, signers: [] });
+        }
+      });
+      const signTxnsResult = await this.signTxns(txnsToSign);
+      const signedTxnsBase64 = signTxnsResult.filter(Boolean);
+      const signedTxns = signedTxnsBase64.map((txn) => base64ToByteArray(txn));
+      const txnGroupSigned = mergeSignedTxnsWithGroup(
+        signedTxns,
+        msgpackTxnGroup,
+        signedIndexes,
+        returnGroup
+      );
+      return txnGroupSigned;
+    } catch (error) {
+      console.error(
+        `[KibisisWallet] Error signing transactions: ` + (isResponseError(error) ? `${error.message} (code: ${error.code})` : error.message)
+      );
+      throw error;
+    }
+  };
+  transactionSigner = async (txnGroup, indexesToSign) => {
+    try {
+      const txnsToSign = txnGroup.reduce((acc, txn, idx) => {
+        const txnBase64 = byteArrayToBase64(txn.toByte());
+        if (indexesToSign.includes(idx)) {
+          acc.push({ txn: txnBase64 });
+        } else {
+          acc.push({ txn: txnBase64, signers: [] });
+        }
+        return acc;
+      }, []);
+      const signTxnsResult = await this.signTxns(txnsToSign);
+      const signedTxnsBase64 = signTxnsResult.filter(Boolean);
+      const signedTxns = signedTxnsBase64.map((txn) => base64ToByteArray(txn));
+      return signedTxns;
+    } catch (error) {
+      console.error(
+        `[KibisisWallet] Error signing transactions: ` + (isResponseError(error) ? `${error.message} (code: ${error.code})` : error.message)
+      );
+      throw error;
+    }
+  };
+};
+var icon3 = "data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz48c3ZnIGlkPSJMYXllcl8xIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA0MDkuODMgMjEwLjMzIj48dGV4dCB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwIDE2MS4zMSkiIHN0eWxlPSJmb250LWZhbWlseTpJQk1QbGV4U2Fucy1NZWRtLCAmYXBvcztJQk0gUGxleCBTYW5zJmFwb3M7OyBmb250LXNpemU6MTkwcHg7Ij48dHNwYW4geD0iMCIgeT0iMCI+S01EPC90c3Bhbj48L3RleHQ+PC9zdmc+";
+var KmdWallet = class extends BaseWallet {
+  client = null;
+  options;
+  walletName;
+  walletId = "";
+  password = "";
+  store;
+  constructor({
+    id,
+    store,
+    subscribe,
+    getAlgodClient,
+    options,
+    metadata = {}
+  }) {
+    super({ id, metadata, getAlgodClient, store, subscribe });
+    const {
+      token = "a".repeat(64),
+      baseServer = "http://127.0.0.1",
+      port = 4002,
+      wallet = "unencrypted-default-wallet"
+    } = options || {};
+    this.options = { token, baseServer, port };
+    this.walletName = wallet;
+    this.store = store;
+  }
+  static defaultMetadata = { name: "KMD", icon: icon3 };
+  async initializeClient() {
+    console.info("[KmdWallet] Initializing client...");
+    const { token, baseServer, port } = this.options;
+    const client = new esm_default.Kmd(token, baseServer, port);
+    this.client = client;
+    return client;
+  }
+  connect = async () => {
+    console.info("[KmdWallet] Connecting...");
+    try {
+      if (!this.client) {
+        await this.initializeClient();
+      }
+      const walletId = this.walletId || await this.fetchWalletId();
+      const token = await this.fetchToken(walletId, this.getPassword());
+      const accounts = await this.fetchAccounts(token);
+      if (accounts.length === 0) {
+        throw new Error("No accounts found!");
+      }
+      const walletAccounts = accounts.map((address, idx) => ({
+        name: `KMD Wallet ${idx + 1}`,
+        address
+      }));
+      const activeAccount = walletAccounts[0];
+      addWallet(this.store, {
+        walletId: this.id,
+        wallet: {
+          accounts: walletAccounts,
+          activeAccount
+        }
+      });
+      await this.releaseToken(token);
+      return walletAccounts;
+    } catch (error) {
+      console.error("[KmdWallet] Error connecting:", error);
+      return [];
+    }
+  };
+  disconnect = async () => {
+    console.info("[KmdWallet] Disconnecting...");
+    this.onDisconnect();
+  };
+  resumeSession = async () => {
+    try {
+      const state = this.store.state;
+      const walletState = state.wallets[this.id];
+      if (!walletState) {
+        return;
+      }
+      console.info("[KmdWallet] Resuming session...");
+      await this.initializeClient();
+    } catch (error) {
+      console.error(`[KmdWallet] Error resuming session: ${error.message}`);
+      this.onDisconnect();
+    }
+  };
+  signTransactions = async (txnGroup, indexesToSign, returnGroup = true) => {
+    if (!this.client) {
+      throw new Error("[KmdWallet] Client not initialized!");
+    }
+    const walletId = this.walletId || await this.fetchWalletId();
+    const password = this.getPassword();
+    const token = await this.fetchToken(walletId, password);
+    const signTxnPromises = [];
+    const signedIndexes = [];
+    const msgpackTxnGroup = normalizeTxnGroup(txnGroup);
+    const decodedObjects = msgpackTxnGroup.map((txn) => {
+      return esm_default.decodeObj(txn);
+    });
+    decodedObjects.forEach((txnObject, idx) => {
+      const isSigned = isSignedTxnObject(txnObject);
+      const shouldSign = shouldSignTxnObject(txnObject, this.addresses, indexesToSign, idx);
+      const txnBuffer = msgpackTxnGroup[idx];
+      const txn = isSigned ? esm_default.decodeSignedTransaction(txnBuffer).txn : esm_default.decodeUnsignedTransaction(txnBuffer);
+      if (shouldSign) {
+        signTxnPromises.push(this.client.signTransaction(token, password, txn));
+        signedIndexes.push(idx);
+      }
+    });
+    const signedTxns = await Promise.all(signTxnPromises);
+    await this.releaseToken(token);
+    const txnGroupSigned = mergeSignedTxnsWithGroup(
+      signedTxns,
+      msgpackTxnGroup,
+      signedIndexes,
+      returnGroup
+    );
+    return txnGroupSigned;
+  };
+  transactionSigner = async (txnGroup, indexesToSign) => {
+    if (!this.client) {
+      throw new Error("[KmdWallet] Client not initialized!");
+    }
+    const walletId = this.walletId || await this.fetchWalletId();
+    const password = this.getPassword();
+    const token = await this.fetchToken(walletId, password);
+    const signTxnPromises = [];
+    txnGroup.forEach((txn, idx) => {
+      if (indexesToSign.includes(idx)) {
+        signTxnPromises.push(this.client.signTransaction(token, password, txn));
+      }
+    });
+    const signedTxns = await Promise.all(signTxnPromises);
+    return signedTxns;
+  };
+  async fetchWalletId() {
+    console.info("[KmdWallet] Fetching wallet data...");
+    if (!this.client) {
+      throw new Error("Client not initialized!");
+    }
+    const { wallets } = await this.client.listWallets();
+    const wallet = wallets.find((wallet2) => wallet2.name === this.walletName);
+    if (!wallet) {
+      throw new Error(`Wallet ${this.walletName} not found!`);
+    }
+    this.walletId = wallet.id;
+    return wallet.id;
+  }
+  async fetchToken(walletId, password) {
+    console.info("[KmdWallet] Fetching token...");
+    if (!this.client) {
+      throw new Error("Client not initialized!");
+    }
+    const { wallet_handle_token } = await this.client.initWalletHandle(
+      walletId,
+      password
+    );
+    return wallet_handle_token;
+  }
+  async fetchAccounts(token) {
+    console.info("[KmdWallet] Fetching accounts...");
+    if (!this.client) {
+      throw new Error("Client not initialized!");
+    }
+    const { addresses } = await this.client.listKeys(token);
+    return addresses;
+  }
+  async releaseToken(token) {
+    console.info("[KmdWallet] Releasing token...");
+    if (!this.client) {
+      throw new Error("Client not initialized!");
+    }
+    await this.client.releaseWalletHandle(token);
+  }
+  getPassword() {
+    if (this.password) {
+      return this.password;
+    }
+    const password = prompt("KMD password") || "";
+    this.password = password;
+    return password;
+  }
+};
+function isSignTxnsError(error) {
+  return error instanceof Error && "code" in error;
+}
+var svgIcon = `
+<svg fill="#ab47bc" version="1.1" viewBox="0 0 1e3 1e3" xmlns="http://www.w3.org/2000/svg">
+  <path d="m708.49 604.22c-1.4434 0.0745-3.1495-0.29645-4.4397-0.9439-1.3774-0.69087-2.7586-1.9213-3.6501-3.1772-0.99228-1.3985-1.7378-3.3014-2.0311-4.9904-0.33364-1.92-0.21829-4.2204 0.23071-6.1167 0.51227-2.1618 1.6138-4.5296 2.8762-6.3571 1.4314-2.0747 3.535-4.1505 5.5871-5.6136 2.3137-1.648 5.3114-3.0703 8.033-3.8824 3.0387-0.90794 6.7097-1.3576 9.8803-1.2757 3.5102 0.0868 7.5298 0.85335 10.85 1.9967 3.6487 1.2571 7.6157 3.3634 10.733 5.6374 3.403 2.4814 6.8762 5.9359 9.4195 9.2928 2.7585 3.6421 5.2967 8.305 6.9078 12.58 1.7391 4.6113 2.9488 10.207 3.3251 15.12 0.40311 5.2743-0.0248 11.403-1.0977 16.582-1.151 5.5358-3.3952 11.705-6.0243 16.71-2.7996 5.3284-6.8947 10.99-11.044 15.352-4.4027 4.6272-10.217 9.2227-15.71 12.479-5.8105 3.4453-13.046 6.4589-19.57 8.2046-6.8814 1.8421-15.085 2.8458-22.208 2.7666-7.494-0.0744-16.088-1.3814-23.285-3.4703-7.5522-2.1935-15.879-5.9201-22.569-10.051-7.0069-4.3275-14.368-10.414-19.969-16.452-5.8527-6.3096-11.576-14.487-15.54-22.128-4.136-7.9708-7.6261-17.78-9.5-26.562-1.9518-9.1463-2.7495-19.962-2.2093-29.297 0.56311-9.7088 2.7361-20.773 5.8448-29.986 3.2286-9.5687 8.4395-20.053 14.078-28.43 5.8474-8.6867 13.927-17.748 21.856-24.586 8.2138-7.0821 18.756-13.932 28.546-18.601 10.126-4.8319 22.512-8.7987 33.552-10.797 11.408-2.0639 24.834-2.6556 36.384-1.6506 11.923 1.0382 25.458 4.087 36.69 8.2179 11.584 4.2613 24.229 10.957 34.288 18.104 10.368 7.3672 21.132 17.439 29.204 27.264 8.313 10.115 16.291 23.023 21.664 34.963 5.5266 12.281 9.9714 27.244 12.091 40.543 2.179 13.671 2.5659 29.71 1.0927 43.474-1.512 14.136-5.4366 30.142-10.591 43.391-5.2914 13.6-13.473 28.404-22.133 40.149-8.8847 12.047-20.949 24.513-32.671 33.822-12.016 9.5423-27.291 18.649-41.38 24.724-14.435 6.2239-31.976 11.147-47.535 13.388-15.931 2.295-34.584 2.476-50.561 0.53458-16.351-1.9848-34.826-6.7838-50.094-12.964-15.616-6.3215-32.58-15.987-46.008-26.16-13.728-10.401-27.896-24.46-38.439-38.077-10.773-13.917-21.009-31.555-27.785-47.799-6.9211-16.587-12.322-36.707-14.683-54.525-2.2001-14.805-6.9646-31.487-12.954-45.204-5.8408-13.373-14.573-27.859-23.704-39.242-8.8966-11.09-20.796-22.49-32.282-30.868-11.184-8.1571-25.267-15.843-38.195-20.789-12.577-4.8147-27.759-8.4462-41.158-9.801-13.026-1.3166-28.194-0.86079-41.11 1.2795-12.546 2.0786-26.65 6.3651-38.212 11.659-11.222 5.1382-23.343 12.741-32.826 20.643-9.1934 7.6619-18.6 17.858-25.462 27.665-6.6459 9.5-12.846 21.424-16.763 32.336-3.79 10.559-6.5473 23.271-7.4269 34.454-0.84963 10.813-0.18976 23.368 1.8369 34.023 1.9566 10.287 5.765 21.814 10.364 31.222 4.435 9.0723 10.909 18.827 17.582 26.407 6.4257 7.2985 14.92 14.713 23.047 20.055 7.8149 5.1356 17.581 9.8513 26.475 12.736 8.5427 2.7679 18.784 4.6496 27.754 5.0524 8.5981 0.38699 18.542-0.48002 26.934-2.3941 8.029-1.8316 16.98-5.1633 24.231-9.0682 6.9236-3.7292 14.314-9.0762 19.989-14.521 5.4078-5.1872 10.83-11.981 14.647-18.43 3.6302-6.13 6.8629-13.737 8.7091-20.617 1.7496-6.5234 2.7573-14.296 2.6794-21.051-0.0745-6.3861-1.1461-13.719-2.9528-19.845-1.7021-5.7735-4.5573-12.152-7.7714-17.239-3.0202-4.7805-7.2421-9.8078-11.46-13.572-3.9472-3.5221-9.0433-6.9541-13.812-9.2425-4.4423-2.1314-9.8936-3.8813-14.756-4.6802-4.5084-0.74172-9.8158-0.87692-14.35-0.30759-4.1782 0.52466-8.9071 1.8039-12.757 3.5114-3.5284 1.5634-7.3369 3.9445-10.25 6.4761-2.6502 2.3043-5.3192 5.4037-7.1534 8.3986-1.656 2.7044-3.102 6.1103-3.8349 9.195-0.65861 2.7626-0.9253 6.0706-0.65366 8.8966 0.24063 2.509 0.98608 5.3679 2.0668 7.646 0.95259 2.0072 2.4523 4.1452 4.0686 5.6691 1.417 1.3365 3.3516 2.587 5.1805 3.2579 1.6097 0.59286 3.6302 0.89676 5.3377 0.73676 1.5331-0.1439 3.2895-0.72436 4.577-1.5715 1.2068-0.79382 2.381-2.0865 3.0373-3.3726 0.65491-1.2876 1.8301-2.5803 3.0372-3.3741 1.2861-0.84593 3.0426-1.4274 4.577-1.5714 1.7075-0.16001 3.7267 0.14759 5.3363 0.73676 1.829 0.67102 3.7649 1.9214 5.1819 3.2577 1.6164 1.524 3.1165 3.662 4.0686 5.6692 1.0803 2.2778 1.825 5.1369 2.0668 7.6459 0.2704 2.8272 2e-3 6.1352-0.65366 8.8966-0.73426 3.0861-2.1803 6.4904-3.8364 9.1949-1.8329 2.9952-4.503 6.0944-7.1533 8.3988-2.9131 2.5316-6.7216 4.9124-10.249 6.4759-3.8508 1.7075-8.5783 2.9871-12.758 3.5114-4.5322 0.56684-9.8407 0.43411-14.348-0.30635-4.8636-0.80003-10.313-2.55-14.758-4.6813-4.7698-2.2887-9.8646-5.7207-13.812-9.2425-4.219-3.7635-8.4396-8.7909-11.46-13.572-3.2155-5.0881-6.0705-11.466-7.7727-17.239-1.8064-6.1259-2.8788-13.459-2.9528-19.845-0.0745-6.7545 0.92904-14.527 2.6808-21.051 1.8461-6.88 5.0776-14.486 8.7077-20.617 3.8191-6.4483 9.2413-13.242 14.648-18.429 5.6744-5.4447 13.064-10.792 19.989-14.521 7.2498-3.905 16.201-7.2366 24.231-9.0683 8.3908-1.9134 18.335-2.7811 26.934-2.3941 8.9705 0.4031 19.21 2.2846 27.753 5.0536 8.8964 2.8828 18.661 7.5985 26.476 12.736 8.1267 5.3403 16.622 12.756 23.048 20.054 6.6727 7.5798 13.146 17.335 17.582 26.407 4.5981 9.4076 8.4066 20.934 10.364 31.222 2.0258 10.654 2.6873 23.21 1.8371 34.023-0.8794 11.185-3.6369 23.895-7.4268 34.454-3.9169 10.913-10.117 22.836-16.763 32.337-6.8604 9.8062-16.268 20.002-25.462 27.665-9.4814 7.9024-21.602 15.504-32.823 20.643-11.563 5.2943-25.668 9.5806-38.214 11.659-12.914 2.1406-28.084 2.5962-41.11 1.2795-13.398-1.355-28.58-4.9864-41.158-9.7998-12.927-4.9482-27.011-12.634-38.195-20.791-11.487-8.3775-23.385-19.778-32.282-30.868-9.132-11.382-17.862-25.869-23.703-39.242-5.9911-13.717-10.755-30.399-12.955-45.204-2.2562-15.177-2.5054-32.96-0.72188-48.198 1.8276-15.613 6.335-33.265 12.173-47.86 5.9781-14.944 15.148-31.188 24.817-44.054 9.8948-13.167 23.289-26.769 36.275-36.9 13.282-10.364 30.135-20.223 45.659-26.765 15.87-6.6887 35.129-11.93 52.195-14.252 17.438-2.3715 37.834-2.4152 55.286-0.16248 17.827 2.3003 37.951 7.6829 54.563 14.547 13.923 5.4961 30.751 9.7114 45.625 11.382 14.502 1.6283 31.412 1.31 45.837-0.9067 14.052-2.1603 29.875-6.7638 42.874-12.522 12.656-5.6071 26.355-13.962 37.102-22.683 10.457-8.4858 21.195-19.818 29.066-30.743 7.6526-10.623 14.843-23.987 19.447-36.243 4.4716-11.905 7.8124-26.262 9.009-38.923 1.1609-12.288 0.63878-26.585-1.4646-38.748-2.039-11.792-6.1657-25.037-11.229-35.882-4.9033-10.506-12.131-21.839-19.622-30.686-7.2498-8.5611-16.88-17.304-26.125-23.659-8.9375-6.1419-20.143-11.848-30.382-15.42-9.887-3.4493-21.774-5.9148-32.222-6.6358-10.075-0.69459-21.759 0.0373-31.658 2.0231-9.5342 1.9148-20.203 5.5636-28.892 9.9319-8.3552 4.1993-17.321 10.298-24.266 16.561-6.6689 6.0137-13.419 13.941-18.254 21.507-4.6325 7.2539-8.8543 16.298-11.392 24.523-2.4286 7.8692-4.0197 17.288-4.2628 25.52-0.23069 7.8598 0.70453 16.933 2.5817 24.57 1.7881 7.2776 4.9614 15.37 8.6351 21.902 3.4943 6.208 8.4648 12.81 13.501 17.85 4.7737 4.7778 11.002 9.537 16.89 12.846 5.5674 3.1284 12.455 5.8672 18.663 7.366 5.8513 1.4118 12.802 2.1288 18.816 1.8884 5.6494-0.22452 12.113-1.3667 17.483-3.1389 5.0234-1.6573 10.543-4.354 14.91-7.3396 4.0672-2.7824 8.3076-6.6292 11.432-10.44 2.8958-3.5324 5.6651-8.0619 7.4387-12.272 1.6361-3.881 2.892-8.6153 3.3396-12.804 0.41056-3.8376 0.25055-8.3262-0.48495-12.114-0.67104-3.448-2.0205-7.3093-3.6962-10.395-1.5146-2.7864-3.7411-5.7404-6.0454-7.918-2.0641-1.9506-4.7949-3.8376-7.3779-5.0156-2.2938-1.0468-5.1422-1.8304-7.6551-2.0323-2.2134-0.17984-4.8162 0.0496-6.9437 0.68838-1.8658 0.55939-3.9167 1.6097-5.4128 2.8578-1.3166 1.0989-2.5908 2.6952-3.3054 4.2547-0.64374 1.3998-1.0183 3.2116-0.92776 4.7488 0.0745 1.4422 0.6152 3.1059 1.4024 4.3169 0.78637 1.2118 1.3192 2.8749 1.4037 4.3182 0.0745 1.537-0.2865 3.3489-0.92778 4.7486-0.71442 1.5583-1.9901 3.1548-3.3068 4.2535-1.4946 1.2493-3.5454 2.2991-5.4115 2.8591-2.1273 0.63628-4.7302 0.867-6.9436 0.68839-2.5129-0.20343-5.3614-0.98607-7.6551-2.0337-2.5842-1.1783-5.3152-3.0635-7.3779-5.0141-2.3057-2.1775-4.5308-5.1329-6.0455-7.9181-1.6771-3.0861-3.0267-6.9486-3.6961-10.395-0.738-3.7888-0.89305-8.2773-0.48498-12.115 0.44653-4.1874 1.7035-8.9215 3.3384-12.803 1.7749-4.2101 4.5441-8.7407 7.4401-12.273 3.1244-3.8112 7.3646-7.6566 11.432-10.439 4.3656-2.9871 9.887-5.6837 14.91-7.341 5.3693-1.7708 11.833-2.913 17.483-3.1377 6.0152-0.24063 12.965 0.47505 18.816 1.8884 6.2079 1.499 13.096 4.2364 18.663 7.3661 5.8883 3.3092 12.115 8.0685 16.89 12.846 5.0353 5.0391 10.007 11.641 13.5 17.85 3.6751 6.5302 6.847 14.624 8.6364 21.899 1.8779 7.6367 2.8128 16.71 2.5803 24.571-0.24187 8.2324-1.8329 17.649-4.2613 25.519-2.5381 8.2243-6.7598 17.27-11.394 24.523-4.8334 7.568-11.584 15.496-18.253 21.509-6.9448 6.262-15.911 12.36-24.268 16.561-8.6878 4.3671-19.357 8.0172-28.891 9.932-9.9003 1.9886-21.586 2.7176-31.658 2.023-10.447-0.72188-22.335-3.1866-32.222-6.6358-10.241-3.5734-21.444-9.2781-30.383-15.421-9.2468-6.3531-18.874-15.096-26.127-23.659-7.4915-8.8477-14.718-20.179-19.622-30.685-5.0616-10.844-9.1883-24.09-11.227-35.883-2.1024-12.162-2.6253-26.46-1.4644-38.747 1.1969-12.66 4.536-27.018 9.0088-38.923 4.6048-12.256 11.794-25.62 19.447-36.243 7.8717-10.926 18.608-22.257 29.065-30.743 10.749-8.7223 24.446-17.076 37.102-22.683 12.999-5.7589 28.822-10.364 42.875-12.524 14.423-2.2172 31.333-2.5354 45.837-0.90668 14.874 1.6705 31.703 5.8857 45.625 11.383 14.271 5.6346 29.795 14.31 42.102 23.475 12.607 9.3891 25.642 22.119 35.361 34.473 9.9529 12.649 19.436 28.713 25.744 43.52 6.4562 15.152 11.538 33.552 13.82 49.864 2.3333 16.685 2.4456 36.209 0.34853 52.925-2.1434 17.088-7.234 36.388-13.757 52.327-6.6648 16.287-16.825 33.972-27.502 47.961-10.906 14.287-25.629 29.023-39.879 39.979-11.721 9.3085-23.787 21.774-32.671 33.822-8.6602 11.744-16.841 26.548-22.133 40.147-5.1554 13.251-9.0788 29.256-10.591 43.392-1.4724 13.764-1.0865 29.804 1.0927 43.474 2.1209 13.298 6.5657 28.262 12.092 40.543 5.372 11.938 13.351 24.848 21.663 34.963 8.0738 9.825 18.837 19.896 29.204 27.263 10.061 7.1496 22.706 13.845 34.289 18.106 11.233 4.1308 24.767 7.18 36.689 8.218 11.551 1.0047 24.977 0.41179 36.385-1.6508 11.04-1.9981 23.426-5.9663 33.552-10.797 9.7879-4.6695 20.332-11.519 28.545-18.601 7.9312-6.8377 16.01-15.899 21.857-24.586 5.6387-8.3775 10.85-18.862 14.078-28.43 3.1087-9.2135 5.2822-20.278 5.8435-29.986 0.54081-9.3363-0.25674-20.151-2.2078-29.297-1.874-8.7816-5.3642-18.59-9.5001-26.562-3.9656-7.6393-9.6876-15.818-15.541-22.128-5.6005-6.0376-12.962-12.125-19.968-16.452-6.6925-4.1307-15.017-7.8587-22.569-10.051-7.1971-2.0892-15.792-3.3885-23.285-3.4705-7.1231-0.0745-15.326 0.92406-22.207 2.7664-6.5263 1.7458-13.76 4.7594-19.57 8.2047-5.4936 3.2565-11.309 7.8518-15.71 12.479-4.1492 4.3617-8.2455 10.022-11.045 15.352-2.6291 5.0048-4.8728 11.174-6.023 16.71-1.0766 5.1792-1.5013 11.308-1.0964 16.582 0.37706 4.9138 1.5859 10.509 3.3237 15.12 1.6125 4.2745 4.1507 8.9374 6.9092 12.58 2.5434 3.3568 6.015 6.8113 9.4195 9.2928 3.1178 2.274 7.0846 4.3803 10.733 5.6374 3.3199 1.1436 7.3396 1.9056 10.85 1.9967 3.1707 0.0745 6.8418-0.36962 9.8804-1.2756 2.7216-0.81242 5.7193-2.2345 8.0316-3.8824 2.0535-1.4646 4.1558-3.5391 5.5885-5.6138 1.2624-1.8276 2.3639-4.1967 2.8762-6.3571 0.44901-1.8964 0.56434-4.1967 0.2307-6.1167-0.2952-1.689-1.0394-3.5919-2.031-4.9903-0.89181-1.2561-2.2739-2.4867-3.6501-3.1774-1.2914-0.64869-2.9962-1.0196-4.4397-0.94389z" stroke-width=".13206" />
+</svg>
+`;
+var LuteWallet = class extends BaseWallet {
+  client = null;
+  options;
+  store;
+  constructor({
+    id,
+    store,
+    subscribe,
+    getAlgodClient,
+    options,
+    metadata = {}
+  }) {
+    super({ id, metadata, getAlgodClient, store, subscribe });
+    if (!options?.siteName) {
+      throw new Error("[LuteWallet] Missing required option: siteName");
+    }
+    this.options = options;
+    this.store = store;
+  }
+  static defaultMetadata = {
+    name: "Lute",
+    icon: `data:image/svg+xml;base64,${btoa(svgIcon.trim())}`
+  };
+  async initializeClient() {
+    console.info("[LuteWallet] Initializing client...");
+    const module = await import("./main.esm/3Z2KJMX5.jsx");
+    const LuteConnect = module.default;
+    const client = new LuteConnect(this.options.siteName);
+    this.client = client;
+    return client;
+  }
+  async getGenesisId() {
+    const algodClient = this.getAlgodClient();
+    const genesis = await algodClient.genesis().do();
+    const genesisId = `${genesis.network}-${genesis.id}`;
+    return genesisId;
+  }
+  connect = async () => {
+    console.info("[LuteWallet] Connecting...");
+    try {
+      const client = this.client || await this.initializeClient();
+      const genesisId = await this.getGenesisId();
+      const accounts = await client.connect(genesisId);
+      if (accounts.length === 0) {
+        throw new Error("No accounts found!");
+      }
+      const walletAccounts = accounts.map((address, idx) => ({
+        name: `Lute Wallet ${idx + 1}`,
+        address
+      }));
+      const activeAccount = walletAccounts[0];
+      addWallet(this.store, {
+        walletId: this.id,
+        wallet: {
+          accounts: walletAccounts,
+          activeAccount
+        }
+      });
+      return walletAccounts;
+    } catch (error) {
+      console.error(`[LuteWallet] Error connecting: ${error.message}`);
+      return [];
+    }
+  };
+  disconnect = async () => {
+    console.info("[LuteWallet] Disconnecting...");
+    this.onDisconnect();
+  };
+  resumeSession = async () => {
+    try {
+      const state = this.store.state;
+      const walletState = state.wallets[this.id];
+      if (!walletState) {
+        return;
+      }
+      console.info("[LuteWallet] Resuming session...");
+      await this.initializeClient();
+    } catch (error) {
+      console.error(`[LuteWallet] Error resuming session: ${error.message}`);
+      this.onDisconnect();
+    }
+  };
+  signTransactions = async (txnGroup, indexesToSign, returnGroup = true) => {
+    try {
+      if (!this.client) {
+        throw new Error("[LuteWallet] Client not initialized!");
+      }
+      const txnsToSign = [];
+      const signedIndexes = [];
+      const msgpackTxnGroup = normalizeTxnGroup(txnGroup);
+      const decodedObjects = msgpackTxnGroup.map((txn) => {
+        return esm_default.decodeObj(txn);
+      });
+      decodedObjects.forEach((txnObject, idx) => {
+        const isSigned = isSignedTxnObject(txnObject);
+        const shouldSign = shouldSignTxnObject(txnObject, this.addresses, indexesToSign, idx);
+        const txnBuffer = msgpackTxnGroup[idx];
+        const txn = isSigned ? esm_default.decodeSignedTransaction(txnBuffer).txn : esm_default.decodeUnsignedTransaction(txnBuffer);
+        const txnBase64 = byteArrayToBase64(txn.toByte());
+        if (shouldSign) {
+          txnsToSign.push({ txn: txnBase64 });
+          signedIndexes.push(idx);
+        } else {
+          txnsToSign.push({ txn: txnBase64, signers: [] });
+        }
+      });
+      const signTxnsResult = await this.client.signTxns(txnsToSign);
+      const signedTxns = signTxnsResult.filter(Boolean);
+      const txnGroupSigned = mergeSignedTxnsWithGroup(
+        signedTxns,
+        msgpackTxnGroup,
+        signedIndexes,
+        returnGroup
+      );
+      return txnGroupSigned;
+    } catch (error) {
+      console.error(
+        `[LuteWallet] Error signing transactions: ` + (isSignTxnsError(error) ? `${error.message} (code: ${error.code})` : error.message)
+      );
+      throw error;
+    }
+  };
+  transactionSigner = async (txnGroup, indexesToSign) => {
+    try {
+      if (!this.client) {
+        throw new Error("[LuteWallet] Client not initialized!");
+      }
+      const txnsToSign = txnGroup.reduce((acc, txn, idx) => {
+        const txnBase64 = byteArrayToBase64(txn.toByte());
+        if (indexesToSign.includes(idx)) {
+          acc.push({ txn: txnBase64 });
+        } else {
+          acc.push({ txn: txnBase64, signers: [] });
+        }
+        return acc;
+      }, []);
+      const signTxnsResult = await this.client.signTxns(txnsToSign);
+      const signedTxns = signTxnsResult.filter(Boolean);
+      return signedTxns;
+    } catch (error) {
+      console.error(
+        `[LuteWallet] Error signing transactions: ` + (isSignTxnsError(error) ? `${error.message} (code: ${error.code})` : error.message)
+      );
+      throw error;
+    }
+  };
+};
+var icon4 = `data:image/svg+xml,%3c%3fxml version='1.0' encoding='UTF-8'%3f%3e %3c!-- Generated by Pixelmator Pro 3.2.2 --%3e %3csvg width='409' height='210' viewBox='0 0 409 210' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'%3e%3ctext id='MNEMONIC' xml:space='preserve' x='0' y='129' font-family='Helvetica' font-size='72' fill='black'%3eMNEMONIC%3c/text%3e%3c/svg%3e`;
+var MnemonicWallet = class extends BaseWallet {
+  account = null;
+  options;
+  store;
+  constructor({
+    id,
+    store,
+    subscribe,
+    getAlgodClient,
+    options,
+    metadata = {}
+  }) {
+    super({ id, metadata, getAlgodClient, store, subscribe });
+    const { persistToStorage = false } = options || {};
+    this.options = { persistToStorage };
+    this.store = store;
+  }
+  static defaultMetadata = { name: "Mnemonic", icon: icon4 };
+  // @todo: Show explicit security warning if persistToStorage is true
+  // @todo: Save/load mnemonic from storage if persistToStorage is true
+  // @todo: Throw error with link to docs if using mainnet
+  initializeAccount() {
+    const mnemonic = prompt("Enter 25-word mnemonic passphrase:");
+    if (!mnemonic) {
+      this.account = null;
+      throw new Error("No mnemonic provided");
+    }
+    const account = esm_default.mnemonicToSecretKey(mnemonic);
+    this.account = account;
+    return account;
+  }
+  connect = async () => {
+    console.info("[MnemonicWallet] Connecting...");
+    try {
+      const account = this.initializeAccount();
+      const walletAccount = {
+        name: "Mnemonic Account",
+        address: account.addr
+      };
+      addWallet(this.store, {
+        walletId: this.id,
+        wallet: {
+          accounts: [walletAccount],
+          activeAccount: walletAccount
+        }
+      });
+      return [walletAccount];
+    } catch (error) {
+      console.error("[MnemonicWallet] Error connecting:", error);
+      throw error;
+    }
+  };
+  disconnect = async () => {
+    console.info("[MnemonicWallet] Disconnecting...");
+    try {
+      this.account = null;
+      this.onDisconnect();
+    } catch (error) {
+      console.error(error);
+    }
+  };
+  resumeSession = async () => {
+    const state = this.store.state;
+    const walletState = state.wallets[this.id];
+    if (walletState) {
+      try {
+        this.account = null;
+        this.onDisconnect();
+      } catch (error) {
+        console.error(error);
+      }
+    }
+  };
+  signTransactions = async (txnGroup, indexesToSign, returnGroup = true) => {
+    if (!this.account) {
+      throw new Error("[MnemonicWallet] Client not initialized!");
+    }
+    const txnGroupSigned = [];
+    const msgpackTxnGroup = normalizeTxnGroup(txnGroup);
+    const decodedObjects = msgpackTxnGroup.map((txn) => {
+      return esm_default.decodeObj(txn);
+    });
+    decodedObjects.forEach((txnObject, idx) => {
+      const isIndexMatch = !indexesToSign || indexesToSign.includes(idx);
+      const isSigned = isSignedTxnObject(txnObject);
+      const canSign = !isSigned && esm_default.encodeAddress(txnObject.snd) === this.account.addr;
+      const shouldSign = isIndexMatch && canSign;
+      if (shouldSign) {
+        const txn = esm_default.Transaction.from_obj_for_encoding(txnObject);
+        const signedTxn = txn.signTxn(this.account.sk);
+        txnGroupSigned.push(signedTxn);
+      } else if (returnGroup) {
+        txnGroupSigned.push(msgpackTxnGroup[idx]);
+      }
+    });
+    return Promise.resolve(txnGroupSigned);
+  };
+  transactionSigner = async (txnGroup, indexesToSign) => {
+    if (!this.account) {
+      throw new Error("[MnemonicWallet] Account not initialized!");
+    }
+    const signedTxns = [];
+    for (const index of indexesToSign) {
+      const txnToSign = txnGroup[index];
+      if (txnToSign) {
+        signedTxns.push(txnToSign.signTxn(this.account.sk));
+      }
+    }
+    return Promise.resolve(signedTxns);
+  };
+};
+var icon5 = "data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz48c3ZnIGlkPSJMYXllcl8xIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxNzcgMTg3Ij48cmVjdCB4PSItMTEuMzgiIHk9Ii0yNS45NyIgd2lkdGg9IjIwMC4wMiIgaGVpZ2h0PSIyMzEuNTMiIHN0eWxlPSJmaWxsOiNmZTU7Ii8+PHBhdGggZD0iTTk0LjA1LDU5LjYxYzIuMDUsOC40OCwxLjM2LDE1Ljk0LTEuNTUsMTYuNjYtMi45LC43Mi02LjkxLTUuNTctOC45Ni0xNC4wNS0yLjA1LTguNDgtMS4zNi0xNS45NCwxLjU1LTE2LjY2LDIuOS0uNzIsNi45MSw1LjU3LDguOTYsMTQuMDVaIiBzdHlsZT0iZmlsbDojMWMxYzFjOyIvPjxwYXRoIGQ9Ik0xMjcuODUsNjYuOWMtNC41My00LjgxLTEzLjU1LTMuNS0yMC4xNSwyLjkxLTYuNTksNi40MS04LjI2LDE1LjUtMy43MywyMC4zMSw0LjUzLDQuOCwxMy41NSwzLjUsMjAuMTUtMi45MXM4LjI2LTE1LjUsMy43My0yMC4zMVoiIHN0eWxlPSJmaWxsOiMxYzFjMWM7Ii8+PHBhdGggZD0iTTkxLjc5LDE0MC40N2MyLjktLjcyLDMuNDktOC42LDEuMzItMTcuNjEtMi4xNy05LTYuMjktMTUuNzEtOS4xOS0xNC45OS0yLjksLjcyLTMuNDksOC42LTEuMzIsMTcuNjEsMi4xNyw5LDYuMjksMTUuNzEsOS4xOSwxNC45OVoiIHN0eWxlPSJmaWxsOiMxYzFjMWM7Ii8+PHBhdGggZD0iTTYyLjIyLDcxLjNjOC4zNywyLjQ3LDE0LjQ4LDYuOCwxMy42Niw5LjY3LS44MywyLjg3LTguMjgsMy4yLTE2LjY1LC43My04LjM3LTIuNDctMTQuNDgtNi44LTEzLjY2LTkuNjcsLjgzLTIuODcsOC4yOC0zLjIsMTYuNjUtLjczWiIgc3R5bGU9ImZpbGw6IzFjMWMxYzsiLz48cGF0aCBkPSJNMTE2LjU0LDEwMy43NGM4Ljg4LDIuNjIsMTUuNDEsNy4wNywxNC41OSw5Ljk0LS44MywyLjg3LTguNywzLjA4LTE3LjU4LC40Ni04Ljg4LTIuNjItMTUuNDEtNy4wNy0xNC41OS05Ljk0LC44My0yLjg3LDguNy0zLjA4LDE3LjU4LS40NloiIHN0eWxlPSJmaWxsOiMxYzFjMWM7Ii8+PHBhdGggZD0iTTcxLjY0LDk3LjcxYy0yLjA4LTIuMTUtOC44OCwuOTgtMTUuMiw2Ljk5LTYuMzIsNi4wMS05Ljc2LDEyLjYzLTcuNjksMTQuNzgsMi4wOCwyLjE1LDguODgtLjk4LDE1LjItNi45OSw2LjMyLTYuMDEsOS43Ni0xMi42Myw3LjY5LTE0Ljc4WiIgc3R5bGU9ImZpbGw6IzFjMWMxYzsiLz48L3N2Zz4=";
+var PeraWallet = class extends BaseWallet {
+  client = null;
+  options;
+  store;
+  constructor({
+    id,
+    store,
+    subscribe,
+    getAlgodClient,
+    options = {},
+    metadata = {}
+  }) {
+    super({ id, metadata, getAlgodClient, store, subscribe });
+    this.options = options;
+    this.store = store;
+  }
+  static defaultMetadata = { name: "Pera", icon: icon5 };
+  async initializeClient() {
+    console.info("[PeraWallet] Initializing client...");
+    const module = await import("./dist/Y3EB35O7.jsx");
+    const PeraWalletConnect = module.default ? module.default.PeraWalletConnect : module.PeraWalletConnect;
+    const client = new PeraWalletConnect(this.options);
+    client.connector?.on("disconnect", this.onDisconnect);
+    this.client = client;
+    return client;
+  }
+  connect = async () => {
+    console.info("[PeraWallet] Connecting...");
+    try {
+      const client = this.client || await this.initializeClient();
+      const accounts = await client.connect();
+      if (accounts.length === 0) {
+        throw new Error("No accounts found!");
+      }
+      const walletAccounts = accounts.map((address, idx) => ({
+        name: `Pera Wallet ${idx + 1}`,
+        address
+      }));
+      const activeAccount = walletAccounts[0];
+      addWallet(this.store, {
+        walletId: this.id,
+        wallet: {
+          accounts: walletAccounts,
+          activeAccount
+        }
+      });
+      return walletAccounts;
+    } catch (error) {
+      if (error?.data?.type !== "CONNECT_MODAL_CLOSED") {
+        console.error(`[PeraWallet] Error connecting: ${error.message}`);
+      } else {
+        console.info("[PeraWallet] Connection cancelled.");
+      }
+      return [];
+    }
+  };
+  disconnect = async () => {
+    console.info("[PeraWallet] Disconnecting...");
+    try {
+      await this.client?.disconnect();
+      this.onDisconnect();
+    } catch (error) {
+      console.error(error);
+    }
+  };
+  resumeSession = async () => {
+    try {
+      const state = this.store.state;
+      const walletState = state.wallets[this.id];
+      if (!walletState) {
+        return;
+      }
+      console.info("[PeraWallet] Resuming session...");
+      const client = this.client || await this.initializeClient();
+      const accounts = await client.reconnectSession();
+      if (accounts.length === 0) {
+        throw new Error("[PeraWallet] No accounts found!");
+      }
+      const walletAccounts = accounts.map((address, idx) => ({
+        name: `Pera Wallet ${idx + 1}`,
+        address
+      }));
+      const match = compareAccounts(walletAccounts, walletState.accounts);
+      if (!match) {
+        console.warn(`[PeraWallet] Session accounts mismatch, updating accounts`);
+        setAccounts(this.store, {
+          walletId: this.id,
+          accounts: walletAccounts
+        });
+      }
+    } catch (error) {
+      console.error(`[PeraWallet] Error resuming session: ${error.message}`);
+      this.onDisconnect();
+    }
+  };
+  signTransactions = async (txnGroup, indexesToSign, returnGroup = true) => {
+    if (!this.client) {
+      throw new Error("[PeraWallet] Client not initialized!");
+    }
+    const txnsToSign = [];
+    const signedIndexes = [];
+    const msgpackTxnGroup = normalizeTxnGroup(txnGroup);
+    const decodedObjects = msgpackTxnGroup.map((txn) => {
+      return esm_default.decodeObj(txn);
+    });
+    decodedObjects.forEach((txnObject, idx) => {
+      const isSigned = isSignedTxnObject(txnObject);
+      const shouldSign = shouldSignTxnObject(txnObject, this.addresses, indexesToSign, idx);
+      const txnBuffer = msgpackTxnGroup[idx];
+      const txn = isSigned ? esm_default.decodeSignedTransaction(txnBuffer).txn : esm_default.decodeUnsignedTransaction(txnBuffer);
+      if (shouldSign) {
+        txnsToSign.push({ txn });
+        signedIndexes.push(idx);
+      } else {
+        txnsToSign.push({ txn, signers: [] });
+      }
+    });
+    const signedTxns = await this.client.signTransaction([txnsToSign]);
+    const txnGroupSigned = mergeSignedTxnsWithGroup(
+      signedTxns,
+      msgpackTxnGroup,
+      signedIndexes,
+      returnGroup
+    );
+    return txnGroupSigned;
+  };
+  transactionSigner = async (txnGroup, indexesToSign) => {
+    if (!this.client) {
+      throw new Error("[PeraWallet] Client not initialized!");
+    }
+    const txnsToSign = txnGroup.reduce((acc, txn, idx) => {
+      if (indexesToSign.includes(idx)) {
+        acc.push({ txn });
+      } else {
+        acc.push({ txn, signers: [] });
+      }
+      return acc;
+    }, []);
+    const signTxnsResult = await this.client.signTransaction([txnsToSign]);
+    return signTxnsResult;
+  };
+};
+var icon6 = "data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPHN2ZyB2ZXJzaW9uPSIxLjEiIGlkPSJMYXllcl8xIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB4PSIwcHgiIHk9IjBweCIKCSB2aWV3Qm94PSIwIDAgNDgwIDQ4MCIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgNDgwIDQ4MDsiIHhtbDpzcGFjZT0icHJlc2VydmUiPgo8c3R5bGUgdHlwZT0idGV4dC9jc3MiPgoJLnN0MHtmaWxsOiMzMzk2RkY7fQo8L3N0eWxlPgo8cGF0aCBjbGFzcz0ic3QwIiBkPSJNMTI2LjYsMTY4YzYyLjYtNjEuMywxNjQuMi02MS4zLDIyNi44LDBsNy41LDcuNGMzLjEsMy4xLDMuMSw4LDAsMTEuMWwtMjUuOCwyNS4yYy0xLjYsMS41LTQuMSwxLjUtNS43LDAKCWwtMTAuNC0xMC4yYy00My43LTQyLjgtMTE0LjUtNDIuOC0xNTguMiwwbC0xMS4xLDEwLjljLTEuNiwxLjUtNC4xLDEuNS01LjcsMGwtMjUuOC0yNS4yYy0zLjEtMy4xLTMuMS04LDAtMTEuMUwxMjYuNiwxNjh6CgkgTTQwNi43LDIyMC4ybDIyLjksMjIuNWMzLjEsMy4xLDMuMSw4LDAsMTEuMUwzMjYuMiwzNTUuMWMtMy4xLDMuMS04LjIsMy4xLTExLjMsMGwtNzMuNC03MS45Yy0wLjgtMC44LTIuMS0wLjgtMi44LDBsLTczLjQsNzEuOQoJYy0zLjEsMy4xLTguMiwzLjEtMTEuMywwTDUwLjMsMjUzLjhjLTMuMS0zLjEtMy4xLTgsMC0xMS4xbDIyLjktMjIuNWMzLjEtMy4xLDguMi0zLjEsMTEuMywwbDczLjQsNzEuOWMwLjgsMC44LDIuMSwwLjgsMi44LDAKCWw3My40LTcxLjljMy4xLTMuMSw4LjItMy4xLDExLjMsMGw3My40LDcxLjljMC44LDAuOCwyLjEsMC44LDIuOCwwbDczLjQtNzEuOUMzOTguNSwyMTcuMSw0MDMuNiwyMTcuMSw0MDYuNywyMjAuMkw0MDYuNywyMjAuMnoiLz4KPC9zdmc+Cg==";
+var WalletConnect = class extends BaseWallet {
+  client = null;
+  options;
+  modal = null;
+  modalOptions;
+  session = null;
+  chains;
+  store;
+  constructor({
+    id,
+    store,
+    subscribe,
+    getAlgodClient,
+    options,
+    metadata = {}
+  }) {
+    super({ id, metadata, getAlgodClient, store, subscribe });
+    if (!options?.projectId) {
+      throw new Error("[WalletConnect] Missing required option: projectId");
+    }
+    const {
+      projectId,
+      relayUrl = "wss://relay.walletconnect.com",
+      metadata: _metadata,
+      ...modalOptions
+    } = options;
+    this.options = {
+      projectId,
+      relayUrl,
+      ..._metadata
+    };
+    this.modalOptions = modalOptions;
+    this.chains = Object.values(caipChainId);
+    this.store = store;
+  }
+  static defaultMetadata = { name: "WalletConnect", icon: icon6 };
+  async initializeClient() {
+    console.info("[WalletConnect] Initializing client...");
+    const SignClient = (await import("./index.es/F3DWLLSH.jsx")).SignClient;
+    const client = await SignClient.init(this.options);
+    client.on("session_event", (args) => {
+      console.log("[WalletConnect] EVENT", "session_event", args);
+    });
+    client.on("session_update", ({ topic, params }) => {
+      console.log("[WalletConnect] EVENT", "session_update", { topic, params });
+      const { namespaces } = params;
+      const session = client.session.get(topic);
+      const updatedSession = { ...session, namespaces };
+      this.onSessionConnected(updatedSession);
+    });
+    client.on("session_delete", () => {
+      console.log("[WalletConnect] EVENT", "session_delete");
+      this.session = null;
+    });
+    this.client = client;
+    return client;
+  }
+  async initializeModal() {
+    console.info("[WalletConnect] Initializing modal...");
+    const WalletConnectModal = (await import("./dist/5CZLQJ23.jsx")).WalletConnectModal;
+    const modal = new WalletConnectModal({
+      projectId: this.options.projectId,
+      chains: this.chains,
+      ...this.modalOptions
+    });
+    modal.subscribeModal(
+      (state) => console.info(`[WalletConnect] Modal ${state.open ? "open" : "closed"}`)
+    );
+    this.modal = modal;
+    return modal;
+  }
+  onSessionConnected(session) {
+    const caipAccounts = session.namespaces.algorand.accounts;
+    if (!caipAccounts.length) {
+      throw new Error("No accounts found!");
+    }
+    const accounts = [...new Set(caipAccounts.map((account) => account.split(":").pop()))];
+    const walletAccounts = accounts.map((address, idx) => ({
+      name: `WalletConnect ${idx + 1}`,
+      address
+    }));
+    const state = this.store.state;
+    const walletState = state.wallets[this.id];
+    if (!walletState) {
+      addWallet(this.store, {
+        walletId: this.id,
+        wallet: {
+          accounts: walletAccounts,
+          activeAccount: walletAccounts[0]
+        }
+      });
+    } else {
+      const match = compareAccounts(walletAccounts, walletState.accounts);
+      if (!match) {
+        console.warn(`[WalletConnect] Session accounts mismatch, updating accounts`);
+        setAccounts(this.store, {
+          walletId: this.id,
+          accounts: walletAccounts
+        });
+      }
+    }
+    this.session = session;
+    return walletAccounts;
+  }
+  connect = async () => {
+    console.info("[WalletConnect] Connecting...");
+    try {
+      const client = this.client || await this.initializeClient();
+      const modal = this.modal || await this.initializeModal();
+      const requiredNamespaces = {
+        algorand: {
+          chains: this.chains,
+          methods: ["algo_signTxn"],
+          events: []
+        }
+      };
+      const { uri, approval } = await client.connect({ requiredNamespaces });
+      if (!uri) {
+        throw new Error("No URI found");
+      }
+      await modal.openModal({ uri });
+      const session = await approval();
+      const walletAccounts = this.onSessionConnected(session);
+      return walletAccounts;
+    } catch (error) {
+      console.error(`[WalletConnect] Error connecting: ${error.message}`);
+      return [];
+    } finally {
+      this.modal?.closeModal();
+    }
+  };
+  disconnect = async () => {
+    console.info("[WalletConnect] Disconnecting...");
+    try {
+      if (this.client && this.session) {
+        await this.client.disconnect({
+          topic: this.session.topic,
+          reason: {
+            message: "User disconnected.",
+            code: 6e3
+          }
+        });
+      }
+      this.onDisconnect();
+    } catch (error) {
+      console.error(error);
+    }
+  };
+  resumeSession = async () => {
+    try {
+      const state = this.store.state;
+      const walletState = state.wallets[this.id];
+      if (!walletState) {
+        return;
+      }
+      console.info("[WalletConnect] Resuming session...");
+      const client = this.client || await this.initializeClient();
+      if (client.session.length) {
+        const lastKeyIndex = client.session.keys.length - 1;
+        const restoredSession = client.session.get(client.session.keys[lastKeyIndex]);
+        this.onSessionConnected(restoredSession);
+      }
+    } catch (error) {
+      console.error(`[WalletConnect] Error resuming session: ${error.message}`);
+      this.onDisconnect();
+    }
+  };
+  signTransactions = async (txnGroup, indexesToSign, returnGroup = true) => {
+    if (!this.client) {
+      throw new Error("[WalletConnect] Client not initialized!");
+    }
+    if (!this.session) {
+      throw new Error("[WalletConnect] Session is not connected");
+    }
+    if (this.activeNetwork === "localnet") {
+      throw new Error(`[WalletConnect] Invalid network: ${this.activeNetwork}`);
+    }
+    const txnsToSign = [];
+    const signedIndexes = [];
+    const msgpackTxnGroup = normalizeTxnGroup(txnGroup);
+    const decodedObjects = msgpackTxnGroup.map((txn) => {
+      return esm_default.decodeObj(txn);
+    });
+    decodedObjects.forEach((txnObject, idx) => {
+      const isSigned = isSignedTxnObject(txnObject);
+      const shouldSign = shouldSignTxnObject(txnObject, this.addresses, indexesToSign, idx);
+      const txnBuffer = msgpackTxnGroup[idx];
+      const txn = isSigned ? esm_default.decodeSignedTransaction(txnBuffer).txn : esm_default.decodeUnsignedTransaction(txnBuffer);
+      const txnBase64 = byteArrayToBase64(txn.toByte());
+      if (shouldSign) {
+        txnsToSign.push({ txn: txnBase64 });
+        signedIndexes.push(idx);
+      } else {
+        txnsToSign.push({ txn: txnBase64, signers: [] });
+      }
+    });
+    const request = formatJsonRpcRequest("algo_signTxn", [txnsToSign]);
+    const signTxnsResult = await this.client.request({
+      chainId: caipChainId[this.activeNetwork],
+      topic: this.session.topic,
+      request
+    });
+    const signedTxnsBase64 = signTxnsResult.filter(Boolean);
+    const signedTxns = signedTxnsBase64.map((txn) => base64ToByteArray(txn));
+    const txnGroupSigned = mergeSignedTxnsWithGroup(
+      signedTxns,
+      msgpackTxnGroup,
+      signedIndexes,
+      returnGroup
+    );
+    return txnGroupSigned;
+  };
+  transactionSigner = async (txnGroup, indexesToSign) => {
+    if (!this.client) {
+      throw new Error("[WalletConnect] Client not initialized!");
+    }
+    if (!this.session) {
+      throw new Error("[WalletConnect] Session is not connected");
+    }
+    if (this.activeNetwork === "localnet") {
+      throw new Error(`[WalletConnect] Invalid network: ${this.activeNetwork}`);
+    }
+    const txnsToSign = txnGroup.reduce((acc, txn, idx) => {
+      const txnBase64 = byteArrayToBase64(txn.toByte());
+      if (indexesToSign.includes(idx)) {
+        acc.push({ txn: txnBase64 });
+      } else {
+        acc.push({ txn: txnBase64, signers: [] });
+      }
+      return acc;
+    }, []);
+    const request = formatJsonRpcRequest("algo_signTxn", [txnsToSign]);
+    const signTxnsResult = await this.client.request({
+      chainId: caipChainId[this.activeNetwork],
+      topic: this.session.topic,
+      request
+    });
+    const signedTxnsBase64 = signTxnsResult.filter(Boolean);
+    const signedTxns = signedTxnsBase64.map((txn) => base64ToByteArray(txn));
+    return signedTxns;
+  };
+};
+function createWalletMap() {
+  return {
+    [
+      "defly"
+      /* DEFLY */
+    ]: DeflyWallet,
+    [
+      "exodus"
+      /* EXODUS */
+    ]: ExodusWallet,
+    [
+      "kibisis"
+      /* KIBISIS */
+    ]: KibisisWallet,
+    [
+      "kmd"
+      /* KMD */
+    ]: KmdWallet,
+    [
+      "lute"
+      /* LUTE */
+    ]: LuteWallet,
+    [
+      "mnemonic"
+      /* MNEMONIC */
+    ]: MnemonicWallet,
+    [
+      "pera"
+      /* PERA */
+    ]: PeraWallet,
+    [
+      "walletconnect"
+      /* WALLETCONNECT */
+    ]: WalletConnect
+  };
+}
+function compareAccounts(accounts, compareTo) {
+  const addresses = new Set(accounts.map((account) => account.address));
+  const compareAddresses = new Set(compareTo.map((account) => account.address));
+  if (addresses.size !== compareAddresses.size) {
+    return false;
+  }
+  for (const address of addresses) {
+    if (!compareAddresses.has(address)) {
+      return false;
+    }
+  }
+  return true;
+}
+function base64ToByteArray(blob) {
+  return stringToByteArray(atob(blob));
+}
+function byteArrayToBase64(array) {
+  return btoa(byteArrayToString(array));
+}
+function stringToByteArray(str) {
+  const array = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; i++) {
+    array[i] = str.charCodeAt(i);
+  }
+  return array;
+}
+function byteArrayToString(array) {
+  let result = "";
+  for (let i = 0; i < array.length; i++) {
+    result += String.fromCharCode(array[i]);
+  }
+  return result;
+}
+function isTransaction(item) {
+  if (Array.isArray(item)) {
+    return item.every(
+      (elem) => typeof elem === "object" && elem !== null && "genesisID" in elem && typeof elem.genesisID === "string"
+    );
+  } else {
+    return typeof item === "object" && item !== null && "genesisID" in item && typeof item.genesisID === "string";
+  }
+}
+function isSignedTxnObject(item) {
+  return item.txn !== void 0;
+}
+function normalizeTxnGroup(txnGroup) {
+  if (!txnGroup[0]) {
+    throw new Error("Empty transaction group!");
+  }
+  const isTransactionType = isTransaction(txnGroup[0]);
+  if (isTransactionType) {
+    const transactionGroup = Array.isArray(txnGroup[0]) ? txnGroup.flatMap((txn) => txn) : txnGroup;
+    return transactionGroup.map((txn) => {
+      return esm_default.encodeUnsignedTransaction(txn);
+    });
+  } else {
+    const transactionGroup = Array.isArray(txnGroup[0]) ? txnGroup.flatMap((txn) => txn) : txnGroup;
+    return transactionGroup;
+  }
+}
+function shouldSignTxnObject(txnObject, addresses, indexesToSign, idx) {
+  const isIndexMatch = !indexesToSign || indexesToSign.includes(idx);
+  const isSigned = isSignedTxnObject(txnObject);
+  const canSign = !isSigned && addresses.includes(esm_default.encodeAddress(txnObject.snd));
+  const shouldSign = isIndexMatch && canSign;
+  return shouldSign;
+}
+function mergeSignedTxnsWithGroup(signedTxns, txnGroup, signedIndexes, returnGroup) {
+  return txnGroup.reduce((acc, txn, i) => {
+    if (signedIndexes.includes(i)) {
+      const signedByUser = signedTxns.shift();
+      signedByUser && acc.push(signedByUser);
+    } else if (returnGroup) {
+      acc.push(txnGroup[i]);
+    }
+    return acc;
+  }, []);
+}
+function getPayloadId() {
+  const date = Date.now() * Math.pow(10, 3);
+  const extra = Math.floor(Math.random() * Math.pow(10, 3));
+  return date + extra;
+}
+function formatJsonRpcRequest(method, params) {
+  return {
+    id: getPayloadId(),
+    jsonrpc: "2.0",
+    method,
+    params
+  };
+}
+function deepMerge(target, source) {
+  const isObject = (obj) => obj && typeof obj === "object";
+  if (!isObject(target) || !isObject(source)) {
+    throw new Error("Target and source must be objects");
+  }
+  Object.keys(source).forEach((key) => {
+    const targetValue = target[key];
+    const sourceValue = source[key];
+    if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+      target[key] = targetValue.concat(sourceValue);
+    } else if (isObject(targetValue) && isObject(sourceValue)) {
+      target[key] = deepMerge(Object.assign({}, targetValue), sourceValue);
+    } else {
+      target[key] = sourceValue;
+    }
+  });
+  return target;
+}
+function generateUuid() {
+  if (window.crypto.randomUUID) {
+    return window.crypto.randomUUID();
+  }
+  return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (value) => {
+    const valueAsNumber = parseInt(value);
+    return (valueAsNumber ^ window.crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> valueAsNumber / 4).toString(16);
+  });
+}
+var icon7 = "data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9Im5vIj8+CjwhRE9DVFlQRSBzdmcgUFVCTElDICItLy9XM0MvL0RURCBTVkcgMS4xLy9FTiIgImh0dHA6Ly93d3cudzMub3JnL0dyYXBoaWNzL1NWRy8xLjEvRFREL3N2ZzExLmR0ZCI+Cjxzdmcgd2lkdGg9IjEwMCUiIGhlaWdodD0iMTAwJSIgdmlld0JveD0iMCAwIDEwMjQgMTAyNCIgdmVyc2lvbj0iMS4xIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB4bWw6c3BhY2U9InByZXNlcnZlIiB4bWxuczpzZXJpZj0iaHR0cDovL3d3dy5zZXJpZi5jb20vIiBzdHlsZT0iZmlsbC1ydWxlOmV2ZW5vZGQ7Y2xpcC1ydWxlOmV2ZW5vZGQ7c3Ryb2tlLWxpbmVqb2luOnJvdW5kO3N0cm9rZS1taXRlcmxpbWl0OjI7Ij4KICAgIDxyZWN0IHg9IjAiIHk9IjAiIHdpZHRoPSIxMDI0IiBoZWlnaHQ9IjEwMjQiLz4KICAgIDxnIHRyYW5zZm9ybT0ibWF0cml4KDEuNjgyMDksMCwwLDEuNjgyMDksMjI2LjM2OCwyMTIuODE4KSI+CiAgICAgICAgPHBhdGggZD0iTTMyNy4wNDksMjgwLjE5MkwxNjkuNTI0LDEzTDEyLDI4MC4xOTJMMTY5LjUyNCwxODkuMDg0TDMyNy4wNDksMjgwLjE5MloiIHN0eWxlPSJmaWxsOndoaXRlO2ZpbGwtcnVsZTpub256ZXJvOyIvPgogICAgPC9nPgogICAgPGcgdHJhbnNmb3JtPSJtYXRyaXgoMS42ODIwOSwwLDAsMS42ODIwOSwyMjYuMzY4LDIxMi44MTgpIj4KICAgICAgICA8cGF0aCBkPSJNMjk5LjU0NiwzMDdMMTY5LjUyNSwyMzguNDczTDM5LjUwNCwzMDdMMTY5LjUyNSwyNjQuNjdMMjk5LjU0NiwzMDdaIiBzdHlsZT0iZmlsbDp3aGl0ZTtmaWxsLXJ1bGU6bm9uemVybzsiLz4KICAgIDwvZz4KPC9zdmc+Cg==";
+var DeflyWallet = class extends BaseWallet {
+  client = null;
+  options;
+  store;
+  constructor({
+    id,
+    store,
+    subscribe,
+    getAlgodClient,
+    options = {},
+    metadata = {}
+  }) {
+    super({ id, metadata, getAlgodClient, store, subscribe });
+    this.options = options;
+    this.store = store;
+  }
+  static defaultMetadata = { name: "Defly", icon: icon7 };
+  async initializeClient() {
+    console.info("[DeflyWallet] Initializing client...");
+    const module = await import("./dist/ONNQ4WBY.jsx");
+    const DeflyWalletConnect = module.default ? module.default.DeflyWalletConnect : module.DeflyWalletConnect;
+    const client = new DeflyWalletConnect(this.options);
+    client.connector?.on("disconnect", this.onDisconnect);
+    this.client = client;
+    return client;
+  }
+  connect = async () => {
+    console.info("[DeflyWallet] Connecting...");
+    try {
+      const client = this.client || await this.initializeClient();
+      const accounts = await client.connect();
+      if (accounts.length === 0) {
+        throw new Error("No accounts found!");
+      }
+      const walletAccounts = accounts.map((address, idx) => ({
+        name: `Defly Wallet ${idx + 1}`,
+        address
+      }));
+      const activeAccount = walletAccounts[0];
+      addWallet(this.store, {
+        walletId: this.id,
+        wallet: {
+          accounts: walletAccounts,
+          activeAccount
+        }
+      });
+      return walletAccounts;
+    } catch (error) {
+      if (error?.data?.type !== "CONNECT_MODAL_CLOSED") {
+        console.error(`[DeflyWallet] Error connecting: ${error.message}`);
+      } else {
+        console.info("[DeflyWallet] Connection cancelled.");
+      }
+      return [];
+    }
+  };
+  disconnect = async () => {
+    console.info("[DeflyWallet] Disconnecting...");
+    try {
+      await this.client?.disconnect();
+      this.onDisconnect();
+    } catch (error) {
+      console.error(error);
+    }
+  };
+  resumeSession = async () => {
+    try {
+      const state = this.store.state;
+      const walletState = state.wallets[this.id];
+      if (!walletState) {
+        return;
+      }
+      console.info("[DeflyWallet] Resuming session...");
+      const client = this.client || await this.initializeClient();
+      const accounts = await client.reconnectSession();
+      if (accounts.length === 0) {
+        throw new Error("[DeflyWallet] No accounts found!");
+      }
+      const walletAccounts = accounts.map((address, idx) => ({
+        name: `Defly Wallet ${idx + 1}`,
+        address
+      }));
+      const match = compareAccounts(walletAccounts, walletState.accounts);
+      if (!match) {
+        console.warn(`[DeflyWallet] Session accounts mismatch, updating accounts`);
+        setAccounts(this.store, {
+          walletId: this.id,
+          accounts: walletAccounts
+        });
+      }
+    } catch (error) {
+      console.error(`[DeflyWallet] Error resuming session: ${error.message}`);
+      this.onDisconnect();
+    }
+  };
+  signTransactions = async (txnGroup, indexesToSign, returnGroup = true) => {
+    if (!this.client) {
+      throw new Error("[DeflyWallet] Client not initialized!");
+    }
+    const txnsToSign = [];
+    const signedIndexes = [];
+    const msgpackTxnGroup = normalizeTxnGroup(txnGroup);
+    const decodedObjects = msgpackTxnGroup.map((txn) => {
+      return esm_default.decodeObj(txn);
+    });
+    decodedObjects.forEach((txnObject, idx) => {
+      const isSigned = isSignedTxnObject(txnObject);
+      const shouldSign = shouldSignTxnObject(txnObject, this.addresses, indexesToSign, idx);
+      const txnBuffer = msgpackTxnGroup[idx];
+      const txn = isSigned ? esm_default.decodeSignedTransaction(txnBuffer).txn : esm_default.decodeUnsignedTransaction(txnBuffer);
+      if (shouldSign) {
+        txnsToSign.push({ txn });
+        signedIndexes.push(idx);
+      } else {
+        txnsToSign.push({ txn, signers: [] });
+      }
+    });
+    const signedTxns = await this.client.signTransaction([txnsToSign]);
+    const txnGroupSigned = mergeSignedTxnsWithGroup(
+      signedTxns,
+      msgpackTxnGroup,
+      signedIndexes,
+      returnGroup
+    );
+    return txnGroupSigned;
+  };
+  transactionSigner = async (txnGroup, indexesToSign) => {
+    if (!this.client) {
+      throw new Error("[DeflyWallet] Client not initialized!");
+    }
+    const txnsToSign = txnGroup.reduce((acc, txn, idx) => {
+      if (indexesToSign.includes(idx)) {
+        acc.push({ txn });
+      } else {
+        acc.push({ txn, signers: [] });
+      }
+      return acc;
+    }, []);
+    const signTxnsResult = await this.client.signTransaction([txnsToSign]);
+    return signTxnsResult;
+  };
+};
+var defaultState = {
+  wallets: {},
+  activeWallet: null,
+  activeNetwork: "testnet"
+  /* TESTNET */
+};
+var LOCAL_STORAGE_KEY = "@txnlab/use-wallet:v3";
+function addWallet(store, { walletId, wallet }) {
+  store.setState((state) => {
+    const newWallets = {
+      ...state.wallets,
+      [walletId]: wallet
+    };
+    return {
+      ...state,
+      wallets: newWallets,
+      activeWallet: walletId
+    };
+  });
+}
+function removeWallet(store, { walletId }) {
+  store.setState((state) => {
+    const newWallets = { ...state.wallets };
+    delete newWallets[walletId];
+    return {
+      ...state,
+      wallets: newWallets,
+      activeWallet: state.activeWallet === walletId ? null : state.activeWallet
+    };
+  });
+}
+function setActiveWallet(store, { walletId }) {
+  store.setState((state) => {
+    return {
+      ...state,
+      activeWallet: walletId
+    };
+  });
+}
+function setActiveAccount(store, { walletId, address }) {
+  store.setState((state) => {
+    const wallet = state.wallets[walletId];
+    if (!wallet) {
+      return state;
+    }
+    const activeAccount = wallet.accounts.find((a) => a.address === address);
+    if (!activeAccount) {
+      return state;
+    }
+    const newWallets = {
+      ...state.wallets,
+      [walletId]: {
+        ...wallet,
+        activeAccount
+      }
+    };
+    return {
+      ...state,
+      wallets: newWallets
+    };
+  });
+}
+function setAccounts(store, { walletId, accounts }) {
+  store.setState((state) => {
+    const wallet = state.wallets[walletId];
+    if (!wallet) {
+      return state;
+    }
+    const isActiveAccountConnected = accounts.some(
+      (account) => account.address === wallet.activeAccount?.address
+    );
+    const activeAccount = isActiveAccountConnected ? wallet.activeAccount : accounts[0] || null;
+    const newWallet = {
+      ...wallet,
+      accounts,
+      activeAccount
+    };
+    const newWallets = {
+      ...state.wallets,
+      [walletId]: newWallet
+    };
+    return {
+      ...state,
+      wallets: newWallets
+    };
+  });
+}
+function setActiveNetwork(store, { networkId }) {
+  store.setState((state) => {
+    return {
+      ...state,
+      activeNetwork: networkId
+    };
+  });
+}
+function isValidWalletId(walletId) {
+  return Object.values(WalletId).includes(walletId);
+}
+function isValidWalletAccount(account) {
+  return typeof account === "object" && account !== null && typeof account.name === "string" && typeof account.address === "string";
+}
+function isValidWalletState(wallet) {
+  return typeof wallet === "object" && wallet !== null && Array.isArray(wallet.accounts) && wallet.accounts.every(isValidWalletAccount) && (wallet.activeAccount === null || isValidWalletAccount(wallet.activeAccount));
+}
+function isValidState(state) {
+  if (!state || typeof state !== "object")
+    return false;
+  if (typeof state.wallets !== "object")
+    return false;
+  for (const [walletId, wallet] of Object.entries(state.wallets)) {
+    if (!isValidWalletId(walletId) || !isValidWalletState(wallet))
+      return false;
+  }
+  if (state.activeWallet !== null && !isValidWalletId(state.activeWallet))
+    return false;
+  if (!isValidNetworkId(state.activeNetwork))
+    return false;
+  return true;
+}
+var WalletManager = class {
+  _clients = /* @__PURE__ */ new Map();
+  networkConfig;
+  algodClient;
+  store;
+  subscribe;
+  constructor({ wallets = [], network = "testnet", algod = {} } = {}) {
+    const initialState = this.loadPersistedState() || {
+      ...defaultState,
+      activeNetwork: network
+    };
+    this.store = new Store(initialState, {
+      onUpdate: () => this.savePersistedState()
+    });
+    this.savePersistedState();
+    this.subscribe = (callback) => {
+      const unsubscribe = this.store.subscribe(() => {
+        callback(this.store.state);
+      });
+      return unsubscribe;
+    };
+    this.networkConfig = this.initNetworkConfig(network, algod);
+    this.algodClient = this.createAlgodClient(this.networkConfig[network]);
+    this.initializeWallets(wallets);
+  }
+  // ---------- Store ------------------------------------------------- //
+  loadPersistedState() {
+    try {
+      const serializedState = StorageAdapter.getItem(LOCAL_STORAGE_KEY);
+      if (serializedState === null) {
+        return null;
+      }
+      const parsedState = JSON.parse(serializedState);
+      if (!isValidState(parsedState)) {
+        console.warn("[Store] Parsed state:", parsedState);
+        throw new Error("Persisted state is invalid");
+      }
+      return parsedState;
+    } catch (error) {
+      console.error(`[Store] Could not load state from local storage: ${error.message}`);
+      return null;
+    }
+  }
+  savePersistedState() {
+    try {
+      const state = this.store.state;
+      const serializedState = JSON.stringify(state);
+      StorageAdapter.setItem(LOCAL_STORAGE_KEY, serializedState);
+    } catch (error) {
+      console.error("[Store] Could not save state to local storage:", error);
+    }
+  }
+  // ---------- Wallets ----------------------------------------------- //
+  initializeWallets(walletsConfig) {
+    console.info("[Manager] Initializing wallets...");
+    for (const walletConfig of walletsConfig) {
+      let walletId;
+      let walletOptions;
+      let walletMetadata;
+      if (typeof walletConfig === "string") {
+        walletId = walletConfig;
+      } else {
+        const { id, options, metadata } = walletConfig;
+        walletId = id;
+        walletOptions = options;
+        walletMetadata = metadata;
+      }
+      const walletMap = createWalletMap();
+      const WalletClass = walletMap[walletId];
+      if (!WalletClass) {
+        console.error(`[Manager] Wallet not found: ${walletId}`);
+        continue;
+      }
+      const walletInstance = new WalletClass({
+        id: walletId,
+        metadata: walletMetadata,
+        options: walletOptions,
+        getAlgodClient: this.getAlgodClient,
+        store: this.store,
+        subscribe: this.subscribe
+      });
+      this._clients.set(walletId, walletInstance);
+      console.info(`[Manager] \u2705 Initialized ${walletId}`);
+    }
+    const state = this.store.state;
+    const connectedWallets = Object.keys(state.wallets);
+    for (const walletId of connectedWallets) {
+      if (!this._clients.has(walletId)) {
+        console.warn(`[Manager] Connected wallet not found: ${walletId}`);
+        removeWallet(this.store, { walletId });
+      }
+    }
+    if (state.activeWallet && !this._clients.has(state.activeWallet)) {
+      console.warn(`[Manager] Active wallet not found: ${state.activeWallet}`);
+      setActiveWallet(this.store, { walletId: null });
+    }
+  }
+  get wallets() {
+    return [...this._clients.values()];
+  }
+  getWallet(walletId) {
+    return this._clients.get(walletId);
+  }
+  async resumeSessions() {
+    const promises = this.wallets.map((wallet) => wallet?.resumeSession());
+    await Promise.all(promises);
+  }
+  // ---------- Network ----------------------------------------------- //
+  initNetworkConfig(network, config) {
+    console.info("[Manager] Initializing network...");
+    let networkConfig = createDefaultNetworkConfig();
+    if (isNetworkConfigMap(config)) {
+      networkConfig = deepMerge(networkConfig, config);
+    } else {
+      networkConfig[network] = deepMerge(networkConfig[network], config);
+    }
+    console.info("[Manager] Algodv2 config:", networkConfig);
+    return networkConfig;
+  }
+  createAlgodClient(config) {
+    console.info(`[Manager] Creating Algodv2 client for ${this.activeNetwork}...`);
+    const { token = "", baseServer, port = "", headers = {} } = config;
+    return new esm_default.Algodv2(token, baseServer, port, headers);
+  }
+  getAlgodClient = () => {
+    return this.algodClient;
+  };
+  setActiveNetwork = (networkId) => {
+    setActiveNetwork(this.store, { networkId });
+    this.algodClient = this.createAlgodClient(this.networkConfig[networkId]);
+  };
+  get activeNetwork() {
+    return this.store.state.activeNetwork;
+  }
+  // ---------- Active Wallet ----------------------------------------- //
+  get activeWallet() {
+    const state = this.store.state;
+    const activeWallet = this.wallets.find((wallet) => wallet.id === state.activeWallet);
+    if (!activeWallet) {
+      return null;
+    }
+    return activeWallet;
+  }
+  get activeWalletAccounts() {
+    if (!this.activeWallet) {
+      return null;
+    }
+    return this.activeWallet.accounts;
+  }
+  get activeWalletAddresses() {
+    if (!this.activeWallet) {
+      return null;
+    }
+    return this.activeWallet.accounts.map((account) => account.address);
+  }
+  get activeAccount() {
+    if (!this.activeWallet) {
+      return null;
+    }
+    return this.activeWallet.activeAccount;
+  }
+  get activeAddress() {
+    if (!this.activeAccount) {
+      return null;
+    }
+    return this.activeAccount.address;
+  }
+  // ---------- Sign Transactions ------------------------------------- //
+  get signTransactions() {
+    if (!this.activeWallet) {
+      throw new Error("[Manager] No active wallet found!");
+    }
+    return this.activeWallet.signTransactions;
+  }
+  /**
+   * A function which can sign transactions from an atomic transaction group. The logic will be
+   * specific to each wallet, but the function will always return a promise that resolves to an
+   * array of encoded signed transactions matching the length of the indexesToSign array.
+   *
+   * @see https://github.com/algorand/js-algorand-sdk/blob/v2.6.0/src/signer.ts#L7-L18
+   *
+   * @param txnGroup - The atomic group containing transactions to be signed
+   * @param indexesToSign - An array of indexes in the atomic transaction group that should be signed
+   * @returns A promise which resolves an array of encoded signed transactions. The length of the
+   *   array will be the same as the length of indexesToSign, and each index i in the array
+   *   corresponds to the signed transaction from txnGroup[indexesToSign[i]]
+   */
+  get transactionSigner() {
+    if (!this.activeWallet) {
+      throw new Error("[Manager] No active wallet found!");
+    }
+    return this.activeWallet.transactionSigner;
+  }
+};
+
+// ../../node_modules/.pnpm/solid-js@1.8.16/node_modules/solid-js/dist/solid.js
+var sharedConfig = {
+  context: void 0,
+  registry: void 0
+};
+function setHydrateContext(context) {
+  sharedConfig.context = context;
+}
+var equalFn = (a, b) => a === b;
+var $PROXY = Symbol("solid-proxy");
+var $TRACK = Symbol("solid-track");
+var $DEVCOMP = Symbol("solid-dev-component");
+var signalOptions = {
+  equals: equalFn
+};
+var ERROR = null;
+var runEffects = runQueue;
+var STALE = 1;
+var PENDING = 2;
+var UNOWNED = {
+  owned: null,
+  cleanups: null,
+  context: null,
+  owner: null
+};
+var Owner = null;
+var Transition = null;
+var Scheduler = null;
+var ExternalSourceConfig = null;
+var Listener = null;
+var Updates = null;
+var Effects = null;
+var ExecCount = 0;
+function createSignal(value, options) {
+  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+  const s = {
+    value,
+    observers: null,
+    observerSlots: null,
+    comparator: options.equals || void 0
+  };
+  const setter = (value2) => {
+    if (typeof value2 === "function") {
+      if (Transition && Transition.running && Transition.sources.has(s))
+        value2 = value2(s.tValue);
+      else
+        value2 = value2(s.value);
+    }
+    return writeSignal(s, value2);
+  };
+  return [readSignal.bind(s), setter];
+}
+function createRenderEffect(fn, value, options) {
+  const c = createComputation(fn, value, false, STALE);
+  if (Scheduler && Transition && Transition.running)
+    Updates.push(c);
+  else
+    updateComputation(c);
+}
+function createEffect(fn, value, options) {
+  runEffects = runUserEffects;
+  const c = createComputation(fn, value, false, STALE), s = SuspenseContext && useContext(SuspenseContext);
+  if (s)
+    c.suspense = s;
+  if (!options || !options.render)
+    c.user = true;
+  Effects ? Effects.push(c) : updateComputation(c);
+}
+function createMemo(fn, value, options) {
+  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+  const c = createComputation(fn, value, true, 0);
+  c.observers = null;
+  c.observerSlots = null;
+  c.comparator = options.equals || void 0;
+  if (Scheduler && Transition && Transition.running) {
+    c.tState = STALE;
+    Updates.push(c);
+  } else
+    updateComputation(c);
+  return readSignal.bind(c);
+}
+function batch(fn) {
+  return runUpdates(fn, false);
+}
+function untrack(fn) {
+  if (!ExternalSourceConfig && Listener === null)
+    return fn();
+  const listener = Listener;
+  Listener = null;
+  try {
+    if (ExternalSourceConfig)
+      return ExternalSourceConfig.untrack(fn);
+    return fn();
+  } finally {
+    Listener = listener;
+  }
+}
+function onMount(fn) {
+  createEffect(() => untrack(fn));
+}
+function onCleanup(fn) {
+  if (Owner === null)
+    ;
+  else if (Owner.cleanups === null)
+    Owner.cleanups = [fn];
+  else
+    Owner.cleanups.push(fn);
+  return fn;
+}
+function getListener() {
+  return Listener;
+}
+function startTransition(fn) {
+  if (Transition && Transition.running) {
+    fn();
+    return Transition.done;
+  }
+  const l = Listener;
+  const o = Owner;
+  return Promise.resolve().then(() => {
+    Listener = l;
+    Owner = o;
+    let t;
+    if (Scheduler || SuspenseContext) {
+      t = Transition || (Transition = {
+        sources: /* @__PURE__ */ new Set(),
+        effects: [],
+        promises: /* @__PURE__ */ new Set(),
+        disposed: /* @__PURE__ */ new Set(),
+        queue: /* @__PURE__ */ new Set(),
+        running: true
+      });
+      t.done || (t.done = new Promise((res) => t.resolve = res));
+      t.running = true;
+    }
+    runUpdates(fn, false);
+    Listener = Owner = null;
+    return t ? t.done : void 0;
+  });
+}
+var [transPending, setTransPending] = /* @__PURE__ */ createSignal(false);
+function createContext(defaultValue, options) {
+  const id = Symbol("context");
+  return {
+    id,
+    Provider: createProvider(id),
+    defaultValue
+  };
+}
+function useContext(context) {
+  return Owner && Owner.context && Owner.context[context.id] !== void 0 ? Owner.context[context.id] : context.defaultValue;
+}
+function children(fn) {
+  const children2 = createMemo(fn);
+  const memo = createMemo(() => resolveChildren(children2()));
+  memo.toArray = () => {
+    const c = memo();
+    return Array.isArray(c) ? c : c != null ? [c] : [];
+  };
+  return memo;
+}
+var SuspenseContext;
+function readSignal() {
+  const runningTransition = Transition && Transition.running;
+  if (this.sources && (runningTransition ? this.tState : this.state)) {
+    if ((runningTransition ? this.tState : this.state) === STALE)
+      updateComputation(this);
+    else {
+      const updates = Updates;
+      Updates = null;
+      runUpdates(() => lookUpstream(this), false);
+      Updates = updates;
+    }
+  }
+  if (Listener) {
+    const sSlot = this.observers ? this.observers.length : 0;
+    if (!Listener.sources) {
+      Listener.sources = [this];
+      Listener.sourceSlots = [sSlot];
+    } else {
+      Listener.sources.push(this);
+      Listener.sourceSlots.push(sSlot);
+    }
+    if (!this.observers) {
+      this.observers = [Listener];
+      this.observerSlots = [Listener.sources.length - 1];
+    } else {
+      this.observers.push(Listener);
+      this.observerSlots.push(Listener.sources.length - 1);
+    }
+  }
+  if (runningTransition && Transition.sources.has(this))
+    return this.tValue;
+  return this.value;
+}
+function writeSignal(node, value, isComp) {
+  let current = Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value;
+  if (!node.comparator || !node.comparator(current, value)) {
+    if (Transition) {
+      const TransitionRunning = Transition.running;
+      if (TransitionRunning || !isComp && Transition.sources.has(node)) {
+        Transition.sources.add(node);
+        node.tValue = value;
+      }
+      if (!TransitionRunning)
+        node.value = value;
+    } else
+      node.value = value;
+    if (node.observers && node.observers.length) {
+      runUpdates(() => {
+        for (let i = 0; i < node.observers.length; i += 1) {
+          const o = node.observers[i];
+          const TransitionRunning = Transition && Transition.running;
+          if (TransitionRunning && Transition.disposed.has(o))
+            continue;
+          if (TransitionRunning ? !o.tState : !o.state) {
+            if (o.pure)
+              Updates.push(o);
+            else
+              Effects.push(o);
+            if (o.observers)
+              markDownstream(o);
+          }
+          if (!TransitionRunning)
+            o.state = STALE;
+          else
+            o.tState = STALE;
+        }
+        if (Updates.length > 1e6) {
+          Updates = [];
+          if (false)
+            ;
+          throw new Error();
+        }
+      }, false);
+    }
+  }
+  return value;
+}
+function updateComputation(node) {
+  if (!node.fn)
+    return;
+  cleanNode(node);
+  const time = ExecCount;
+  runComputation(
+    node,
+    Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value,
+    time
+  );
+  if (Transition && !Transition.running && Transition.sources.has(node)) {
+    queueMicrotask(() => {
+      runUpdates(() => {
+        Transition && (Transition.running = true);
+        Listener = Owner = node;
+        runComputation(node, node.tValue, time);
+        Listener = Owner = null;
+      }, false);
+    });
+  }
+}
+function runComputation(node, value, time) {
+  let nextValue;
+  const owner = Owner, listener = Listener;
+  Listener = Owner = node;
+  try {
+    nextValue = node.fn(value);
+  } catch (err) {
+    if (node.pure) {
+      if (Transition && Transition.running) {
+        node.tState = STALE;
+        node.tOwned && node.tOwned.forEach(cleanNode);
+        node.tOwned = void 0;
+      } else {
+        node.state = STALE;
+        node.owned && node.owned.forEach(cleanNode);
+        node.owned = null;
+      }
+    }
+    node.updatedAt = time + 1;
+    return handleError(err);
+  } finally {
+    Listener = listener;
+    Owner = owner;
+  }
+  if (!node.updatedAt || node.updatedAt <= time) {
+    if (node.updatedAt != null && "observers" in node) {
+      writeSignal(node, nextValue, true);
+    } else if (Transition && Transition.running && node.pure) {
+      Transition.sources.add(node);
+      node.tValue = nextValue;
+    } else
+      node.value = nextValue;
+    node.updatedAt = time;
+  }
+}
+function createComputation(fn, init, pure, state = STALE, options) {
+  const c = {
+    fn,
+    state,
+    updatedAt: null,
+    owned: null,
+    sources: null,
+    sourceSlots: null,
+    cleanups: null,
+    value: init,
+    owner: Owner,
+    context: Owner ? Owner.context : null,
+    pure
+  };
+  if (Transition && Transition.running) {
+    c.state = 0;
+    c.tState = state;
+  }
+  if (Owner === null)
+    ;
+  else if (Owner !== UNOWNED) {
+    if (Transition && Transition.running && Owner.pure) {
+      if (!Owner.tOwned)
+        Owner.tOwned = [c];
+      else
+        Owner.tOwned.push(c);
+    } else {
+      if (!Owner.owned)
+        Owner.owned = [c];
+      else
+        Owner.owned.push(c);
+    }
+  }
+  if (ExternalSourceConfig && c.fn) {
+    const [track, trigger] = createSignal(void 0, {
+      equals: false
+    });
+    const ordinary = ExternalSourceConfig.factory(c.fn, trigger);
+    onCleanup(() => ordinary.dispose());
+    const triggerInTransition = () => startTransition(trigger).then(() => inTransition.dispose());
+    const inTransition = ExternalSourceConfig.factory(c.fn, triggerInTransition);
+    c.fn = (x) => {
+      track();
+      return Transition && Transition.running ? inTransition.track(x) : ordinary.track(x);
+    };
+  }
+  return c;
+}
+function runTop(node) {
+  const runningTransition = Transition && Transition.running;
+  if ((runningTransition ? node.tState : node.state) === 0)
+    return;
+  if ((runningTransition ? node.tState : node.state) === PENDING)
+    return lookUpstream(node);
+  if (node.suspense && untrack(node.suspense.inFallback))
+    return node.suspense.effects.push(node);
+  const ancestors = [node];
+  while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
+    if (runningTransition && Transition.disposed.has(node))
+      return;
+    if (runningTransition ? node.tState : node.state)
+      ancestors.push(node);
+  }
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    node = ancestors[i];
+    if (runningTransition) {
+      let top = node, prev = ancestors[i + 1];
+      while ((top = top.owner) && top !== prev) {
+        if (Transition.disposed.has(top))
+          return;
+      }
+    }
+    if ((runningTransition ? node.tState : node.state) === STALE) {
+      updateComputation(node);
+    } else if ((runningTransition ? node.tState : node.state) === PENDING) {
+      const updates = Updates;
+      Updates = null;
+      runUpdates(() => lookUpstream(node, ancestors[0]), false);
+      Updates = updates;
+    }
+  }
+}
+function runUpdates(fn, init) {
+  if (Updates)
+    return fn();
+  let wait = false;
+  if (!init)
+    Updates = [];
+  if (Effects)
+    wait = true;
+  else
+    Effects = [];
+  ExecCount++;
+  try {
+    const res = fn();
+    completeUpdates(wait);
+    return res;
+  } catch (err) {
+    if (!wait)
+      Effects = null;
+    Updates = null;
+    handleError(err);
+  }
+}
+function completeUpdates(wait) {
+  if (Updates) {
+    if (Scheduler && Transition && Transition.running)
+      scheduleQueue(Updates);
+    else
+      runQueue(Updates);
+    Updates = null;
+  }
+  if (wait)
+    return;
+  let res;
+  if (Transition) {
+    if (!Transition.promises.size && !Transition.queue.size) {
+      const sources = Transition.sources;
+      const disposed = Transition.disposed;
+      Effects.push.apply(Effects, Transition.effects);
+      res = Transition.resolve;
+      for (const e2 of Effects) {
+        "tState" in e2 && (e2.state = e2.tState);
+        delete e2.tState;
+      }
+      Transition = null;
+      runUpdates(() => {
+        for (const d of disposed)
+          cleanNode(d);
+        for (const v of sources) {
+          v.value = v.tValue;
+          if (v.owned) {
+            for (let i = 0, len = v.owned.length; i < len; i++)
+              cleanNode(v.owned[i]);
+          }
+          if (v.tOwned)
+            v.owned = v.tOwned;
+          delete v.tValue;
+          delete v.tOwned;
+          v.tState = 0;
+        }
+        setTransPending(false);
+      }, false);
+    } else if (Transition.running) {
+      Transition.running = false;
+      Transition.effects.push.apply(Transition.effects, Effects);
+      Effects = null;
+      setTransPending(true);
+      return;
+    }
+  }
+  const e = Effects;
+  Effects = null;
+  if (e.length)
+    runUpdates(() => runEffects(e), false);
+  if (res)
+    res();
+}
+function runQueue(queue) {
+  for (let i = 0; i < queue.length; i++)
+    runTop(queue[i]);
+}
+function scheduleQueue(queue) {
+  for (let i = 0; i < queue.length; i++) {
+    const item = queue[i];
+    const tasks = Transition.queue;
+    if (!tasks.has(item)) {
+      tasks.add(item);
+      Scheduler(() => {
+        tasks.delete(item);
+        runUpdates(() => {
+          Transition.running = true;
+          runTop(item);
+        }, false);
+        Transition && (Transition.running = false);
+      });
+    }
+  }
+}
+function runUserEffects(queue) {
+  let i, userLength = 0;
+  for (i = 0; i < queue.length; i++) {
+    const e = queue[i];
+    if (!e.user)
+      runTop(e);
+    else
+      queue[userLength++] = e;
+  }
+  if (sharedConfig.context) {
+    if (sharedConfig.count) {
+      sharedConfig.effects || (sharedConfig.effects = []);
+      sharedConfig.effects.push(...queue.slice(0, userLength));
+      return;
+    } else if (sharedConfig.effects) {
+      queue = [...sharedConfig.effects, ...queue];
+      userLength += sharedConfig.effects.length;
+      delete sharedConfig.effects;
+    }
+    setHydrateContext();
+  }
+  for (i = 0; i < userLength; i++)
+    runTop(queue[i]);
+}
+function lookUpstream(node, ignore) {
+  const runningTransition = Transition && Transition.running;
+  if (runningTransition)
+    node.tState = 0;
+  else
+    node.state = 0;
+  for (let i = 0; i < node.sources.length; i += 1) {
+    const source = node.sources[i];
+    if (source.sources) {
+      const state = runningTransition ? source.tState : source.state;
+      if (state === STALE) {
+        if (source !== ignore && (!source.updatedAt || source.updatedAt < ExecCount))
+          runTop(source);
+      } else if (state === PENDING)
+        lookUpstream(source, ignore);
+    }
+  }
+}
+function markDownstream(node) {
+  const runningTransition = Transition && Transition.running;
+  for (let i = 0; i < node.observers.length; i += 1) {
+    const o = node.observers[i];
+    if (runningTransition ? !o.tState : !o.state) {
+      if (runningTransition)
+        o.tState = PENDING;
+      else
+        o.state = PENDING;
+      if (o.pure)
+        Updates.push(o);
+      else
+        Effects.push(o);
+      o.observers && markDownstream(o);
+    }
+  }
+}
+function cleanNode(node) {
+  let i;
+  if (node.sources) {
+    while (node.sources.length) {
+      const source = node.sources.pop(), index = node.sourceSlots.pop(), obs = source.observers;
+      if (obs && obs.length) {
+        const n = obs.pop(), s = source.observerSlots.pop();
+        if (index < obs.length) {
+          n.sourceSlots[s] = index;
+          obs[index] = n;
+          source.observerSlots[index] = s;
+        }
+      }
+    }
+  }
+  if (Transition && Transition.running && node.pure) {
+    if (node.tOwned) {
+      for (i = node.tOwned.length - 1; i >= 0; i--)
+        cleanNode(node.tOwned[i]);
+      delete node.tOwned;
+    }
+    reset(node, true);
+  } else if (node.owned) {
+    for (i = node.owned.length - 1; i >= 0; i--)
+      cleanNode(node.owned[i]);
+    node.owned = null;
+  }
+  if (node.cleanups) {
+    for (i = node.cleanups.length - 1; i >= 0; i--)
+      node.cleanups[i]();
+    node.cleanups = null;
+  }
+  if (Transition && Transition.running)
+    node.tState = 0;
+  else
+    node.state = 0;
+}
+function reset(node, top) {
+  if (!top) {
+    node.tState = 0;
+    Transition.disposed.add(node);
+  }
+  if (node.owned) {
+    for (let i = 0; i < node.owned.length; i++)
+      reset(node.owned[i]);
+  }
+}
+function castError(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(typeof err === "string" ? err : "Unknown error", {
+    cause: err
+  });
+}
+function runErrors(err, fns, owner) {
+  try {
+    for (const f of fns)
+      f(err);
+  } catch (e) {
+    handleError(e, owner && owner.owner || null);
+  }
+}
+function handleError(err, owner = Owner) {
+  const fns = ERROR && owner && owner.context && owner.context[ERROR];
+  const error = castError(err);
+  if (!fns)
+    throw error;
+  if (Effects)
+    Effects.push({
+      fn() {
+        runErrors(error, fns, owner);
+      },
+      state: STALE
+    });
+  else
+    runErrors(error, fns, owner);
+}
+function resolveChildren(children2) {
+  if (typeof children2 === "function" && !children2.length)
+    return resolveChildren(children2());
+  if (Array.isArray(children2)) {
+    const results = [];
+    for (let i = 0; i < children2.length; i++) {
+      const result = resolveChildren(children2[i]);
+      Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
+    }
+    return results;
+  }
+  return children2;
+}
+function createProvider(id, options) {
+  return function provider(props) {
+    let res;
+    createRenderEffect(
+      () => res = untrack(() => {
+        Owner.context = {
+          ...Owner.context,
+          [id]: props.value
+        };
+        return children(() => props.children);
+      }),
+      void 0
+    );
+    return res;
+  };
+}
+var FALLBACK = Symbol("fallback");
+var SuspenseListContext = createContext();
+
+// src/WalletProvider.tsx
+var WalletContext = createContext();
+var WalletProvider = (props) => {
+  const store = () => props.manager;
+  onMount(async () => {
+    try {
+      await props.manager.resumeSessions();
+    } catch (error) {
+      console.error("Error resuming sessions:", error);
+    }
+  });
+  return <WalletContext.Provider value={store}>{props.children}</WalletContext.Provider>;
+};
+var useWalletManager = () => {
+  const manager = useContext(WalletContext);
+  if (!manager) {
+    throw new Error("useWalletManager must be used within a WalletProvider");
+  }
+  return manager();
+};
+
+// ../../node_modules/.pnpm/solid-js@1.8.16/node_modules/solid-js/store/dist/store.js
+var $RAW = Symbol("store-raw");
+var $NODE = Symbol("store-node");
+var $HAS = Symbol("store-has");
+var $SELF = Symbol("store-self");
+function wrap$1(value) {
+  let p = value[$PROXY];
+  if (!p) {
+    Object.defineProperty(value, $PROXY, {
+      value: p = new Proxy(value, proxyTraps$1)
+    });
+    if (!Array.isArray(value)) {
+      const keys = Object.keys(value), desc = Object.getOwnPropertyDescriptors(value);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        const prop = keys[i];
+        if (desc[prop].get) {
+          Object.defineProperty(value, prop, {
+            enumerable: desc[prop].enumerable,
+            get: desc[prop].get.bind(p)
+          });
+        }
+      }
+    }
+  }
+  return p;
+}
+function isWrappable(obj) {
+  let proto;
+  return obj != null && typeof obj === "object" && (obj[$PROXY] || !(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype || Array.isArray(obj));
+}
+function unwrap(item, set = /* @__PURE__ */ new Set()) {
+  let result, unwrapped, v, prop;
+  if (result = item != null && item[$RAW])
+    return result;
+  if (!isWrappable(item) || set.has(item))
+    return item;
+  if (Array.isArray(item)) {
+    if (Object.isFrozen(item))
+      item = item.slice(0);
+    else
+      set.add(item);
+    for (let i = 0, l = item.length; i < l; i++) {
+      v = item[i];
+      if ((unwrapped = unwrap(v, set)) !== v)
+        item[i] = unwrapped;
+    }
+  } else {
+    if (Object.isFrozen(item))
+      item = Object.assign({}, item);
+    else
+      set.add(item);
+    const keys = Object.keys(item), desc = Object.getOwnPropertyDescriptors(item);
+    for (let i = 0, l = keys.length; i < l; i++) {
+      prop = keys[i];
+      if (desc[prop].get)
+        continue;
+      v = item[prop];
+      if ((unwrapped = unwrap(v, set)) !== v)
+        item[prop] = unwrapped;
+    }
+  }
+  return item;
+}
+function getNodes(target, symbol) {
+  let nodes = target[symbol];
+  if (!nodes)
+    Object.defineProperty(target, symbol, {
+      value: nodes = /* @__PURE__ */ Object.create(null)
+    });
+  return nodes;
+}
+function getNode(nodes, property, value) {
+  if (nodes[property])
+    return nodes[property];
+  const [s, set] = createSignal(value, {
+    equals: false,
+    internal: true
+  });
+  s.$ = set;
+  return nodes[property] = s;
+}
+function proxyDescriptor$1(target, property) {
+  const desc = Reflect.getOwnPropertyDescriptor(target, property);
+  if (!desc || desc.get || !desc.configurable || property === $PROXY || property === $NODE)
+    return desc;
+  delete desc.value;
+  delete desc.writable;
+  desc.get = () => target[$PROXY][property];
+  return desc;
+}
+function trackSelf(target) {
+  getListener() && getNode(getNodes(target, $NODE), $SELF)();
+}
+function ownKeys(target) {
+  trackSelf(target);
+  return Reflect.ownKeys(target);
+}
+var proxyTraps$1 = {
+  get(target, property, receiver) {
+    if (property === $RAW)
+      return target;
+    if (property === $PROXY)
+      return receiver;
+    if (property === $TRACK) {
+      trackSelf(target);
+      return receiver;
+    }
+    const nodes = getNodes(target, $NODE);
+    const tracked = nodes[property];
+    let value = tracked ? tracked() : target[property];
+    if (property === $NODE || property === $HAS || property === "__proto__")
+      return value;
+    if (!tracked) {
+      const desc = Object.getOwnPropertyDescriptor(target, property);
+      if (getListener() && (typeof value !== "function" || target.hasOwnProperty(property)) && !(desc && desc.get))
+        value = getNode(nodes, property, value)();
+    }
+    return isWrappable(value) ? wrap$1(value) : value;
+  },
+  has(target, property) {
+    if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === $HAS || property === "__proto__")
+      return true;
+    getListener() && getNode(getNodes(target, $HAS), property)();
+    return property in target;
+  },
+  set() {
+    return true;
+  },
+  deleteProperty() {
+    return true;
+  },
+  ownKeys,
+  getOwnPropertyDescriptor: proxyDescriptor$1
+};
+function setProperty(state, property, value, deleting = false) {
+  if (!deleting && state[property] === value)
+    return;
+  const prev = state[property], len = state.length;
+  if (value === void 0) {
+    delete state[property];
+    if (state[$HAS] && state[$HAS][property] && prev !== void 0)
+      state[$HAS][property].$();
+  } else {
+    state[property] = value;
+    if (state[$HAS] && state[$HAS][property] && prev === void 0)
+      state[$HAS][property].$();
+  }
+  let nodes = getNodes(state, $NODE), node;
+  if (node = getNode(nodes, property, prev))
+    node.$(() => value);
+  if (Array.isArray(state) && state.length !== len) {
+    for (let i = state.length; i < len; i++)
+      (node = nodes[i]) && node.$();
+    (node = getNode(nodes, "length", len)) && node.$(state.length);
+  }
+  (node = nodes[$SELF]) && node.$();
+}
+function mergeStoreNode(state, value) {
+  const keys = Object.keys(value);
+  for (let i = 0; i < keys.length; i += 1) {
+    const key = keys[i];
+    setProperty(state, key, value[key]);
+  }
+}
+function updateArray(current, next) {
+  if (typeof next === "function")
+    next = next(current);
+  next = unwrap(next);
+  if (Array.isArray(next)) {
+    if (current === next)
+      return;
+    let i = 0, len = next.length;
+    for (; i < len; i++) {
+      const value = next[i];
+      if (current[i] !== value)
+        setProperty(current, i, value);
+    }
+    setProperty(current, "length", len);
+  } else
+    mergeStoreNode(current, next);
+}
+function updatePath(current, path, traversed = []) {
+  let part, prev = current;
+  if (path.length > 1) {
+    part = path.shift();
+    const partType = typeof part, isArray = Array.isArray(current);
+    if (Array.isArray(part)) {
+      for (let i = 0; i < part.length; i++) {
+        updatePath(current, [part[i]].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "function") {
+      for (let i = 0; i < current.length; i++) {
+        if (part(current[i], i))
+          updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (isArray && partType === "object") {
+      const { from = 0, to = current.length - 1, by = 1 } = part;
+      for (let i = from; i <= to; i += by) {
+        updatePath(current, [i].concat(path), traversed);
+      }
+      return;
+    } else if (path.length > 1) {
+      updatePath(current[part], path, [part].concat(traversed));
+      return;
+    }
+    prev = current[part];
+    traversed = [part].concat(traversed);
+  }
+  let value = path[0];
+  if (typeof value === "function") {
+    value = value(prev, traversed);
+    if (value === prev)
+      return;
+  }
+  if (part === void 0 && value == void 0)
+    return;
+  value = unwrap(value);
+  if (part === void 0 || isWrappable(prev) && isWrappable(value) && !Array.isArray(value)) {
+    mergeStoreNode(prev, value);
+  } else
+    setProperty(current, part, value);
+}
+function createStore(...[store, options]) {
+  const unwrappedStore = unwrap(store || {});
+  const isArray = Array.isArray(unwrappedStore);
+  const wrappedStore = wrap$1(unwrappedStore);
+  function setStore(...args) {
+    batch(() => {
+      isArray && args.length === 1 ? updateArray(unwrappedStore, args[0]) : updatePath(unwrappedStore, args);
+    });
+  }
+  return [wrappedStore, setStore];
+}
+var $ROOT = Symbol("store-root");
+function applyState(target, parent, property, merge, key) {
+  const previous = parent[property];
+  if (target === previous)
+    return;
+  const isArray = Array.isArray(target);
+  if (property !== $ROOT && (!isWrappable(target) || !isWrappable(previous) || isArray !== Array.isArray(previous) || key && target[key] !== previous[key])) {
+    setProperty(parent, property, target);
+    return;
+  }
+  if (isArray) {
+    if (target.length && previous.length && (!merge || key && target[0] && target[0][key] != null)) {
+      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
+      for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start] && target[start] && previous[start][key] === target[start][key]); start++) {
+        applyState(target[start], previous, start, merge, key);
+      }
+      const temp = new Array(target.length), newIndices = /* @__PURE__ */ new Map();
+      for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[start] && target[start] && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
+        temp[newEnd] = previous[end];
+      }
+      if (start > newEnd || start > end) {
+        for (j = start; j <= newEnd; j++)
+          setProperty(previous, j, target[j]);
+        for (; j < target.length; j++) {
+          setProperty(previous, j, temp[j]);
+          applyState(target[j], previous, j, merge, key);
+        }
+        if (previous.length > target.length)
+          setProperty(previous, "length", target.length);
+        return;
+      }
+      newIndicesNext = new Array(newEnd + 1);
+      for (j = newEnd; j >= start; j--) {
+        item = target[j];
+        keyVal = key && item ? item[key] : item;
+        i = newIndices.get(keyVal);
+        newIndicesNext[j] = i === void 0 ? -1 : i;
+        newIndices.set(keyVal, j);
+      }
+      for (i = start; i <= end; i++) {
+        item = previous[i];
+        keyVal = key && item ? item[key] : item;
+        j = newIndices.get(keyVal);
+        if (j !== void 0 && j !== -1) {
+          temp[j] = previous[i];
+          j = newIndicesNext[j];
+          newIndices.set(keyVal, j);
+        }
+      }
+      for (j = start; j < target.length; j++) {
+        if (j in temp) {
+          setProperty(previous, j, temp[j]);
+          applyState(target[j], previous, j, merge, key);
+        } else
+          setProperty(previous, j, target[j]);
+      }
+    } else {
+      for (let i = 0, len = target.length; i < len; i++) {
+        applyState(target[i], previous, i, merge, key);
+      }
+    }
+    if (previous.length > target.length)
+      setProperty(previous, "length", target.length);
+    return;
+  }
+  const targetKeys = Object.keys(target);
+  for (let i = 0, len = targetKeys.length; i < len; i++) {
+    applyState(target[targetKeys[i]], previous, targetKeys[i], merge, key);
+  }
+  const previousKeys = Object.keys(previous);
+  for (let i = 0, len = previousKeys.length; i < len; i++) {
+    if (target[previousKeys[i]] === void 0)
+      setProperty(previous, previousKeys[i], void 0);
+  }
+}
+function reconcile(value, options = {}) {
+  const { merge, key = "id" } = options, v = unwrap(value);
+  return (state) => {
+    if (!isWrappable(state) || !isWrappable(v))
+      return v;
+    const res = applyState(
+      v,
+      {
+        [$ROOT]: state
+      },
+      $ROOT,
+      merge,
+      key
+    );
+    return res === void 0 ? state : res;
+  };
+}
+
+// ../../node_modules/.pnpm/@tanstack+solid-store@0.3.1_solid-js@1.8.16/node_modules/@tanstack/solid-store/dist/esm/index.js
+function useStore(store, selector = (d) => d) {
+  const [slice, setSlice] = createStore({
+    value: selector(store.state)
+  });
+  const unsub = store.subscribe(() => {
+    const newValue = selector(store.state);
+    setSlice("value", reconcile(newValue));
+  });
+  onCleanup(() => {
+    unsub();
+  });
+  return () => slice.value;
+}
+
+// src/useWallet.ts
+function useWallet() {
+  const manager = createMemo(() => useWalletManager());
+  const walletStore = useStore(manager().store, (state) => {
+    return state.wallets;
+  });
+  const walletState = (walletId) => walletStore()[walletId] || null;
+  const activeWalletId = useStore(manager().store, (state) => {
+    return state.activeWallet;
+  });
+  const activeWallet = () => manager().getWallet(activeWalletId()) || null;
+  const activeWalletState = () => walletState(activeWalletId());
+  const activeWalletAccounts = () => activeWalletState()?.accounts ?? null;
+  const activeWalletAddresses = () => activeWalletAccounts()?.map((account) => account.address) ?? null;
+  const activeAccount = () => activeWalletState()?.activeAccount ?? null;
+  const activeAddress = () => activeAccount()?.address ?? null;
+  const isWalletActive = (walletId) => walletId === activeWalletId();
+  const isWalletConnected = (walletId) => !!walletState(walletId)?.accounts.length || false;
+  const activeNetworkState = createMemo(() => {
+    return useStore(manager().store, (state) => state.activeNetwork);
+  });
+  const activeNetwork = () => activeNetworkState()();
+  const setActiveNetwork2 = (network) => manager().setActiveNetwork(network);
+  const algodClient = createMemo(() => manager().algodClient);
+  const signTransactions = (txnGroup, indexesToSign, returnGroup) => {
+    if (!activeWallet) {
+      throw new Error("No active wallet");
+    }
+    return activeWallet()?.signTransactions(txnGroup, indexesToSign, returnGroup);
+  };
+  const transactionSigner = (txnGroup, indexesToSign) => {
+    if (!activeWallet) {
+      throw new Error("No active wallet");
+    }
+    return activeWallet()?.transactionSigner(txnGroup, indexesToSign);
+  };
+  return {
+    activeWalletId,
+    walletStore,
+    algodClient,
+    activeNetwork,
+    activeWallet,
+    activeWalletAccounts,
+    activeWalletAddresses,
+    activeWalletState,
+    activeAccount,
+    activeAddress,
+    isWalletActive,
+    isWalletConnected,
+    setActiveNetwork: setActiveNetwork2,
+    signTransactions,
+    transactionSigner,
+    wallets: manager().wallets
+  };
+}
+export {
+  BaseWallet,
+  DeflyWallet,
+  ExodusWallet,
+  KmdWallet,
+  MnemonicWallet,
+  NetworkId,
+  PeraWallet,
+  StorageAdapter,
+  WalletConnect,
+  WalletId,
+  WalletManager,
+  WalletProvider,
+  defaultState,
+  useWallet
+};