@vue-solana/vue 2.0.0 → 2.1.0

package/dist/shared/vue.CogzzQXM.mjs

@@ -0,0 +1,171 @@
+import { createReactiveStoreWithInitialValueAndSlotTracking, getAbortablePromise } from '@vue-solana/core/kit';
+import { normalizeSolanaError } from '@vue-solana/core/errors';
+import { shallowRef, watch, unref, onMounted, getCurrentInstance, onScopeDispose, computed } from 'vue';
+
+function isActionSource(value) {
+  return typeof value === "object" && value !== null && "reactiveStore" in value && typeof value.reactiveStore === "function";
+}
+function useTrackedData(source, options = {}) {
+  const data = shallowRef(void 0);
+  const error = shallowRef(null);
+  const status = shallowRef("loading");
+  const disposables = [];
+  let connectionCount = 0;
+  let disposed = false;
+  let activeStore;
+  function applyState(state) {
+    if (state.status === "loaded") {
+      data.value = state.data;
+      error.value = null;
+      status.value = "loaded";
+    } else if (state.status === "error") {
+      error.value = normalizeSolanaError(state.error, "RPC_FAILURE");
+      status.value = "error";
+      options.onError?.(state.error);
+    } else if (state.status === "loading") {
+      status.value = data.value === void 0 ? "loading" : status.value;
+    } else if (state.status === "idle") {
+      error.value = null;
+    }
+  }
+  function buildAndConnect() {
+    if (disposed) {
+      return;
+    }
+    let rpcRequest = unref(source.rpcRequest);
+    const rpcSubscriptionRequest = unref(source.rpcSubscriptionRequest);
+    if (!rpcRequest || !rpcSubscriptionRequest) {
+      disconnect();
+      data.value = void 0;
+      error.value = null;
+      status.value = "disabled";
+      return;
+    }
+    if (!isActionSource(rpcRequest) && isSendSource(rpcRequest)) {
+      let runSend = function(abortSignal) {
+        controller?.abort();
+        controller = new AbortController();
+        const composed = abortSignal ? AbortSignal.any([controller.signal, abortSignal]) : controller.signal;
+        settle({ data: void 0, error: void 0, status: "running" });
+        const pending = Promise.resolve(sendSource.send({ abortSignal: composed }));
+        pending.then((response) => {
+          settle({ data: response, error: void 0, status: "success" });
+        }).catch((cause) => {
+          settle({ data: void 0, error: cause, status: "error" });
+        });
+        return getAbortablePromise(pending, composed);
+      };
+      const sendSource = rpcRequest;
+      const listeners = /* @__PURE__ */ new Set();
+      let sendState = {
+        data: void 0,
+        error: void 0,
+        status: "idle"
+      };
+      let controller;
+      const emit = () => {
+        listeners.forEach((listener) => {
+          listener();
+        });
+      };
+      const settle = (next) => {
+        sendState = next;
+        emit();
+      };
+      rpcRequest = {
+        reactiveStore: () => ({
+          dispatch() {
+            void runSend().catch(() => {
+            });
+          },
+          dispatchAsync: () => runSend(),
+          getState: () => sendState,
+          reset() {
+            controller?.abort();
+            settle({ data: void 0, error: void 0, status: "idle" });
+          },
+          subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+              listeners.delete(listener);
+            };
+          },
+          withSignal(signal) {
+            return {
+              dispatch: () => {
+                void runSend(signal).catch(() => {
+                });
+              },
+              dispatchAsync: () => runSend(signal)
+            };
+          }
+        })
+      };
+    }
+    connectionCount += 1;
+    const connection = connectionCount;
+    const callerSignal = options.getAbortSignal?.(connection);
+    const store = createReactiveStoreWithInitialValueAndSlotTracking({
+      initialValueMapper: source.rpcValueMapper,
+      initialValueSource: rpcRequest,
+      streamSource: rpcSubscriptionRequest,
+      streamValueMapper: source.rpcSubscriptionValueMapper
+    });
+    activeStore = store;
+    applyState(store.getState());
+    disposables.push(
+      store.subscribe(() => {
+        applyState(store.getState());
+      })
+    );
+    if (callerSignal?.aborted) {
+      applyState({ data: store.getState().data, error: callerSignal.reason, status: "error" });
+      return;
+    }
+    if (callerSignal) {
+      store.withSignal(callerSignal).connect();
+    } else {
+      store.connect();
+    }
+  }
+  function disconnect() {
+    disposables.forEach((dispose) => {
+      dispose();
+    });
+    disposables.length = 0;
+    if (activeStore) {
+      activeStore.reset();
+      activeStore = void 0;
+    }
+  }
+  watch(
+    () => [unref(source.rpcRequest), unref(source.rpcSubscriptionRequest)],
+    () => {
+      buildAndConnect();
+    },
+    { flush: "post" }
+  );
+  onMounted(() => {
+    buildAndConnect();
+  });
+  if (!getCurrentInstance()) {
+    buildAndConnect();
+  }
+  onScopeDispose(() => {
+    disposed = true;
+    disconnect();
+  });
+  return {
+    data: computed(() => data.value),
+    error: computed(() => error.value),
+    refresh: () => {
+      buildAndConnect();
+    },
+    status: computed(() => status.value)
+  };
+}
+function isSendSource(value) {
+  return typeof value === "object" && value !== null && "send" in value && typeof value.send === "function";
+}
+
+export { useTrackedData as u };

