@vue-solana/vue 0.6.0 → 0.7.0

package/dist/shared/{vue.RQ9fETnm.mjs → vue.CM6qb_s8.mjs}

@@ -1,7 +1,7 @@
 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 { u as useWallet } from './vue.CGVdFmYI.mjs';
 import { g as getConfirmedTransactionStatus } from './vue.jOsz34kz.mjs';
 
 const SIGN_AND_SEND_TIMEOUT_MS = 12e4;
@@ -22,12 +22,17 @@ function useSignAndSendTransaction() {
     loading.value = true;
     error.value = null;
     confirmation.value = null;
+    const activeWallet = wallet.value;
+    if (!activeWallet) {
+      const cause = new Error("No Solana wallet is configured");
+      error.value = cause;
+      status.value = "error";
+      loading.value = false;
+      throw cause;
+    }
     try {
-      if (!wallet.value) {
-        throw new Error("No Solana wallet is configured");
-      }
       const nextSignature = await withWalletTransactionTimeout(
-        signAndSendTransaction(connection, wallet.value, transaction, transactionOptions)
+        signAndSendTransaction(connection, activeWallet, transaction, transactionOptions)
       );
       if (currentExecutionId === executionId) {
         signature.value = nextSignature;

package/dist/shared/vue.CUTLu1Gf.mjs

@@ -0,0 +1,71 @@
+import { parsePublicKey } from '@vue-solana/core/address';
+import { shallowRef, onMounted, onUnmounted, watch, toValue } from 'vue';
+import { u as useConnection } from './vue.DlEAL2G8.mjs';
+import { t as tryUseSolana } from './vue.1M_c5FWA.mjs';
+
+function useProgramAccounts(programId, options = {}) {
+  const solana = tryUseSolana();
+  const connection = solana?.connection ?? useConnection();
+  const accounts = shallowRef([]);
+  const loading = shallowRef(false);
+  const error = shallowRef(null);
+  let refreshId = 0;
+  async function refresh() {
+    const requestId = ++refreshId;
+    const value = toValue(programId);
+    if (!value || !solana) {
+      accounts.value = [];
+      loading.value = false;
+      error.value = null;
+      return [];
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const publicKey = parsePublicKey(value);
+      if (!publicKey) {
+        accounts.value = [];
+        return [];
+      }
+      const nextAccounts = await connection.getProgramAccounts(publicKey, {
+        commitment: options.commitment,
+        dataSlice: options.dataSlice,
+        filters: options.filters
+      });
+      if (requestId === refreshId) {
+        accounts.value = nextAccounts;
+      }
+      return nextAccounts;
+    } catch (cause) {
+      if (requestId === refreshId) {
+        accounts.value = [];
+        error.value = cause;
+      }
+      throw cause;
+    } finally {
+      if (requestId === refreshId) {
+        loading.value = false;
+      }
+    }
+  }
+  onMounted(() => {
+    void refresh().catch(() => void 0);
+  });
+  onUnmounted(() => {
+    refreshId += 1;
+  });
+  watch(
+    () => toValue(programId),
+    () => {
+      void refresh().catch(() => void 0);
+    }
+  );
+  return {
+    accounts,
+    loading,
+    error,
+    refresh
+  };
+}
+
+export { useProgramAccounts as u };

package/dist/shared/vue.D1knFN3X.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+const wallet = require('@vue-solana/core/wallet');
+const vue = require('vue');
+const useWallet = require('./vue.BwipRa1w.cjs');
+
+function useSignMessage() {
+  const { wallet: wallet$1 } = useWallet.useWallet();
+  const signedMessage = vue.ref(null);
+  const signature = vue.ref(null);
+  const status = vue.ref("idle");
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  let executionId = 0;
+  async function execute(message) {
+    const currentExecutionId = ++executionId;
+    status.value = "signing";
+    loading.value = true;
+    error.value = null;
+    signedMessage.value = null;
+    signature.value = null;
+    const activeWallet = wallet$1.value;
+    if (!activeWallet) {
+      const cause = new Error("No Solana wallet is configured");
+      error.value = cause;
+      status.value = "error";
+      loading.value = false;
+      throw cause;
+    }
+    try {
+      wallet.assertWalletCanSignMessage(activeWallet);
+      const result = await activeWallet.signMessage(message);
+      if (currentExecutionId === executionId) {
+        signedMessage.value = result.signedMessage;
+        signature.value = result.signature;
+        status.value = "signed";
+      }
+      return result;
+    } catch (cause) {
+      const normalizedError = normalizeError(cause);
+      if (currentExecutionId === executionId) {
+        error.value = normalizedError;
+        status.value = "error";
+      }
+      throw normalizedError;
+    } finally {
+      if (currentExecutionId === executionId) {
+        loading.value = false;
+      }
+    }
+  }
+  return {
+    signedMessage,
+    signature,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+function normalizeError(cause) {
+  return cause instanceof Error ? cause : new Error(String(cause));
+}
+
+exports.useSignMessage = useSignMessage;

package/dist/shared/vue.DUufwq8y.cjs

@@ -0,0 +1,186 @@
+'use strict';
+
+const bs58 = require('bs58');
+const vue = require('vue');
+const useConnection = require('./vue.CwhEmATP.cjs');
+const useSolana = require('./vue.C4tLiG3R.cjs');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const bs58__default = /*#__PURE__*/_interopDefaultCompat(bs58);
+
+function useSignatureStatus(signature, options = {}) {
+  const solana = useSolana.tryUseSolana();
+  const connection = solana?.connection ?? useConnection.useConnection();
+  const status = vue.shallowRef(null);
+  const loading = vue.shallowRef(false);
+  const error = vue.shallowRef(null);
+  let refreshId = 0;
+  let subscriptionStartId = 0;
+  let pollId = null;
+  let subscriptionId = null;
+  let manuallyStoppedPolling = false;
+  let manuallyStoppedSubscription = false;
+  async function refresh() {
+    const requestId = ++refreshId;
+    const value = vue.toValue(signature);
+    if (!value || !solana) {
+      status.value = null;
+      loading.value = false;
+      error.value = null;
+      return null;
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const validSignature = parseTransactionSignature(value);
+      const response = await connection.getSignatureStatuses([validSignature], {
+        searchTransactionHistory: options.searchTransactionHistory
+      });
+      const nextStatus = response.value[0] ?? null;
+      if (requestId === refreshId) {
+        status.value = nextStatus;
+      }
+      return nextStatus;
+    } catch (cause) {
+      if (requestId === refreshId) {
+        status.value = null;
+        error.value = cause;
+      }
+      throw cause;
+    } finally {
+      if (requestId === refreshId) {
+        loading.value = false;
+      }
+    }
+  }
+  function stopPolling() {
+    manuallyStoppedPolling = true;
+    stopCurrentPolling();
+  }
+  function stopCurrentPolling() {
+    if (pollId === null) {
+      return;
+    }
+    clearInterval(pollId);
+    pollId = null;
+  }
+  function startPolling() {
+    stopCurrentPolling();
+    const value = vue.toValue(signature);
+    if (manuallyStoppedPolling || !options.pollIntervalMs || !value || !solana) {
+      return;
+    }
+    if (options.pollIntervalMs <= 0) {
+      error.value = new RangeError("pollIntervalMs must be greater than 0");
+      return;
+    }
+    try {
+      parseTransactionSignature(value);
+    } catch (cause) {
+      error.value = cause;
+      return;
+    }
+    pollId = setInterval(() => {
+      void refresh().catch(() => void 0);
+    }, options.pollIntervalMs);
+  }
+  async function stopSubscription() {
+    manuallyStoppedSubscription = true;
+    subscriptionStartId += 1;
+    await stopCurrentSubscription();
+  }
+  async function stopCurrentSubscription() {
+    if (subscriptionId === null) {
+      return;
+    }
+    const currentSubscriptionId = subscriptionId;
+    subscriptionId = null;
+    try {
+      await connection.removeSignatureListener(currentSubscriptionId);
+    } catch (cause) {
+      error.value = cause;
+    }
+  }
+  async function startSubscription() {
+    const requestId = ++subscriptionStartId;
+    await stopCurrentSubscription();
+    if (requestId !== subscriptionStartId) {
+      return;
+    }
+    const value = vue.toValue(signature);
+    if (manuallyStoppedSubscription || !options.subscribe || !value || !solana) {
+      return;
+    }
+    try {
+      const validSignature = parseTransactionSignature(value);
+      const nextSubscriptionId = connection.onSignature(
+        validSignature,
+        (notification, context) => {
+          if (requestId !== subscriptionStartId) {
+            return;
+          }
+          status.value = {
+            slot: context.slot,
+            confirmations: null,
+            err: notification.err,
+            confirmationStatus: options.commitment ?? "confirmed"
+          };
+          error.value = null;
+        },
+        options.commitment
+      );
+      if (requestId !== subscriptionStartId) {
+        await connection.removeSignatureListener(nextSubscriptionId);
+        return;
+      }
+      subscriptionId = nextSubscriptionId;
+    } catch (cause) {
+      if (requestId === subscriptionStartId) {
+        error.value = cause;
+      }
+    }
+  }
+  function resetIntervals() {
+    startPolling();
+    void startSubscription();
+  }
+  vue.onMounted(() => {
+    void refresh().catch(() => void 0);
+    resetIntervals();
+  });
+  vue.onUnmounted(() => {
+    refreshId += 1;
+    stopPolling();
+    void stopSubscription();
+  });
+  vue.watch(
+    () => vue.toValue(signature),
+    () => {
+      void refresh().catch(() => void 0);
+      resetIntervals();
+    }
+  );
+  return {
+    status,
+    loading,
+    error,
+    refresh,
+    stopPolling,
+    stopSubscription
+  };
+}
+function parseTransactionSignature(signature) {
+  let decodedSignature;
+  try {
+    decodedSignature = bs58__default.decode(signature);
+  } catch (cause) {
+    throw new TypeError("Invalid Solana transaction signature", { cause });
+  }
+  if (decodedSignature.length !== 64) {
+    throw new TypeError("Invalid Solana transaction signature");
+  }
+  return signature;
+}
+
+exports.useSignatureStatus = useSignatureStatus;

package/dist/shared/{vue.DEQJ23UM.cjs → vue.DWiQYhb8.cjs}

@@ -3,7 +3,7 @@
 const transaction = require('@vue-solana/core/transaction');
 const vue = require('vue');
 const useConnection = require('./vue.CwhEmATP.cjs');
-const useWallet = require('./vue.CwPjPFN6.cjs');
+const useWallet = require('./vue.BwipRa1w.cjs');
 const useTransactionConfirmation = require('./vue.DHVYJk8P.cjs');
 
 const SIGN_AND_SEND_TIMEOUT_MS = 12e4;
@@ -24,12 +24,17 @@ function useSignAndSendTransaction() {
     loading.value = true;
     error.value = null;
     confirmation.value = null;
+    const activeWallet = wallet.value;
+    if (!activeWallet) {
+      const cause = new Error("No Solana wallet is configured");
+      error.value = cause;
+      status.value = "error";
+      loading.value = false;
+      throw cause;
+    }
     try {
-      if (!wallet.value) {
-        throw new Error("No Solana wallet is configured");
-      }
       const nextSignature = await withWalletTransactionTimeout(
-        transaction.signAndSendTransaction(connection, wallet.value, transaction$1, transactionOptions)
+        transaction.signAndSendTransaction(connection, activeWallet, transaction$1, transactionOptions)
       );
       if (currentExecutionId === executionId) {
         signature.value = nextSignature;

package/dist/shared/vue.JC5FdU2O.mjs

@@ -0,0 +1,180 @@
+import bs58 from 'bs58';
+import { shallowRef, onMounted, onUnmounted, watch, toValue } from 'vue';
+import { u as useConnection } from './vue.DlEAL2G8.mjs';
+import { t as tryUseSolana } from './vue.1M_c5FWA.mjs';
+
+function useSignatureStatus(signature, options = {}) {
+  const solana = tryUseSolana();
+  const connection = solana?.connection ?? useConnection();
+  const status = shallowRef(null);
+  const loading = shallowRef(false);
+  const error = shallowRef(null);
+  let refreshId = 0;
+  let subscriptionStartId = 0;
+  let pollId = null;
+  let subscriptionId = null;
+  let manuallyStoppedPolling = false;
+  let manuallyStoppedSubscription = false;
+  async function refresh() {
+    const requestId = ++refreshId;
+    const value = toValue(signature);
+    if (!value || !solana) {
+      status.value = null;
+      loading.value = false;
+      error.value = null;
+      return null;
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const validSignature = parseTransactionSignature(value);
+      const response = await connection.getSignatureStatuses([validSignature], {
+        searchTransactionHistory: options.searchTransactionHistory
+      });
+      const nextStatus = response.value[0] ?? null;
+      if (requestId === refreshId) {
+        status.value = nextStatus;
+      }
+      return nextStatus;
+    } catch (cause) {
+      if (requestId === refreshId) {
+        status.value = null;
+        error.value = cause;
+      }
+      throw cause;
+    } finally {
+      if (requestId === refreshId) {
+        loading.value = false;
+      }
+    }
+  }
+  function stopPolling() {
+    manuallyStoppedPolling = true;
+    stopCurrentPolling();
+  }
+  function stopCurrentPolling() {
+    if (pollId === null) {
+      return;
+    }
+    clearInterval(pollId);
+    pollId = null;
+  }
+  function startPolling() {
+    stopCurrentPolling();
+    const value = toValue(signature);
+    if (manuallyStoppedPolling || !options.pollIntervalMs || !value || !solana) {
+      return;
+    }
+    if (options.pollIntervalMs <= 0) {
+      error.value = new RangeError("pollIntervalMs must be greater than 0");
+      return;
+    }
+    try {
+      parseTransactionSignature(value);
+    } catch (cause) {
+      error.value = cause;
+      return;
+    }
+    pollId = setInterval(() => {
+      void refresh().catch(() => void 0);
+    }, options.pollIntervalMs);
+  }
+  async function stopSubscription() {
+    manuallyStoppedSubscription = true;
+    subscriptionStartId += 1;
+    await stopCurrentSubscription();
+  }
+  async function stopCurrentSubscription() {
+    if (subscriptionId === null) {
+      return;
+    }
+    const currentSubscriptionId = subscriptionId;
+    subscriptionId = null;
+    try {
+      await connection.removeSignatureListener(currentSubscriptionId);
+    } catch (cause) {
+      error.value = cause;
+    }
+  }
+  async function startSubscription() {
+    const requestId = ++subscriptionStartId;
+    await stopCurrentSubscription();
+    if (requestId !== subscriptionStartId) {
+      return;
+    }
+    const value = toValue(signature);
+    if (manuallyStoppedSubscription || !options.subscribe || !value || !solana) {
+      return;
+    }
+    try {
+      const validSignature = parseTransactionSignature(value);
+      const nextSubscriptionId = connection.onSignature(
+        validSignature,
+        (notification, context) => {
+          if (requestId !== subscriptionStartId) {
+            return;
+          }
+          status.value = {
+            slot: context.slot,
+            confirmations: null,
+            err: notification.err,
+            confirmationStatus: options.commitment ?? "confirmed"
+          };
+          error.value = null;
+        },
+        options.commitment
+      );
+      if (requestId !== subscriptionStartId) {
+        await connection.removeSignatureListener(nextSubscriptionId);
+        return;
+      }
+      subscriptionId = nextSubscriptionId;
+    } catch (cause) {
+      if (requestId === subscriptionStartId) {
+        error.value = cause;
+      }
+    }
+  }
+  function resetIntervals() {
+    startPolling();
+    void startSubscription();
+  }
+  onMounted(() => {
+    void refresh().catch(() => void 0);
+    resetIntervals();
+  });
+  onUnmounted(() => {
+    refreshId += 1;
+    stopPolling();
+    void stopSubscription();
+  });
+  watch(
+    () => toValue(signature),
+    () => {
+      void refresh().catch(() => void 0);
+      resetIntervals();
+    }
+  );
+  return {
+    status,
+    loading,
+    error,
+    refresh,
+    stopPolling,
+    stopSubscription
+  };
+}
+function parseTransactionSignature(signature) {
+  let decodedSignature;
+  try {
+    decodedSignature = bs58.decode(signature);
+  } catch (cause) {
+    throw new TypeError("Invalid Solana transaction signature", { cause });
+  }
+  if (decodedSignature.length !== 64) {
+    throw new TypeError("Invalid Solana transaction signature");
+  }
+  return signature;
+}
+
+export { useSignatureStatus as u };

package/dist/shared/vue.dmuispJ3.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+const address = require('@vue-solana/core/address');
+const vue = require('vue');
+const useConnection = require('./vue.CwhEmATP.cjs');
+const useSolana = require('./vue.C4tLiG3R.cjs');
+
+function useProgramAccounts(programId, options = {}) {
+  const solana = useSolana.tryUseSolana();
+  const connection = solana?.connection ?? useConnection.useConnection();
+  const accounts = vue.shallowRef([]);
+  const loading = vue.shallowRef(false);
+  const error = vue.shallowRef(null);
+  let refreshId = 0;
+  async function refresh() {
+    const requestId = ++refreshId;
+    const value = vue.toValue(programId);
+    if (!value || !solana) {
+      accounts.value = [];
+      loading.value = false;
+      error.value = null;
+      return [];
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const publicKey = address.parsePublicKey(value);
+      if (!publicKey) {
+        accounts.value = [];
+        return [];
+      }
+      const nextAccounts = await connection.getProgramAccounts(publicKey, {
+        commitment: options.commitment,
+        dataSlice: options.dataSlice,
+        filters: options.filters
+      });
+      if (requestId === refreshId) {
+        accounts.value = nextAccounts;
+      }
+      return nextAccounts;
+    } catch (cause) {
+      if (requestId === refreshId) {
+        accounts.value = [];
+        error.value = cause;
+      }
+      throw cause;
+    } finally {
+      if (requestId === refreshId) {
+        loading.value = false;
+      }
+    }
+  }
+  vue.onMounted(() => {
+    void refresh().catch(() => void 0);
+  });
+  vue.onUnmounted(() => {
+    refreshId += 1;
+  });
+  vue.watch(
+    () => vue.toValue(programId),
+    () => {
+      void refresh().catch(() => void 0);
+    }
+  );
+  return {
+    accounts,
+    loading,
+    error,
+    refresh
+  };
+}
+
+exports.useProgramAccounts = useProgramAccounts;

package/dist/useAccountInfo.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+const useAccountInfo = require('./shared/vue.BPnK_lsh.cjs');
+require('@vue-solana/core/address');
+require('vue');
+require('./shared/vue.CwhEmATP.cjs');
+require('./shared/vue.COyyrsQU.cjs');
+require('./shared/vue.C4tLiG3R.cjs');
+
+
+
+exports.useAccountInfo = useAccountInfo.useAccountInfo;

package/dist/useAccountInfo.d.cts

@@ -0,0 +1,19 @@
+import * as vue from 'vue';
+import { MaybeRefOrGetter } from 'vue';
+import { PublicKeyInput } from '@vue-solana/core/address';
+import { Commitment } from '@solana/web3-compat';
+
+interface UseAccountInfoOptions {
+    commitment?: Commitment;
+    watch?: boolean;
+}
+declare function useAccountInfo(address: MaybeRefOrGetter<PublicKeyInput>, options?: UseAccountInfoOptions): {
+    accountInfo: any;
+    loading: vue.ShallowRef<boolean, boolean>;
+    error: vue.ShallowRef<unknown, unknown>;
+    refresh: () => Promise<any>;
+    stopWatching: () => Promise<void>;
+};
+
+export { useAccountInfo };
+export type { UseAccountInfoOptions };

package/dist/useAccountInfo.d.mts

@@ -0,0 +1,19 @@
+import * as vue from 'vue';
+import { MaybeRefOrGetter } from 'vue';
+import { PublicKeyInput } from '@vue-solana/core/address';
+import { Commitment } from '@solana/web3-compat';
+
+interface UseAccountInfoOptions {
+    commitment?: Commitment;
+    watch?: boolean;
+}
+declare function useAccountInfo(address: MaybeRefOrGetter<PublicKeyInput>, options?: UseAccountInfoOptions): {
+    accountInfo: any;
+    loading: vue.ShallowRef<boolean, boolean>;
+    error: vue.ShallowRef<unknown, unknown>;
+    refresh: () => Promise<any>;
+    stopWatching: () => Promise<void>;
+};
+
+export { useAccountInfo };
+export type { UseAccountInfoOptions };