@vue-solana/vue 0.4.2 → 0.6.0

package/dist/index.mjs

@@ -1,19 +1,170 @@
 export { u as useBalance } from './shared/vue.DQhHHVu6.mjs';
 export { u as useConnection } from './shared/vue.DlEAL2G8.mjs';
 export { u as useRpc } from './shared/vue.BqDzSepb.mjs';
-export { u as useSignAndSendTransaction } from './shared/vue.BfF-kOvb.mjs';
+export { u as useSignAndSendTransaction } from './shared/vue.RQ9fETnm.mjs';
 import { s as solanaInjectionKey } from './shared/vue.1M_c5FWA.mjs';
 export { t as tryUseSolana, u as useSolana } from './shared/vue.1M_c5FWA.mjs';
-export { u as useTransaction } from './shared/vue.CuhLIeDx.mjs';
+import { w as withTimeout } from './shared/vue.gLqkzJY4.mjs';
+export { u as useTransaction } from './shared/vue.gLqkzJY4.mjs';
+export { g as getConfirmedTransactionStatus, u as useTransactionConfirmation } from './shared/vue.jOsz34kz.mjs';
 export { u as useWallet } from './shared/vue.DYf_CRDv.mjs';
 export { u as useWallets } from './shared/vue.h-uS8MXN.mjs';
-import { isSolanaIosWalletInfo, adaptSolanaIosWallet, handleSolanaIosWalletCallback, getSolanaIosWallets } from '@vue-solana/core/ios-wallet';
-import { subscribeSolanaWallets, getSolanaChain, adaptSolanaStandardWallet, getRegisteredSolanaWallets } from '@vue-solana/core/wallet-standard';
 import { createSolanaContext } from '@vue-solana/core/rpc';
+import { getRegisteredSolanaWallets, getSolanaChain, adaptSolanaStandardWallet, subscribeSolanaWallets } from '@vue-solana/core/wallet-standard';
 import { shallowRef, ref, triggerRef } from 'vue';
+import { handleSolanaIosWalletCallback, getSolanaIosWallets, isSolanaIosWalletInfo, adaptSolanaIosWallet } from '@vue-solana/core/ios-wallet';
 import '@solana/web3-compat';
 import '@vue-solana/core/transaction';
 