package/dist/shared/{vue.ChujsB0B.mjs → vue.CpkwC8Th.mjs}

@@ -1,4 +1,4 @@
-import { u as useSolanaClient } from './vue.BaFrF2PF.mjs';
+import { u as useSolanaClient } from './vue.Mxc8w6Qk.mjs';
 
 function useConnection() {
   return useSolanaClient().client;

package/dist/shared/vue.CrkK_T15.cjs

@@ -0,0 +1,86 @@
+'use strict';
+
+const errors = require('@vue-solana/core/errors');
+const timeout = require('@vue-solana/core/timeout');
+const wallet = require('@vue-solana/core/wallet');
+const vue = require('vue');
+const useWallet = require('./vue.BGxz4dru.cjs');
+
+const SIGN_AND_SEND_TIMEOUT_MS = 12e4;
+class PartialSignAndSendError extends errors.SolanaError {
+  constructor(cause, signatures) {
+    super(cause.code, cause.message, { cause: cause.cause, feature: cause.feature });
+    this.signatures = signatures;
+    this.name = "PartialSignAndSendError";
+  }
+}
+function useSignAndSendTransactions() {
+  const { wallet: wallet$1 } = useWallet.useWallet();
+  const signatures = vue.shallowRef(null);
+  const status = vue.ref("idle");
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  let executionId = 0;
+  async function execute(transactions, options) {
+    const currentExecutionId = ++executionId;
+    status.value = "sending";
+    loading.value = true;
+    error.value = null;
+    signatures.value = null;
+    const activeWallet = wallet$1.value;
+    if (!activeWallet) {
+      const normalizedError = wallet.createNoWalletSelectedError();
+      error.value = normalizedError;
+      status.value = "error";
+      loading.value = false;
+      throw normalizedError;
+    }
+    const sendSingularSequentially = async () => {
+      const collected = [];
+      for (const transaction of transactions) {
+        try {
+          const result = await activeWallet.signAndSendTransaction(transaction, options);
+          collected.push(result.signature);
+        } catch (cause) {
+          throw new PartialSignAndSendError(errors.normalizeSolanaError(cause, "RPC_FAILURE"), collected);
+        }
+      }
+      return collected;
+    };
+    try {
+      wallet.assertWalletCanSignAndSendTransactions(activeWallet);
+      const send = timeout.withSolanaTimeout(
+        activeWallet.signAndSendTransactions ? activeWallet.signAndSendTransactions(transactions, options) : sendSingularSequentially(),
+        SIGN_AND_SEND_TIMEOUT_MS,
+        "Wallet transaction did not return a result. Check your wallet or explorer for the final status."
+      );
+      const result = await send;
+      if (currentExecutionId === executionId) {
+        signatures.value = result;
+        status.value = "sent";
+      }
+      return result;
+    } catch (cause) {
+      const normalizedError = errors.normalizeSolanaError(cause, "RPC_FAILURE");
+      if (currentExecutionId === executionId) {
+        error.value = normalizedError;
+        status.value = "error";
+      }
+      throw normalizedError;
+    } finally {
+      if (currentExecutionId === executionId) {
+        loading.value = false;
+      }
+    }
+  }
+  return {
+    signatures,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+
+exports.PartialSignAndSendError = PartialSignAndSendError;
+exports.useSignAndSendTransactions = useSignAndSendTransactions;

package/dist/shared/{vue.BMencBpI.cjs → vue.D-qi8PSL.cjs}

@@ -3,8 +3,8 @@
 const errors = require('@vue-solana/core/errors');
 const vue = require('vue');
 const address = require('@vue-solana/core/address');
-const useConnection = require('./vue.CZwftA0L.cjs');
-const useSolana = require('./vue.BaR1VPhl.cjs');
+const useConnection = require('./vue.BVaMoz9y.cjs');
+const useSolana = require('./vue.DE3emjSF.cjs');
 const decodeBase64 = require('./vue.DNxOpDXz.cjs');
 
 function useAccountInfo(address$1, options = {}) {

package/dist/shared/{vue.PJjEncbP.mjs → vue.D218Ow7t.mjs}

@@ -1,7 +1,7 @@
 import { normalizeSolanaError } from '@vue-solana/core/errors';
-import { createNoWalletSelectedError } from '@vue-solana/core/wallet';
+import { createNoWalletSelectedError, assertWalletConnected } from '@vue-solana/core/wallet';
 import { ref, computed, triggerRef } from 'vue';
-import { u as useSolana } from './vue.CnUlZSe8.mjs';
+import { u as useSolana } from './vue.CQh3AUE8.mjs';
 
 function useWallet() {
   const solana = useSolana();
@@ -9,6 +9,9 @@ function useWallet() {
   const connecting = ref(false);
   const disconnecting = ref(false);
   async function connect() {
+    if (connecting.value || wallet.value?.connecting) {
+      return;
+    }
     const activeWallet = wallet.value;
     if (!activeWallet) {
       throw createNoWalletSelectedError();
@@ -18,6 +21,7 @@ function useWallet() {
       const connection = activeWallet.connect();
       triggerRef(wallet);
       await connection;
+      assertWalletConnected(activeWallet);
       triggerRef(wallet);
       console.info("[Vue Solana] Wallet connected", {
         publicKey: activeWallet.publicKey ?? null

package/dist/shared/{vue.B2sFJ1xI.mjs → vue.D3Y0PWbF.mjs}

@@ -1,7 +1,7 @@
 import { confirmTransactionSignature } from '@vue-solana/core/transaction';
 import { normalizeSolanaError } from '@vue-solana/core/errors';
 import { ref } from 'vue';
-import { u as useConnection } from './vue.ChujsB0B.mjs';
+import { u as useConnection } from './vue.CpkwC8Th.mjs';
 
 function getConfirmedTransactionStatus(confirmation) {
   if (confirmation.commitment === "finalized") {

package/dist/shared/vue.D5U1yLG3.mjs

@@ -0,0 +1,83 @@
+import { SolanaError, normalizeSolanaError } from '@vue-solana/core/errors';
+import { withSolanaTimeout } from '@vue-solana/core/timeout';
+import { createNoWalletSelectedError, assertWalletCanSignAndSendTransactions } from '@vue-solana/core/wallet';
+import { shallowRef, ref } from 'vue';
+import { u as useWallet } from './vue.D218Ow7t.mjs';
+
+const SIGN_AND_SEND_TIMEOUT_MS = 12e4;
+class PartialSignAndSendError extends SolanaError {
+  constructor(cause, signatures) {
+    super(cause.code, cause.message, { cause: cause.cause, feature: cause.feature });
+    this.signatures = signatures;
+    this.name = "PartialSignAndSendError";
+  }
+}
+function useSignAndSendTransactions() {
+  const { wallet } = useWallet();
+  const signatures = shallowRef(null);
+  const status = ref("idle");
+  const loading = ref(false);
+  const error = ref(null);
+  let executionId = 0;
+  async function execute(transactions, options) {
+    const currentExecutionId = ++executionId;
+    status.value = "sending";
+    loading.value = true;
+    error.value = null;
+    signatures.value = null;
+    const activeWallet = wallet.value;
+    if (!activeWallet) {
+      const normalizedError = createNoWalletSelectedError();
+      error.value = normalizedError;
+      status.value = "error";
+      loading.value = false;
+      throw normalizedError;
+    }
+    const sendSingularSequentially = async () => {
+      const collected = [];
+      for (const transaction of transactions) {
+        try {
+          const result = await activeWallet.signAndSendTransaction(transaction, options);
+          collected.push(result.signature);
+        } catch (cause) {
+          throw new PartialSignAndSendError(normalizeSolanaError(cause, "RPC_FAILURE"), collected);
+        }
+      }
+      return collected;
+    };
+    try {
+      assertWalletCanSignAndSendTransactions(activeWallet);
+      const send = withSolanaTimeout(
+        activeWallet.signAndSendTransactions ? activeWallet.signAndSendTransactions(transactions, options) : sendSingularSequentially(),
+        SIGN_AND_SEND_TIMEOUT_MS,
+        "Wallet transaction did not return a result. Check your wallet or explorer for the final status."
+      );
+      const result = await send;
+      if (currentExecutionId === executionId) {
+        signatures.value = result;
+        status.value = "sent";
+      }
+      return result;
+    } catch (cause) {
+      const normalizedError = normalizeSolanaError(cause, "RPC_FAILURE");
+      if (currentExecutionId === executionId) {
+        error.value = normalizedError;
+        status.value = "error";
+      }
+      throw normalizedError;
+    } finally {
+      if (currentExecutionId === executionId) {
+        loading.value = false;
+      }
+    }
+  }
+  return {
+    signatures,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+
+export { PartialSignAndSendError as P, useSignAndSendTransactions as u };

package/dist/shared/{vue.CXHYdyKZ.cjs → vue.DAg5wC1G.cjs}

@@ -4,8 +4,8 @@ const tokenAccounts = require('@vue-solana/core/token-accounts');
 const errors = require('@vue-solana/core/errors');
 const address = require('@vue-solana/core/address');
 const vue = require('vue');
-const useConnection = require('./vue.CZwftA0L.cjs');
-const useSolana = require('./vue.BaR1VPhl.cjs');
+const useConnection = require('./vue.BVaMoz9y.cjs');
+const useSolana = require('./vue.DE3emjSF.cjs');
 
 function useTokenBalance(mint, owner, commitment) {
   const solana = useSolana.tryUseSolana();

package/dist/shared/vue.DDbVk0Zh.cjs

@@ -0,0 +1,180 @@
+'use strict';
+
+const vue = require('vue');
+const injection = require('./vue.DEHxNvUX.cjs');
+
+const SELECTED_WALLET_ACCOUNT_STORAGE_KEY = "vue-solana:selected-wallet-account";
+function createLocalStorageSelectedWalletAccountStorage(storage = defaultLocalStorage()) {
+  return {
+    storeSelectedWallet(key) {
+      try {
+        storage?.setItem(SELECTED_WALLET_ACCOUNT_STORAGE_KEY, key);
+      } catch {
+      }
+    },
+    getSelectedWallet() {
+      try {
+        return storage?.getItem(SELECTED_WALLET_ACCOUNT_STORAGE_KEY) ?? null;
+      } catch {
+        return null;
+      }
+    },
+    deleteSelectedWallet() {
+      try {
+        storage?.removeItem(SELECTED_WALLET_ACCOUNT_STORAGE_KEY);
+      } catch {
+      }
+    }
+  };
+}
+function defaultLocalStorage() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+
+const selectedWalletAccountInjectionKey = Symbol.for("vue-solana:selected-wallet-account");
+function provideSelectedWalletAccount(options = {}) {
+  const context = createSelectedWalletAccountContext(options);
+  vue.provide(selectedWalletAccountInjectionKey, context);
+  return context;
+}
+function createSelectedWalletAccountContext(options = {}, solanaContextOverride) {
+  const solanaContext = solanaContextOverride ?? vue.inject(injection.solanaInjectionKey, null);
+  const stateSync = options.stateSync === void 0 ? defaultStateSync() : options.stateSync;
+  const selectedWalletAccount = vue.ref(null);
+  const walletsValue = () => solanaContext?.wallets.value ?? [];
+  let pendingKey = null;
+  let selectionGeneration = 0;
+  function findAccount(key) {
+    const separatorIndex = key.lastIndexOf(":");
+    const walletName = separatorIndex === -1 ? key : key.slice(0, separatorIndex);
+    const address = separatorIndex === -1 ? "" : key.slice(separatorIndex + 1);
+    const wallet = walletsValue().find((candidate) => candidate.name === walletName);
+    const account = wallet?.accounts.find((candidate) => candidate.address === address);
+    if (!wallet || !account) {
+      return null;
+    }
+    return { ...account, walletName: wallet.name };
+  }
+  function clearSelection() {
+    selectionGeneration += 1;
+    pendingKey = null;
+    selectedWalletAccount.value = null;
+  }
+  function applyExternalSelection(key) {
+    if (!key) {
+      clearSelection();
+      return;
+    }
+    const account = findAccount(key);
+    if (account) {
+      selectionGeneration += 1;
+      pendingKey = null;
+      selectedWalletAccount.value = account;
+      return;
+    }
+    pendingKey = key;
+  }
+  function restoreIfAvailable() {
+    if (!pendingKey || selectedWalletAccount.value) {
+      return;
+    }
+    const account = findAccount(pendingKey);
+    if (account) {
+      selectedWalletAccount.value = account;
+      pendingKey = null;
+    }
+  }
+  if (stateSync) {
+    const generation = selectionGeneration;
+    void Promise.resolve(stateSync.getSelectedWallet()).then((key) => {
+      if (generation !== selectionGeneration || !key || selectedWalletAccount.value) {
+        return;
+      }
+      pendingKey = key;
+      restoreIfAvailable();
+    }).catch(() => void 0);
+  }
+  if (solanaContext) {
+    vue.watch(
+      () => solanaContext.wallets.value,
+      () => restoreIfAvailable()
+    );
+  }
+  if (stateSync && typeof window !== "undefined") {
+    const onStorage = () => {
+      void Promise.resolve(stateSync.getSelectedWallet()).then((key) => applyExternalSelection(key)).catch(() => void 0);
+    };
+    window.addEventListener("storage", onStorage);
+    if (vue.getCurrentScope()) {
+      vue.onScopeDispose(() => window.removeEventListener("storage", onStorage));
+    }
+  }
+  const context = {
+    selectedWalletAccount,
+    setSelectedWalletAccount(account) {
+      selectionGeneration += 1;
+      selectedWalletAccount.value = account;
+      pendingKey = null;
+      if (!stateSync) {
+        return;
+      }
+      const persisted = account ? stateSync.storeSelectedWallet(`${account.walletName}:${account.address}`) : stateSync.deleteSelectedWallet();
+      void Promise.resolve(persisted).catch(() => void 0);
+    },
+    filteredWallets: vue.computed(() => {
+      const filter = options.filterWallet;
+      if (!filter) {
+        return walletsValue();
+      }
+      return walletsValue().map((wallet) => {
+        const accounts = wallet.accounts.filter((account) => filter(wallet.name, account));
+        return accounts.length === 0 ? null : { ...wallet, accounts };
+      }).filter((wallet) => wallet !== null);
+    })
+  };
+  return context;
+}
+function useSelectedWalletAccount() {
+  const context = vue.inject(selectedWalletAccountInjectionKey, null);
+  if (!context) {
+    throw new Error("useSelectedWalletAccount must be used inside a SelectedWalletAccountProvider");
+  }
+  return [context.selectedWalletAccount, context.setSelectedWalletAccount, context.filteredWallets];
+}
+function defaultStateSync() {
+  return createLocalStorageSelectedWalletAccountStorage();
+}
+
+const SelectedWalletAccountProvider = vue.defineComponent({
+  name: "SelectedWalletAccountProvider",
+  props: {
+    filterWallet: {
+      type: Function,
+      default: void 0
+    },
+    stateSync: {
+      type: [Object, null],
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    provideSelectedWalletAccount({
+      filterWallet: props.filterWallet,
+      stateSync: props.stateSync
+    });
+    return () => slots.default?.();
+  }
+});
+
+exports.SelectedWalletAccountProvider = SelectedWalletAccountProvider;
+exports.createSelectedWalletAccountContext = createSelectedWalletAccountContext;
+exports.provideSelectedWalletAccount = provideSelectedWalletAccount;
+exports.selectedWalletAccountInjectionKey = selectedWalletAccountInjectionKey;
+exports.useSelectedWalletAccount = useSelectedWalletAccount;

package/dist/shared/{vue.BaR1VPhl.cjs → vue.DE3emjSF.cjs}

@@ -1,14 +1,11 @@
 'use strict';
 
 const vue = require('vue');
-
-const solanaInjectionKey = Symbol.for(
-  "vue-solana:context"
-);
+const injection = require('./vue.DEHxNvUX.cjs');
 
 let ssrContext;
 function tryUseSolana() {
-  return vue.inject(solanaInjectionKey, null);
+  return vue.inject(injection.solanaInjectionKey, null);
 }
 function useSolana() {
   return tryUseSolana() ?? getSsrContext();
@@ -47,6 +44,5 @@ function createUnavailableProxy() {
   );
 }
 
-exports.solanaInjectionKey = solanaInjectionKey;
 exports.tryUseSolana = tryUseSolana;
 exports.useSolana = useSolana;

package/dist/shared/vue.DEHxNvUX.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+const solanaInjectionKey = Symbol.for(
+  "vue-solana:context"
+);
+
+exports.solanaInjectionKey = solanaInjectionKey;

package/dist/shared/vue.DFaMJLAQ.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+const errors = require('@vue-solana/core/errors');
+const wallet = require('@vue-solana/core/wallet');
+const vue = require('vue');
+const useWallet = require('./vue.BGxz4dru.cjs');
+
+function useSignTransactions() {
+  const { wallet: wallet$1 } = useWallet.useWallet();
+  const signedTransactions = vue.shallowRef(null);
+  const status = vue.ref("idle");
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  let executionId = 0;
+  async function execute(transactions) {
+    const currentExecutionId = ++executionId;
+    status.value = "signing";
+    loading.value = true;
+    error.value = null;
+    signedTransactions.value = null;
+    const activeWallet = wallet$1.value;
+    if (!activeWallet) {
+      const normalizedError = wallet.createNoWalletSelectedError();
+      error.value = normalizedError;
+      status.value = "error";
+      loading.value = false;
+      throw normalizedError;
+    }
+    try {
+      wallet.assertWalletCanSignTransactions(activeWallet);
+      const sign = activeWallet.signTransactions ? activeWallet.signTransactions.bind(activeWallet) : activeWallet.signAllTransactions.bind(activeWallet);
+      const result = await sign([...transactions]);
+      if (currentExecutionId === executionId) {
+        signedTransactions.value = result;
+        status.value = "signed";
+      }
+      return result;
+    } catch (cause) {
+      const normalizedError = errors.normalizeSolanaError(cause, "RPC_FAILURE");
+      if (currentExecutionId === executionId) {
+        error.value = normalizedError;
+        status.value = "error";
+      }
+      throw normalizedError;
+    } finally {
+      if (currentExecutionId === executionId) {
+        loading.value = false;
+      }
+    }
+  }
+  return {
+    signedTransactions,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+
+exports.useSignTransactions = useSignTransactions;