@vue-solana/vue 1.2.0 → 2.1.0

package/dist/shared/vue.CoaIWGPT.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+const action = require('@vue-solana/core/action');
+const vue = require('vue');
+
+function useAction(action$1, options = {}) {
+  const store = action.createSolanaActionStore(
+    (signal, ...args) => vue.unref(action$1)(signal, ...args)
+  );
+  const state = vue.shallowRef(store.getState());
+  const unsubscribe = store.subscribe(() => {
+    const next = store.getState();
+    const previous = state.value;
+    if (next.status === "success" && previous.status !== "success") {
+      options.onSuccess?.(next.data);
+    }
+    if (next.status === "error" && previous.status !== "error") {
+      options.onError?.(next.error);
+    }
+    state.value = next;
+  });
+  vue.onScopeDispose(() => {
+    unsubscribe();
+    store.reset();
+  });
+  return {
+    data: vue.computed(() => state.value.data),
+    dispatch: (...args) => store.dispatchAsync(...args),
+    error: vue.computed(() => state.value.error),
+    isRunning: vue.computed(() => state.value.status === "running"),
+    reset: () => {
+      store.reset();
+    },
+    status: vue.computed(() => state.value.status)
+  };
+}
+
+exports.useAction = useAction;

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.CpkwC8Th.mjs

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

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.D-qi8PSL.cjs

@@ -0,0 +1,82 @@
+'use strict';
+
+const errors = require('@vue-solana/core/errors');
+const vue = require('vue');
+const address = require('@vue-solana/core/address');
+const useConnection = require('./vue.BVaMoz9y.cjs');
+const useSolana = require('./vue.DE3emjSF.cjs');
+const decodeBase64 = require('./vue.DNxOpDXz.cjs');
+
+function useAccountInfo(address$1, options = {}) {
+  const solana = useSolana.tryUseSolana();
+  const client = solana?.client ?? useConnection.useConnection();
+  const accountInfo = vue.shallowRef(null);
+  const loading = vue.shallowRef(false);
+  const error = vue.shallowRef(null);
+  let refreshId = 0;
+  async function refresh() {
+    const requestId = ++refreshId;
+    const value = vue.toValue(address$1);
+    if (!value || !solana) {
+      accountInfo.value = null;
+      loading.value = false;
+      error.value = null;
+      return null;
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const parsedAddress = address.parseAddress(value);
+      if (!parsedAddress) {
+        accountInfo.value = null;
+        return null;
+      }
+      const { value: account } = await client.rpc.getAccountInfo(parsedAddress, {
+        encoding: "base64",
+        commitment: options.commitment
+      }).send();
+      const nextAccountInfo = account ? normalizeAccountInfo(account) : null;
+      if (requestId === refreshId) {
+        accountInfo.value = nextAccountInfo;
+      }
+      return nextAccountInfo;
+    } catch (cause) {
+      const normalizedError = errors.normalizeSolanaError(cause, "RPC_FAILURE");
+      if (requestId === refreshId) {
+        accountInfo.value = null;
+        error.value = normalizedError;
+      }
+      throw normalizedError;
+    } finally {
+      if (requestId === refreshId) {
+        loading.value = false;
+      }
+    }
+  }
+  vue.onMounted(() => {
+    void refresh().catch(() => void 0);
+  });
+  vue.watch(
+    () => vue.toValue(address$1),
+    () => {
+      void refresh().catch(() => void 0);
+    }
+  );
+  return {
+    accountInfo,
+    loading,
+    error,
+    refresh
+  };
+}
+function normalizeAccountInfo(account) {
+  return {
+    executable: account.executable,
+    lamports: Number(account.lamports),
+    owner: account.owner,
+    space: Number(account.space),
+    data: decodeBase64.decodeBase64(account.data[0])
+  };
+}
+
+exports.useAccountInfo = useAccountInfo;

package/dist/shared/{vue.B2AQR2bE.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.CYKT65tB.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,9 +21,10 @@ function useWallet() {
       const connection = activeWallet.connect();
       triggerRef(wallet);
       await connection;
+      assertWalletConnected(activeWallet);
       triggerRef(wallet);
       console.info("[Vue Solana] Wallet connected", {
-        publicKey: activeWallet.publicKey?.toBase58() ?? null
+        publicKey: activeWallet.publicKey ?? null
       });
     } catch (error) {
       const normalizedError = normalizeSolanaError(error, "RPC_FAILURE");
@@ -36,7 +40,7 @@ function useWallet() {
     if (!activeWallet) {
       return;
     }
-    const publicKey = activeWallet.publicKey?.toBase58() ?? null;
+    const publicKey = activeWallet.publicKey ?? null;
     disconnecting.value = true;
     try {
       await activeWallet.disconnect();

package/dist/shared/{vue.QHAHFnw8.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.DiNn3XHm.mjs';
+import { u as useConnection } from './vue.CpkwC8Th.mjs';
 
 function getConfirmedTransactionStatus(confirmation) {
   if (confirmation.commitment === "finalized") {
@@ -10,7 +10,7 @@ function getConfirmedTransactionStatus(confirmation) {
   return confirmation.commitment === "processed" ? "processed" : "confirmed";
 }
 function useTransactionConfirmation(defaultOptions = {}) {
-  const connection = useConnection();
+  const client = useConnection();
   const signature = ref(null);
   const confirmation = ref(null);
   const status = ref("idle");
@@ -27,7 +27,7 @@ function useTransactionConfirmation(defaultOptions = {}) {
     error.value = null;
     try {
       const nextConfirmation = await confirmTransactionSignature(
-        connection,
+        client,
         nextSignature,
         confirmationOptions
       );

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.j1vB3h1n.cjs → vue.DAg5wC1G.cjs}

@@ -1,15 +1,15 @@
 'use strict';
 
-const address = require('@vue-solana/core/address');
-const errors = require('@vue-solana/core/errors');
 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.DCgByzxg.cjs');
-const useSolana = require('./vue.BE4KHksm.cjs');
+const useConnection = require('./vue.BVaMoz9y.cjs');
+const useSolana = require('./vue.DE3emjSF.cjs');
 
-function useTokenBalance(mint, owner) {
+function useTokenBalance(mint, owner, commitment) {
   const solana = useSolana.tryUseSolana();
-  const connection = solana?.connection ?? useConnection.useConnection();
+  const client = solana?.client ?? useConnection.useConnection();
   const balance = vue.shallowRef(null);
   const decimals = vue.shallowRef(null);
   const loading = vue.shallowRef(false);
@@ -29,15 +29,15 @@ function useTokenBalance(mint, owner) {
     loading.value = true;
     error.value = null;
     try {
-      const mintKey = address.parsePublicKey(mintValue);
-      const ownerKey = address.parsePublicKey(ownerValue);
+      const mintKey = address.parseAddress(mintValue);
+      const ownerKey = address.parseAddress(ownerValue);
       if (!mintKey || !ownerKey) {
         balance.value = null;
         decimals.value = null;
         loading.value = false;
         return null;
       }
-      const nextBalance = await tokenAccounts.getTokenBalance(connection, mintKey, ownerKey);
+      const nextBalance = await tokenAccounts.getTokenBalance(client, mintKey, ownerKey, commitment);
       if (requestId === refreshId) {
         balance.value = nextBalance?.amount ?? null;
         decimals.value = nextBalance?.decimals ?? null;