@solana/kit-plugin-wallet 0.0.0 → 0.12.0

package/dist/index.browser.mjs

@@ -0,0 +1,533 @@
+import { withCleanup, extendClient, SolanaError, SOLANA_ERROR__WALLET__NO_SIGNER_CONNECTED, SOLANA_ERROR__WALLET__SIGNER_NOT_AVAILABLE, SOLANA_ERROR__WALLET__NOT_CONNECTED, SOLANA_ERROR__WALLET__ACCOUNT_NOT_AVAILABLE } from '@solana/kit';
+import { createSignerFromWalletAccount } from '@solana/wallet-account-signer';
+import { SolanaSignMessage, SolanaSignIn } from '@solana/wallet-standard-features';
+import { getWallets } from '@wallet-standard/app';
+import { StandardConnect, StandardDisconnect, StandardEvents } from '@wallet-standard/features';
+import { getWalletFeature, getWalletAccountFeature } from '@wallet-standard/ui-features';
+import { getOrCreateUiWalletForStandardWallet, getWalletForHandle } from '@wallet-standard/ui-registry';
+
+// src/wallet.ts
+function createWalletStore(config) {
+  let state = {
+    account: null,
+    connectedWallet: null,
+    signer: null,
+    status: "pending",
+    wallets: []
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  const signerListeners = /* @__PURE__ */ new Set();
+  let walletEventsCleanup = null;
+  let reconnectCleanup = null;
+  let userHasSelected = false;
+  let connectGeneration = 0;
+  let disposed = false;
+  let disconnectingWalletName = null;
+  function resolveDefaultStorage() {
+    try {
+      return localStorage;
+    } catch {
+      return null;
+    }
+  }
+  const storage = config.storage === null ? null : config.storage ?? resolveDefaultStorage();
+  const storageKey = config.storageKey ?? "kit-wallet";
+  function deriveSnapshot(s) {
+    return Object.freeze({
+      connected: s.connectedWallet && s.account ? Object.freeze({
+        account: s.account,
+        signer: s.signer,
+        wallet: s.connectedWallet
+      }) : null,
+      status: s.status,
+      wallets: s.wallets
+    });
+  }
+  let snapshot = deriveSnapshot(state);
+  function observableSigner(s) {
+    return s.connectedWallet && s.account ? s.signer : void 0;
+  }
+  function updateState(updates) {
+    const prev = state;
+    state = { ...state, ...updates };
+    const signerChanged = observableSigner(state) !== observableSigner(prev);
+    if (state.connectedWallet !== prev.connectedWallet || state.account !== prev.account || state.status !== prev.status || state.signer !== prev.signer || state.wallets !== prev.wallets) {
+      snapshot = deriveSnapshot(state);
+      listeners.forEach((l) => l());
+    }
+    if (signerChanged) {
+      signerListeners.forEach((l) => l());
+    }
+  }
+  function tryCreateSigner(account) {
+    try {
+      return createSignerFromWalletAccount(account, config.chain);
+    } catch {
+      return null;
+    }
+  }
+  const registry = getWallets();
+  function filterWallet(uiWallet) {
+    const supportsChain = uiWallet.chains.includes(config.chain);
+    const supportsConnect = uiWallet.features.includes(StandardConnect);
+    if (!supportsChain || !supportsConnect) return false;
+    return config.filter ? config.filter(uiWallet) : true;
+  }
+  function buildWalletList() {
+    return Object.freeze(registry.get().map(getOrCreateUiWalletForStandardWallet).filter(filterWallet));
+  }
+  function reconcileWalletList() {
+    const next = buildWalletList();
+    const prev = state.wallets;
+    if (next.length === prev.length && next.every((w, i) => w === prev[i])) {
+      return prev;
+    }
+    return next;
+  }
+  function isWalletStillAvailable(uiWallet) {
+    return buildWalletList().some((w) => w.name === uiWallet.name);
+  }
+  updateState({ wallets: buildWalletList() });
+  const unsubRegister = registry.on("register", () => {
+    updateState({ wallets: reconcileWalletList() });
+  });
+  const unsubUnregister = registry.on("unregister", () => {
+    const newWallets = reconcileWalletList();
+    const updates = { wallets: newWallets };
+    if (state.connectedWallet && !newWallets.some((w) => w.name === state.connectedWallet.name)) {
+      walletEventsCleanup?.();
+      walletEventsCleanup = null;
+      updates.connectedWallet = null;
+      updates.account = null;
+      updates.signer = null;
+      updates.status = "disconnected";
+      clearPersistedAccount();
+    }
+    updateState(updates);
+  });
+  function cancelReconnect() {
+    reconnectCleanup?.();
+    reconnectCleanup = null;
+  }
+  function resubscribeToWalletEvents(uiWallet) {
+    walletEventsCleanup?.();
+    walletEventsCleanup = subscribeToWalletEvents(uiWallet);
+  }
+  function setConnected(account, wallet, options) {
+    if (disposed) return;
+    const signer = tryCreateSigner(account);
+    resubscribeToWalletEvents(wallet);
+    disconnectingWalletName = null;
+    updateState({ account, connectedWallet: wallet, signer, status: "connected" });
+    if (options?.persist !== false) {
+      persistAccount(account, wallet);
+    }
+  }
+  function refreshUiWallet(staleUiWallet) {
+    const rawWallet = getWalletForHandle(staleUiWallet);
+    return getOrCreateUiWalletForStandardWallet(rawWallet);
+  }
+  function subscribeToWalletEvents(uiWallet) {
+    if (!uiWallet.features.includes(StandardEvents)) {
+      return () => {
+      };
+    }
+    const eventsFeature = getWalletFeature(
+      uiWallet,
+      StandardEvents
+    );
+    return eventsFeature.on("change", () => {
+      const refreshed = refreshUiWallet(uiWallet);
+      if (!filterWallet(refreshed)) {
+        disconnectLocally();
+        return;
+      }
+      const result = reconcileActiveAccount(refreshed);
+      if (result === null) {
+        disconnectLocally();
+        return;
+      }
+      updateState({ connectedWallet: refreshed, wallets: reconcileWalletList(), ...result });
+      if (result.account) {
+        persistAccount(result.account, refreshed);
+      }
+    });
+  }
+  function reconcileActiveAccount(wallet) {
+    const newAccounts = wallet.accounts;
+    if (newAccounts.length === 0) return null;
+    const currentAddress = state.account?.address;
+    const stillPresent = currentAddress ? newAccounts.find((a) => a.address === currentAddress) : null;
+    const activeAccount = stillPresent ?? newAccounts[0];
+    if (activeAccount === state.account) return {};
+    return { account: activeAccount, signer: tryCreateSigner(activeAccount) };
+  }
+  async function connect(uiWallet, options) {
+    options?.abortSignal?.throwIfAborted();
+    const connectFeature = getWalletFeature(
+      uiWallet,
+      StandardConnect
+    );
+    userHasSelected = true;
+    cancelReconnect();
+    const generation = ++connectGeneration;
+    updateState({ status: "connecting" });
+    try {
+      const existingAccounts = [...uiWallet.accounts];
+      await connectFeature.connect();
+      if (generation !== connectGeneration) {
+        throw new DOMException("Wallet connect was superseded by a newer connect or sign-in", "AbortError");
+      }
+      if (!isWalletStillAvailable(uiWallet)) {
+        throw new SolanaError(SOLANA_ERROR__WALLET__NOT_CONNECTED, { operation: "connect" });
+      }
+      const refreshedWallet = refreshUiWallet(uiWallet);
+      const allAccounts = refreshedWallet.accounts;
+      if (allAccounts.length === 0) {
+        throw new SolanaError(SOLANA_ERROR__WALLET__NOT_CONNECTED, { operation: "connect" });
+      }
+      const newAccount = allAccounts.find((a) => !existingAccounts.some((e) => e.address === a.address));
+      const activeAccount = newAccount ?? allAccounts[0];
+      setConnected(activeAccount, refreshedWallet);
+      return allAccounts;
+    } catch (error) {
+      if (generation === connectGeneration) {
+        revertToPreviousConnectionOrDisconnect();
+      }
+      throw error;
+    }
+  }
+  async function disconnect(options) {
+    options?.abortSignal?.throwIfAborted();
+    if (!state.connectedWallet) {
+      userHasSelected = true;
+      cancelReconnect();
+      connectGeneration++;
+      updateState({ status: "disconnected" });
+      clearPersistedAccount();
+      return;
+    }
+    const currentWallet = state.connectedWallet;
+    const generation = ++connectGeneration;
+    disconnectingWalletName = currentWallet.name;
+    updateState({ status: "disconnecting" });
+    try {
+      if (currentWallet.features.includes(StandardDisconnect)) {
+        const disconnectFeature = getWalletFeature(
+          currentWallet,
+          StandardDisconnect
+        );
+        await disconnectFeature.disconnect();
+      }
+    } finally {
+      if (generation === connectGeneration) {
+        disconnectLocally();
+      }
+    }
+  }
+  function disconnectLocally() {
+    walletEventsCleanup?.();
+    walletEventsCleanup = null;
+    disconnectingWalletName = null;
+    updateState({
+      account: null,
+      connectedWallet: null,
+      signer: null,
+      status: "disconnected",
+      // Reconcile the list too: when this runs from the change handler
+      // because the connected wallet dropped the configured chain or
+      // failed the filter, that wallet must leave `wallets` immediately
+      // rather than linger until an unrelated register/unregister event.
+      // `reconcileWalletList` returns the existing reference when the
+      // visible set is unchanged (the common case for a plain disconnect),
+      // so this stays churn-free.
+      wallets: reconcileWalletList()
+    });
+    clearPersistedAccount();
+  }
+  function revertToPreviousConnectionOrDisconnect() {
+    if (state.connectedWallet && state.account && state.connectedWallet.name !== disconnectingWalletName) {
+      updateState({ status: "connected" });
+    } else {
+      disconnectLocally();
+    }
+  }
+  function selectAccount(account) {
+    if (!state.connectedWallet) {
+      throw new SolanaError(SOLANA_ERROR__WALLET__NOT_CONNECTED, { operation: "selectAccount" });
+    }
+    if (state.connectedWallet.name === disconnectingWalletName) {
+      throw new SolanaError(SOLANA_ERROR__WALLET__NOT_CONNECTED, { operation: "selectAccount" });
+    }
+    const refreshed = refreshUiWallet(state.connectedWallet);
+    const selectedAccount = refreshed.accounts.find((a) => a.address === account.address);
+    if (!selectedAccount) {
+      throw new SolanaError(SOLANA_ERROR__WALLET__ACCOUNT_NOT_AVAILABLE, {
+        account: account.address,
+        operation: "selectAccount"
+      });
+    }
+    userHasSelected = true;
+    ++connectGeneration;
+    if (selectedAccount === state.account && refreshed === state.connectedWallet) {
+      updateState({ status: "connected" });
+      return;
+    }
+    const signer = tryCreateSigner(selectedAccount);
+    updateState({ account: selectedAccount, connectedWallet: refreshed, signer, status: "connected" });
+    persistAccount(selectedAccount, refreshed);
+  }
+  async function signMessage(message, options) {
+    options?.abortSignal?.throwIfAborted();
+    const { connectedWallet, account } = state;
+    if (!connectedWallet || !account) {
+      throw new SolanaError(SOLANA_ERROR__WALLET__NOT_CONNECTED, { operation: "signMessage" });
+    }
+    const signMessageFeature = getWalletAccountFeature(
+      account,
+      SolanaSignMessage
+    );
+    const [output] = await signMessageFeature.signMessage({ account, message });
+    return output.signature;
+  }
+  async function signIn(uiWallet, input, options) {
+    options?.abortSignal?.throwIfAborted();
+    const signInFeature = getWalletFeature(uiWallet, SolanaSignIn);
+    userHasSelected = true;
+    cancelReconnect();
+    const generation = ++connectGeneration;
+    updateState({ status: "connecting" });
+    try {
+      const [result] = await signInFeature.signIn(input);
+      if (generation !== connectGeneration) {
+        throw new DOMException("Wallet sign-in was superseded by a newer connect or sign-in", "AbortError");
+      }
+      if (!isWalletStillAvailable(uiWallet)) {
+        throw new SolanaError(SOLANA_ERROR__WALLET__NOT_CONNECTED, { operation: "signIn" });
+      }
+      const refreshedWallet = refreshUiWallet(uiWallet);
+      const activeAccount = refreshedWallet.accounts.find((a) => a.address === result.account.address);
+      if (!activeAccount) {
+        throw new SolanaError(SOLANA_ERROR__WALLET__NOT_CONNECTED, { operation: "signIn" });
+      }
+      setConnected(activeAccount, refreshedWallet);
+      return result;
+    } catch (error) {
+      if (generation === connectGeneration) {
+        revertToPreviousConnectionOrDisconnect();
+      }
+      throw error;
+    }
+  }
+  function ignoreStorageFailure(operation) {
+    void (async () => {
+      try {
+        await operation();
+      } catch {
+      }
+    })();
+  }
+  function persistAccount(account, wallet) {
+    if (!storage) return;
+    ignoreStorageFailure(() => storage.setItem(storageKey, `${wallet.name}:${account.address}`));
+  }
+  function clearPersistedAccount() {
+    if (!storage) return;
+    ignoreStorageFailure(() => storage.removeItem(storageKey));
+  }
+  if (config.autoConnect !== false && storage) {
+    const generation = connectGeneration;
+    (async () => {
+      const savedKey = await storage.getItem(storageKey);
+      if (userHasSelected || disposed) return;
+      if (!savedKey) {
+        updateState({ status: "disconnected" });
+        return;
+      }
+      const separatorIndex = savedKey.lastIndexOf(":");
+      if (separatorIndex === -1) {
+        updateState({ status: "disconnected" });
+        clearPersistedAccount();
+        return;
+      }
+      const walletName = savedKey.slice(0, separatorIndex);
+      const savedAddress = savedKey.slice(separatorIndex + 1);
+      const existing = state.wallets.find((w) => w.name === walletName);
+      if (existing) {
+        await attemptSilentReconnect(savedAddress, existing);
+      } else if (registry.get().some((w) => {
+        const ui = getOrCreateUiWalletForStandardWallet(w);
+        return ui.name === walletName;
+      })) {
+        updateState({ status: "disconnected" });
+        clearPersistedAccount();
+      } else {
+        updateState({ status: "reconnecting" });
+        const statusTimeout = setTimeout(() => {
+          if (!userHasSelected && state.status === "reconnecting") {
+            updateState({ status: "disconnected" });
+          }
+        }, 3e3);
+        const unsubRegisterForReconnect = registry.on("register", () => {
+          const generation2 = connectGeneration;
+          void (async () => {
+            if (userHasSelected) {
+              clearTimeout(statusTimeout);
+              unsubRegisterForReconnect();
+              reconnectCleanup = null;
+              return;
+            }
+            const found = buildWalletList().find((w) => w.name === walletName);
+            if (found) {
+              clearTimeout(statusTimeout);
+              unsubRegisterForReconnect();
+              reconnectCleanup = null;
+              await attemptSilentReconnect(savedAddress, found);
+            } else if (registry.get().some((w) => {
+              const ui = getOrCreateUiWalletForStandardWallet(w);
+              return ui.name === walletName;
+            })) {
+              clearTimeout(statusTimeout);
+              unsubRegisterForReconnect();
+              reconnectCleanup = null;
+              updateState({ status: "disconnected" });
+              clearPersistedAccount();
+            }
+          })().catch(() => {
+            if (generation2 === connectGeneration && !userHasSelected) {
+              updateState({ status: "disconnected" });
+            }
+          });
+        });
+        reconnectCleanup = () => {
+          clearTimeout(statusTimeout);
+          unsubRegisterForReconnect();
+        };
+      }
+    })().catch(() => {
+      if (generation === connectGeneration && !userHasSelected) {
+        updateState({ status: "disconnected" });
+      }
+    });
+  } else {
+    updateState({ status: "disconnected" });
+  }
+  async function attemptSilentReconnect(savedAddress, uiWallet) {
+    const generation = ++connectGeneration;
+    updateState({ status: "reconnecting" });
+    try {
+      const connectFeature = getWalletFeature(
+        uiWallet,
+        StandardConnect
+      );
+      await connectFeature.connect({ silent: true });
+      if (generation !== connectGeneration) return;
+      if (!isWalletStillAvailable(uiWallet)) {
+        updateState({ status: "disconnected" });
+        clearPersistedAccount();
+        return;
+      }
+      const refreshedWallet = refreshUiWallet(uiWallet);
+      const allAccounts = refreshedWallet.accounts;
+      if (allAccounts.length === 0) {
+        updateState({ status: "disconnected" });
+        clearPersistedAccount();
+        return;
+      }
+      const activeAccount = allAccounts.find((a) => a.address === savedAddress) ?? allAccounts[0];
+      setConnected(activeAccount, refreshedWallet, {
+        persist: activeAccount.address !== savedAddress
+      });
+    } catch {
+      if (generation === connectGeneration) {
+        updateState({ status: "disconnected" });
+        clearPersistedAccount();
+      }
+    }
+  }
+  return {
+    connect,
+    disconnect,
+    getState: () => snapshot,
+    selectAccount,
+    signIn,
+    signMessage,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    subscribeSigner: (listener) => {
+      signerListeners.add(listener);
+      return () => {
+        signerListeners.delete(listener);
+      };
+    },
+    [Symbol.dispose]: () => {
+      disposed = true;
+      connectGeneration++;
+      unsubRegister();
+      unsubUnregister();
+      walletEventsCleanup?.();
+      walletEventsCleanup = null;
+      cancelReconnect();
+      listeners.clear();
+      signerListeners.clear();
+    }
+  };
+}
+
+// src/wallet.ts
+function defineSignerGetter(additions, property, store) {
+  Object.defineProperty(additions, property, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const state = store.getState();
+      if (!state.connected) {
+        throw new SolanaError(SOLANA_ERROR__WALLET__NO_SIGNER_CONNECTED, { status: state.status });
+      }
+      if (!state.connected.signer) {
+        throw new SolanaError(SOLANA_ERROR__WALLET__SIGNER_NOT_AVAILABLE);
+      }
+      return state.connected.signer;
+    }
+  });
+}
+var SUBSCRIBE_PROPERTY = {
+  identity: "subscribeToIdentity",
+  payer: "subscribeToPayer"
+};
+function createPlugin(config, signerProperties) {
+  return (client) => {
+    if ("wallet" in client) {
+      throw new Error(
+        "Only one wallet plugin can be used per client. Use walletSigner, walletPayer, walletIdentity, or walletWithoutSigner \u2014 not multiple."
+      );
+    }
+    const store = createWalletStore(config);
+    const additions = { wallet: store };
+    for (const prop of signerProperties) {
+      defineSignerGetter(additions, prop, store);
+      additions[SUBSCRIBE_PROPERTY[prop]] = store.subscribeSigner;
+    }
+    return withCleanup(extendClient(client, additions), () => store[Symbol.dispose]());
+  };
+}
+function walletSigner(config) {
+  return createPlugin(config, ["payer", "identity"]);
+}
+function walletIdentity(config) {
+  return createPlugin(config, ["identity"]);
+}
+function walletPayer(config) {
+  return createPlugin(config, ["payer"]);
+}
+function walletWithoutSigner(config) {
+  return createPlugin(config, []);
+}
+
+export { walletIdentity, walletPayer, walletSigner, walletWithoutSigner };
+//# sourceMappingURL=index.browser.mjs.map
+//# sourceMappingURL=index.browser.mjs.map