+const SELECTED_WALLET_STORAGE_KEY = "vue-solana:selected-wallet";
+function readSelectedWallet() {
+  const storage = getLocalStorage();
+  if (!storage) {
+    return null;
+  }
+  try {
+    const value = storage.getItem(SELECTED_WALLET_STORAGE_KEY);
+    if (!value) {
+      return null;
+    }
+    const wallet = JSON.parse(value);
+    return typeof wallet.name === "string" ? {
+      name: wallet.name,
+      platform: wallet.platform,
+      source: wallet.source
+    } : null;
+  } catch {
+    return null;
+  }
+}
+function writeSelectedWallet(wallet) {
+  const storage = getLocalStorage();
+  if (!storage) {
+    return;
+  }
+  try {
+    if (wallet) {
+      storage.setItem(SELECTED_WALLET_STORAGE_KEY, stringifySelectedWallet(wallet));
+    } else {
+      storage.removeItem(SELECTED_WALLET_STORAGE_KEY);
+    }
+  } catch {
+  }
+}
+function stringifySelectedWallet(wallet) {
+  const value = { name: wallet.name };
+  if (wallet.platform) {
+    value.platform = wallet.platform;
+  }
+  if (wallet.source) {
+    value.source = wallet.source;
+  }
+  return JSON.stringify(value);
+}
+function getLocalStorage() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+
+function createSolanaWalletRegistry(options) {
+  const adaptedWallets = /* @__PURE__ */ new WeakMap();
+  function getAdaptedWallet(walletInfo) {
+    if (isSolanaIosWalletInfo(walletInfo)) {
+      return adaptSolanaIosWallet(walletInfo, {
+        chain: getSolanaChain(options.cluster),
+        cluster: options.cluster,
+        onChange: options.onWalletChange,
+        ...options.iosWallet || {}
+      });
+    }
+    if (!isObject(walletInfo.wallet)) {
+      return adaptSolanaStandardWallet(walletInfo, {
+        chain: getSolanaChain(options.cluster),
+        onChange: options.onWalletChange
+      });
+    }
+    const cachedWallet = adaptedWallets.get(walletInfo.wallet);
+    if (cachedWallet) {
+      return cachedWallet;
+    }
+    const adaptedWallet = adaptSolanaStandardWallet(walletInfo, {
+      chain: getSolanaChain(options.cluster),
+      onChange: options.onWalletChange
+    });
+    const cachedAdapter = {
+      platform: walletInfo.platform,
+      source: walletInfo.source,
+      get publicKey() {
+        return adaptedWallet.publicKey;
+      },
+      get connected() {
+        return adaptedWallet.connected;
+      },
+      get connecting() {
+        return adaptedWallet.connecting;
+      },
+      get disconnecting() {
+        return adaptedWallet.disconnecting;
+      },
+      async connect() {
+        await adaptedWallet.connect();
+        await Promise.all(
+          Array.from(getCachedWallets()).map(
+            (otherWallet) => otherWallet !== cachedAdapter && otherWallet.connected ? otherWallet.disconnect() : void 0
+          )
+        );
+      },
+      disconnect: () => adaptedWallet.disconnect(),
+      signTransaction: adaptedWallet.signTransaction?.bind(adaptedWallet),
+      signAllTransactions: adaptedWallet.signAllTransactions?.bind(adaptedWallet),
+      signAndSendTransaction: adaptedWallet.signAndSendTransaction?.bind(adaptedWallet)
+    };
+    adaptedWallets.set(walletInfo.wallet, cachedAdapter);
+    return cachedAdapter;
+  }
+  function getDiscoveredWallets() {
+    return [
+      ...getRegisteredSolanaWallets(),
+      ...options.iosWallet === false ? [] : getSolanaIosWallets({
+        chains: [getSolanaChain(options.cluster)],
+        cluster: options.cluster,
+        ...options.iosWallet || {}
+      })
+    ];
+  }
+  function handleIosWalletCallback() {
+    try {
+      handleSolanaIosWalletCallback({ clearUrl: true });
+    } catch (cause) {
+      console.error("[Vue Solana] iOS wallet callback failed", cause);
+    }
+  }
+  function* getCachedWallets() {
+    for (const walletInfo of options.getWalletInfos()) {
+      if (isObject(walletInfo.wallet)) {
+        const cachedWallet = adaptedWallets.get(walletInfo.wallet);
+        if (cachedWallet) {
+          yield cachedWallet;
+        }
+      }
+    }
+  }
+  return {
+    getAdaptedWallet,
+    getDiscoveredWallets,
+    handleIosWalletCallback
+  };
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+
 const RPC_CHECK_TIMEOUT_MS = 1e4;
 function createSolanaPlugin(options = {}) {
   return {
@@ -25,9 +176,15 @@ function createSolanaPlugin(options = {}) {
       const status = ref("idle");
       const error = ref(null);
       const latestBlockhash = ref(null);
-      const adaptedWallets = /* @__PURE__ */ new WeakMap();
+      const walletRegistry = createSolanaWalletRegistry({
+        cluster: context.cluster,
+        iosWallet: options.iosWallet,
+        getWalletInfos: () => wallets.value,
+        onWalletChange: () => triggerRef(wallet)
+      });
       let unsubscribeWallets = null;
       let mobileWalletRegistrationPromise = null;
+      let attemptedAutoConnectWallet = null;
       let rpcCheckId = 0;
       async function checkConnection() {
         const checkId = ++rpcCheckId;
@@ -66,17 +223,28 @@ function createSolanaPlugin(options = {}) {
       }
       function refreshWallets() {
         unsubscribeWallets ??= subscribeSolanaWallets(refreshWallets);
-        handleIosWalletCallback();
-        wallets.value = getDiscoveredWallets();
+        walletRegistry.handleIosWalletCallback();
+        wallets.value = walletRegistry.getDiscoveredWallets();
+        let restoredWallet = null;
         if (selectedWallet.value) {
           selectedWallet.value = wallets.value.find((nextWallet) => isSameWallet(nextWallet, selectedWallet.value)) ?? null;
           if (!selectedWallet.value) {
             wallet.value = options.wallet ?? null;
           }
+        } else if (!options.wallet) {
+          const persistedWallet = readSelectedWallet();
+          restoredWallet = persistedWallet ? wallets.value.find((nextWallet) => isSameWallet(nextWallet, persistedWallet)) ?? null : null;
+          if (restoredWallet) {
+            selectedWallet.value = restoredWallet;
+            wallet.value = walletRegistry.getAdaptedWallet(restoredWallet);
+          }
         }
         if (options.mobileWallet !== false) {
           registerMobileWallets();
         }
+        if (restoredWallet) {
+          autoConnectWallet(restoredWallet);
+        }
       }
       function registerMobileWallets() {
         mobileWalletRegistrationPromise ??= import('@vue-solana/core/mobile-wallet').then(({ registerSolanaMobileWallet }) => {
@@ -84,7 +252,7 @@ function createSolanaPlugin(options = {}) {
             chains: [getSolanaChain(context.cluster)],
             ...options.mobileWallet || {}
           });
-          wallets.value = getDiscoveredWallets();
+          refreshWallets();
         }).catch((cause) => {
           console.error("[Vue Solana] Mobile wallet registration failed", cause);
         }).finally(() => {
@@ -93,88 +261,24 @@ function createSolanaPlugin(options = {}) {
       }
       function selectWallet(nextWallet) {
         selectedWallet.value = nextWallet;
-        wallet.value = nextWallet ? getAdaptedWallet(nextWallet) : options.wallet ?? null;
+        wallet.value = nextWallet ? walletRegistry.getAdaptedWallet(nextWallet) : options.wallet ?? null;
+        writeSelectedWallet(nextWallet);
       }
-      function getAdaptedWallet(walletInfo) {
-        if (isSolanaIosWalletInfo(walletInfo)) {
-          return adaptSolanaIosWallet(walletInfo, {
-            chain: getSolanaChain(context.cluster),
-            cluster: context.cluster,
-            onChange: () => triggerRef(wallet),
-            ...options.iosWallet || {}
-          });
+      function autoConnectWallet(walletInfo) {
+        if (!options.autoConnect) {
+          return;
         }
-        if (!isObject(walletInfo.wallet)) {
-          return adaptSolanaStandardWallet(walletInfo, {
-            chain: getSolanaChain(context.cluster),
-            onChange: () => triggerRef(wallet)
-          });
-        }
-        const cachedWallet = adaptedWallets.get(walletInfo.wallet);
-        if (cachedWallet) {
-          return cachedWallet;
+        const activeWallet = wallet.value;
+        const storageValue = stringifySelectedWallet(walletInfo);
+        if (!activeWallet || activeWallet.connected || activeWallet.connecting || attemptedAutoConnectWallet === storageValue) {
+          return;
         }
-        const adaptedWallet = adaptSolanaStandardWallet(walletInfo, {
-          chain: getSolanaChain(context.cluster),
-          onChange: () => triggerRef(wallet)
+        attemptedAutoConnectWallet = storageValue;
+        void activeWallet.connect().catch((cause) => {
+          console.error("[Vue Solana] Wallet auto-connect failed", cause);
+        }).finally(() => {
+          triggerRef(wallet);
         });
-        const cachedAdapter = {
-          platform: walletInfo.platform,
-          source: walletInfo.source,
-          get publicKey() {
-            return adaptedWallet.publicKey;
-          },
-          get connected() {
-            return adaptedWallet.connected;
-          },
-          get connecting() {
-            return adaptedWallet.connecting;
-          },
-          get disconnecting() {
-            return adaptedWallet.disconnecting;
-          },
-          async connect() {
-            await adaptedWallet.connect();
-            await Promise.all(
-              Array.from(getCachedWallets()).map(
-                (otherWallet) => otherWallet !== cachedAdapter && otherWallet.connected ? otherWallet.disconnect() : void 0
-              )
-            );
-          },
-          disconnect: () => adaptedWallet.disconnect(),
-          signTransaction: adaptedWallet.signTransaction?.bind(adaptedWallet),
-          signAllTransactions: adaptedWallet.signAllTransactions?.bind(adaptedWallet),
-          signAndSendTransaction: adaptedWallet.signAndSendTransaction?.bind(adaptedWallet)
-        };
-        adaptedWallets.set(walletInfo.wallet, cachedAdapter);
-        return cachedAdapter;
-      }
-      function getDiscoveredWallets() {
-        return [
-          ...getRegisteredSolanaWallets(),
-          ...options.iosWallet === false ? [] : getSolanaIosWallets({
-            chains: [getSolanaChain(context.cluster)],
-            cluster: context.cluster,
-            ...options.iosWallet || {}
-          })
-        ];
-      }
-      function handleIosWalletCallback() {
-        try {
-          handleSolanaIosWalletCallback({ clearUrl: true });
-        } catch (cause) {
-          console.error("[Vue Solana] iOS wallet callback failed", cause);
-        }
-      }
-      function* getCachedWallets() {
-        for (const walletInfo of wallets.value) {
-          if (isObject(walletInfo.wallet)) {
-            const cachedWallet = adaptedWallets.get(walletInfo.wallet);
-            if (cachedWallet) {
-              yield cachedWallet;
-            }
-          }
-        }
       }
       const vueContext = {
         ...context,
@@ -190,36 +294,26 @@ function createSolanaPlugin(options = {}) {
         setWallet(nextWallet) {
           selectedWallet.value = null;
           wallet.value = nextWallet;
+          writeSelectedWallet(null);
         }
       };
       app.provide(solanaInjectionKey, vueContext);
       if (typeof window !== "undefined") {
         window.setTimeout(() => {
+          try {
+            refreshWallets();
+          } catch (cause) {
+            console.error("[Vue Solana] Wallet refresh failed", cause);
+          }
           void checkConnection();
         }, 0);
       }
     }
   };
 }
-function isObject(value) {
-  return typeof value === "object" && value !== null || typeof value === "function";
-}
 function isSameWallet(wallet, selectedWallet) {
   return wallet.name === selectedWallet?.name && wallet.source === selectedWallet.source && wallet.platform === selectedWallet.platform;
 }
 const VueSolana = createSolanaPlugin;
-function withTimeout(promise, timeoutMs, message) {
-  let timeoutId;
-  const timeout = new Promise((_, reject) => {
-    timeoutId = setTimeout(() => {
-      reject(new Error(message));
-    }, timeoutMs);
-  });
-  return Promise.race([promise, timeout]).finally(() => {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-  });
-}
 
 export { VueSolana, createSolanaPlugin, solanaInjectionKey };

package/dist/shared/vue.DEQJ23UM.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+const transaction = require('@vue-solana/core/transaction');
+const vue = require('vue');
+const useConnection = require('./vue.CwhEmATP.cjs');
+const useWallet = require('./vue.CwPjPFN6.cjs');
+const useTransactionConfirmation = require('./vue.DHVYJk8P.cjs');
+
+const SIGN_AND_SEND_TIMEOUT_MS = 12e4;
+function useSignAndSendTransaction() {
+  const connection = useConnection.useConnection();
+  const { wallet } = useWallet.useWallet();
+  const signature = vue.ref(null);
+  const confirmation = vue.ref(null);
+  const status = vue.ref("idle");
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  let executionId = 0;
+  async function execute(transaction$1, options) {
+    const currentExecutionId = ++executionId;
+    const { confirm, confirmation: confirmationOptions, ...sendOptions } = options ?? {};
+    const transactionOptions = Object.keys(sendOptions).length > 0 ? sendOptions : void 0;
+    status.value = "sending";
+    loading.value = true;
+    error.value = null;
+    confirmation.value = null;
+    try {
+      if (!wallet.value) {
+        throw new Error("No Solana wallet is configured");
+      }
+      const nextSignature = await withWalletTransactionTimeout(
+        transaction.signAndSendTransaction(connection, wallet.value, transaction$1, transactionOptions)
+      );
+      if (currentExecutionId === executionId) {
+        signature.value = nextSignature;
+        status.value = confirm ? "confirming" : "sent";
+      }
+      if (!confirm) {
+        return nextSignature;
+      }
+      const nextConfirmation = await transaction.confirmTransactionSignature(
+        connection,
+        nextSignature,
+        confirmationOptions
+      );
+      if (currentExecutionId === executionId) {
+        confirmation.value = nextConfirmation;
+        status.value = useTransactionConfirmation.getConfirmedTransactionStatus(nextConfirmation);
+      }
+      return nextSignature;
+    } catch (cause) {
+      if (currentExecutionId === executionId) {
+        error.value = cause;
+        status.value = "error";
+      }
+      throw cause;
+    } finally {
+      if (currentExecutionId === executionId) {
+        loading.value = false;
+      }
+    }
+  }
+  return {
+    signature,
+    confirmation,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+async function withWalletTransactionTimeout(promise) {
+  let timeoutId;
+  try {
+    const timeout = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(
+          new Error(
+            "Wallet transaction did not return a result. Check your wallet or explorer for the final status."
+          )
+        );
+      }, SIGN_AND_SEND_TIMEOUT_MS);
+    });
+    return await Promise.race([promise, timeout]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
+exports.useSignAndSendTransaction = useSignAndSendTransaction;

package/dist/shared/vue.DHVYJk8P.cjs

@@ -0,0 +1,72 @@
+'use strict';
+
+const transaction = require('@vue-solana/core/transaction');
+const vue = require('vue');
+const useConnection = require('./vue.CwhEmATP.cjs');
+
+function getConfirmedTransactionStatus(confirmation) {
+  if (confirmation.commitment === "finalized") {
+    return "finalized";
+  }
+  return confirmation.commitment === "processed" ? "processed" : "confirmed";
+}
+function useTransactionConfirmation(defaultOptions = {}) {
+  const connection = useConnection.useConnection();
+  const signature = vue.ref(null);
+  const confirmation = vue.ref(null);
+  const status = vue.ref("idle");
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  let executionId = 0;
+  async function confirm(nextSignature, options = {}) {
+    const currentExecutionId = ++executionId;
+    const confirmationOptions = { ...defaultOptions, ...options };
+    signature.value = nextSignature;
+    confirmation.value = null;
+    status.value = "confirming";
+    loading.value = true;
+    error.value = null;
+    try {
+      const nextConfirmation = await transaction.confirmTransactionSignature(
+        connection,
+        nextSignature,
+        confirmationOptions
+      );
+      if (currentExecutionId === executionId) {
+        confirmation.value = nextConfirmation;
+        status.value = getConfirmedTransactionStatus(nextConfirmation);
+      }
+      return nextConfirmation;
+    } catch (cause) {
+      if (currentExecutionId === executionId) {
+        error.value = cause;
+        status.value = "error";
+      }
+      throw cause;
+    } finally {
+      if (currentExecutionId === executionId) {
+        loading.value = false;
+      }
+    }
+  }
+  function reset() {
+    executionId += 1;
+    signature.value = null;
+    confirmation.value = null;
+    status.value = "idle";
+    loading.value = false;
+    error.value = null;
+  }
+  return {
+    signature,
+    confirmation,
+    status,
+    loading,
+    error,
+    confirm,
+    reset
+  };
+}
+
+exports.getConfirmedTransactionStatus = getConfirmedTransactionStatus;
+exports.useTransactionConfirmation = useTransactionConfirmation;

package/dist/shared/{vue.CNhelr8H.cjs → vue.DQi38JeF.cjs}

@@ -2,6 +2,25 @@
 
 const vue = require('vue');
 
+async function withTimeout(promise, timeoutMs, message) {
+  if (!timeoutMs) {
+    return promise;
+  }
+  let timeoutId;
+  try {
+    const timeout = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(new Error(message));
+      }, timeoutMs);
+    });
+    return await Promise.race([promise, timeout]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
 function useTransaction(handler, options = {}) {
   const signature = vue.ref(null);
   const loading = vue.ref(false);
@@ -39,21 +58,6 @@ function useTransaction(handler, options = {}) {
     execute
   };
 }
-function withTimeout(promise, timeoutMs, message) {
-  if (!timeoutMs) {
-    return promise;
-  }
-  let timeoutId;
-  const timeout = new Promise((_, reject) => {
-    timeoutId = setTimeout(() => {
-      reject(new Error(message));
-    }, timeoutMs);
-  });
-  return Promise.race([promise, timeout]).finally(() => {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-  });
-}
 
 exports.useTransaction = useTransaction;
+exports.withTimeout = withTimeout;

package/dist/shared/vue.RQ9fETnm.mjs

@@ -0,0 +1,90 @@
+import { signAndSendTransaction, confirmTransactionSignature } from '@vue-solana/core/transaction';
+import { ref } from 'vue';
+import { u as useConnection } from './vue.DlEAL2G8.mjs';
+import { u as useWallet } from './vue.DYf_CRDv.mjs';
+import { g as getConfirmedTransactionStatus } from './vue.jOsz34kz.mjs';
+
+const SIGN_AND_SEND_TIMEOUT_MS = 12e4;
+function useSignAndSendTransaction() {
+  const connection = useConnection();
+  const { wallet } = useWallet();
+  const signature = ref(null);
+  const confirmation = ref(null);
+  const status = ref("idle");
+  const loading = ref(false);
+  const error = ref(null);
+  let executionId = 0;
+  async function execute(transaction, options) {
+    const currentExecutionId = ++executionId;
+    const { confirm, confirmation: confirmationOptions, ...sendOptions } = options ?? {};
+    const transactionOptions = Object.keys(sendOptions).length > 0 ? sendOptions : void 0;
+    status.value = "sending";
+    loading.value = true;
+    error.value = null;
+    confirmation.value = null;
+    try {
+      if (!wallet.value) {
+        throw new Error("No Solana wallet is configured");
+      }
+      const nextSignature = await withWalletTransactionTimeout(
+        signAndSendTransaction(connection, wallet.value, transaction, transactionOptions)
+      );
+      if (currentExecutionId === executionId) {
+        signature.value = nextSignature;
+        status.value = confirm ? "confirming" : "sent";
+      }
+      if (!confirm) {
+        return nextSignature;
+      }
+      const nextConfirmation = await confirmTransactionSignature(
+        connection,
+        nextSignature,
+        confirmationOptions
+      );
+      if (currentExecutionId === executionId) {
+        confirmation.value = nextConfirmation;
+        status.value = getConfirmedTransactionStatus(nextConfirmation);
+      }
+      return nextSignature;
+    } catch (cause) {
+      if (currentExecutionId === executionId) {
+        error.value = cause;
+        status.value = "error";
+      }
+      throw cause;
+    } finally {
+      if (currentExecutionId === executionId) {
+        loading.value = false;
+      }
+    }
+  }
+  return {
+    signature,
+    confirmation,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+async function withWalletTransactionTimeout(promise) {
+  let timeoutId;
+  try {
+    const timeout = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(
+          new Error(
+            "Wallet transaction did not return a result. Check your wallet or explorer for the final status."
+          )
+        );
+      }, SIGN_AND_SEND_TIMEOUT_MS);
+    });
+    return await Promise.race([promise, timeout]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
+export { useSignAndSendTransaction as u };