@vue-solana/vue 1.2.0 → 2.1.0

package/dist/shared/vue.B8ub540p.mjs

@@ -0,0 +1,109 @@
+import { normalizeSolanaError } from '@vue-solana/core/errors';
+import { shallowRef, watch, isRef, onMounted, getCurrentInstance, onScopeDispose, computed } from 'vue';
+
+function useSubscription(source, options = {}) {
+  const data = shallowRef(void 0);
+  const error = shallowRef(null);
+  const status = shallowRef("loading");
+  const disposables = [];
+  let connectionCount = 0;
+  let disposed = false;
+  let activeSource;
+  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") {
+      data.value = void 0;
+      error.value = null;
+      status.value = "loading";
+    }
+  }
+  function openConnection(store) {
+    activeStore = store;
+    connectionCount += 1;
+    const connection = connectionCount;
+    const callerSignal = options.getAbortSignal?.(connection);
+    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;
+    }
+    activeSource = void 0;
+  }
+  function connectCurrent() {
+    if (disposed) {
+      return;
+    }
+    const resolved = isRef(source) ? source.value : source;
+    if (resolved === null || resolved === void 0) {
+      disconnect();
+      data.value = void 0;
+      error.value = null;
+      status.value = "disabled";
+      return;
+    }
+    if (activeSource === resolved && activeStore) {
+      openConnection(activeStore);
+      return;
+    }
+    disconnect();
+    activeSource = resolved;
+    openConnection(resolved.reactiveStore());
+  }
+  watch(
+    () => isRef(source) ? source.value : source,
+    () => {
+      connectCurrent();
+    },
+    { flush: "sync" }
+  );
+  onMounted(() => {
+    connectCurrent();
+  });
+  if (!getCurrentInstance()) {
+    connectCurrent();
+  }
+  onScopeDispose(() => {
+    disposed = true;
+    disconnect();
+  });
+  return {
+    data: computed(() => data.value),
+    error: computed(() => error.value),
+    reconnect: () => {
+      connectCurrent();
+    },
+    status: computed(() => status.value)
+  };
+}
+
+export { useSubscription as u };

package/dist/shared/{vue.D0ycWj82.mjs → vue.BD6Gm1nl.mjs}

@@ -1,13 +1,13 @@
-import { parsePublicKey } from '@vue-solana/core/address';
-import { normalizeSolanaError } from '@vue-solana/core/errors';
 import { getTokenBalance } from '@vue-solana/core/token-accounts';
+import { normalizeSolanaError } from '@vue-solana/core/errors';
+import { parseAddress } from '@vue-solana/core/address';
 import { shallowRef, onMounted, watch, toValue } from 'vue';
-import { u as useConnection } from './vue.DiNn3XHm.mjs';
-import { t as tryUseSolana } from './vue.CYKT65tB.mjs';
+import { u as useConnection } from './vue.CpkwC8Th.mjs';
+import { t as tryUseSolana } from './vue.CQh3AUE8.mjs';
 
-function useTokenBalance(mint, owner) {
+function useTokenBalance(mint, owner, commitment) {
   const solana = tryUseSolana();
-  const connection = solana?.connection ?? useConnection();
+  const client = solana?.client ?? useConnection();
   const balance = shallowRef(null);
   const decimals = shallowRef(null);
   const loading = shallowRef(false);
@@ -27,15 +27,15 @@ function useTokenBalance(mint, owner) {
     loading.value = true;
     error.value = null;
     try {
-      const mintKey = parsePublicKey(mintValue);
-      const ownerKey = parsePublicKey(ownerValue);
+      const mintKey = parseAddress(mintValue);
+      const ownerKey = parseAddress(ownerValue);
       if (!mintKey || !ownerKey) {
         balance.value = null;
         decimals.value = null;
         loading.value = false;
         return null;
       }
-      const nextBalance = await getTokenBalance(connection, mintKey, ownerKey);
+      const nextBalance = await getTokenBalance(client, mintKey, ownerKey, commitment);
       if (requestId === refreshId) {
         balance.value = nextBalance?.amount ?? null;
         decimals.value = nextBalance?.decimals ?? null;

package/dist/shared/{vue.BEesxsrA.cjs → vue.BGxz4dru.cjs}

@@ -3,7 +3,7 @@
 const errors = require('@vue-solana/core/errors');
 const wallet = require('@vue-solana/core/wallet');
 const vue = require('vue');
-const useSolana = require('./vue.BE4KHksm.cjs');
+const useSolana = require('./vue.DE3emjSF.cjs');
 
 function useWallet() {
   const solana = useSolana.useSolana();
@@ -11,6 +11,9 @@ function useWallet() {
   const connecting = vue.ref(false);
   const disconnecting = vue.ref(false);
   async function connect() {
+    if (connecting.value || wallet$1.value?.connecting) {
+      return;
+    }
     const activeWallet = wallet$1.value;
     if (!activeWallet) {
       throw wallet.createNoWalletSelectedError();
@@ -20,9 +23,10 @@ function useWallet() {
       const connection = activeWallet.connect();
       vue.triggerRef(wallet$1);
       await connection;
+      wallet.assertWalletConnected(activeWallet);
       vue.triggerRef(wallet$1);
       console.info("[Vue Solana] Wallet connected", {
-        publicKey: activeWallet.publicKey?.toBase58() ?? null
+        publicKey: activeWallet.publicKey ?? null
       });
     } catch (error) {
       const normalizedError = errors.normalizeSolanaError(error, "RPC_FAILURE");
@@ -38,7 +42,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.DDxhSi72.mjs → vue.BINkrA8h.mjs}

@@ -1,12 +1,12 @@
-import { parsePublicKey } from '@vue-solana/core/address';
+import { parseAddress } from '@vue-solana/core/address';
 import { normalizeSolanaError } from '@vue-solana/core/errors';
 import { shallowRef, onMounted, watch, toValue } from 'vue';
-import { u as useConnection } from './vue.DiNn3XHm.mjs';
-import { t as tryUseSolana } from './vue.CYKT65tB.mjs';
+import { u as useConnection } from './vue.CpkwC8Th.mjs';
+import { t as tryUseSolana } from './vue.CQh3AUE8.mjs';
 
 function useBalance(address, commitment) {
   const solana = tryUseSolana();
-  const connection = solana?.connection ?? useConnection();
+  const client = solana?.client ?? useConnection();
   const balance = shallowRef(null);
   const loading = shallowRef(false);
   const error = shallowRef(null);
@@ -23,16 +23,16 @@ function useBalance(address, commitment) {
     loading.value = true;
     error.value = null;
     try {
-      const publicKey = parsePublicKey(value);
-      if (!publicKey) {
+      const parsedAddress = parseAddress(value);
+      if (!parsedAddress) {
         balance.value = null;
         return null;
       }
-      const nextBalance = await connection.getBalance(publicKey, commitment);
+      const { value: lamports } = await client.rpc.getBalance(parsedAddress, commitment ? { commitment } : void 0).send();
       if (requestId === refreshId) {
-        balance.value = nextBalance;
+        balance.value = Number(lamports);
       }
-      return nextBalance;
+      return Number(lamports);
     } catch (cause) {
       const normalizedError = normalizeSolanaError(cause, "RPC_FAILURE");
       if (requestId === refreshId) {

package/dist/shared/{vue.COPnX5fq.cjs → vue.BIxphCAq.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-const useSolana = require('./vue.BE4KHksm.cjs');
+const useSolana = require('./vue.DE3emjSF.cjs');
 
 function useSolanaClient() {
   const { client } = useSolana.useSolana();

package/dist/shared/{vue.CKTUFwSI.mjs → vue.BOpgWr43.mjs}

@@ -1,13 +1,13 @@
-import { parsePublicKey } from '@vue-solana/core/address';
-import { normalizeSolanaError } from '@vue-solana/core/errors';
 import { getTokenAccountsByOwner } from '@vue-solana/core/token-accounts';
+import { normalizeSolanaError } from '@vue-solana/core/errors';
+import { parseAddress } from '@vue-solana/core/address';
 import { shallowRef, onMounted, watch, toValue } from 'vue';
-import { u as useConnection } from './vue.DiNn3XHm.mjs';
-import { t as tryUseSolana } from './vue.CYKT65tB.mjs';
+import { u as useConnection } from './vue.CpkwC8Th.mjs';
+import { t as tryUseSolana } from './vue.CQh3AUE8.mjs';
 
 function useTokenAccounts(owner, options) {
   const solana = tryUseSolana();
-  const connection = solana?.connection ?? useConnection();
+  const client = solana?.client ?? useConnection();
   const tokenAccounts = shallowRef([]);
   const loading = shallowRef(false);
   const error = shallowRef(null);
@@ -24,17 +24,16 @@ function useTokenAccounts(owner, options) {
     loading.value = true;
     error.value = null;
     try {
-      const publicKey = parsePublicKey(value);
-      if (!publicKey) {
+      const parsedAddress = parseAddress(value);
+      if (!parsedAddress) {
         tokenAccounts.value = [];
         loading.value = false;
         return [];
       }
-      const opts = {
+      const nextAccounts = await getTokenAccountsByOwner(client, parsedAddress, {
         commitment: options?.commitment,
         programId: options?.programId
-      };
-      const nextAccounts = await getTokenAccountsByOwner(connection, publicKey, opts);
+      });
       if (requestId === refreshId) {
         tokenAccounts.value = nextAccounts;
       }

package/dist/shared/vue.BQRpjwKl.mjs

@@ -0,0 +1,80 @@
+import { normalizeSolanaError } from '@vue-solana/core/errors';
+import { shallowRef, onMounted, watch, toValue } from 'vue';
+import { parseAddress } from '@vue-solana/core/address';
+import { u as useConnection } from './vue.CpkwC8Th.mjs';
+import { t as tryUseSolana } from './vue.CQh3AUE8.mjs';
+import { d as decodeBase64 } from './vue.Bfu1dCKe.mjs';
+
+function useAccountInfo(address, options = {}) {
+  const solana = tryUseSolana();
+  const client = solana?.client ?? useConnection();
+  const accountInfo = shallowRef(null);
+  const loading = shallowRef(false);
+  const error = shallowRef(null);
+  let refreshId = 0;
+  async function refresh() {
+    const requestId = ++refreshId;
+    const value = toValue(address);
+    if (!value || !solana) {
+      accountInfo.value = null;
+      loading.value = false;
+      error.value = null;
+      return null;
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const parsedAddress = 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 = normalizeSolanaError(cause, "RPC_FAILURE");
+      if (requestId === refreshId) {
+        accountInfo.value = null;
+        error.value = normalizedError;
+      }
+      throw normalizedError;
+    } finally {
+      if (requestId === refreshId) {
+        loading.value = false;
+      }
+    }
+  }
+  onMounted(() => {
+    void refresh().catch(() => void 0);
+  });
+  watch(
+    () => toValue(address),
+    () => {
+      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(account.data[0])
+  };
+}
+
+export { useAccountInfo as u };

package/dist/shared/vue.BVaMoz9y.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+const useSolanaClient = require('./vue.BIxphCAq.cjs');
+
+function useConnection() {
+  return useSolanaClient.useSolanaClient().client;
+}
+
+exports.useConnection = useConnection;

package/dist/shared/vue.BVj9lWBK.cjs

@@ -0,0 +1,111 @@
+'use strict';
+
+const errors = require('@vue-solana/core/errors');
+const vue = require('vue');
+
+function useSubscription(source, options = {}) {
+  const data = vue.shallowRef(void 0);
+  const error = vue.shallowRef(null);
+  const status = vue.shallowRef("loading");
+  const disposables = [];
+  let connectionCount = 0;
+  let disposed = false;
+  let activeSource;
+  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 = errors.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") {
+      data.value = void 0;
+      error.value = null;
+      status.value = "loading";
+    }
+  }
+  function openConnection(store) {
+    activeStore = store;
+    connectionCount += 1;
+    const connection = connectionCount;
+    const callerSignal = options.getAbortSignal?.(connection);
+    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;
+    }
+    activeSource = void 0;
+  }
+  function connectCurrent() {
+    if (disposed) {
+      return;
+    }
+    const resolved = vue.isRef(source) ? source.value : source;
+    if (resolved === null || resolved === void 0) {
+      disconnect();
+      data.value = void 0;
+      error.value = null;
+      status.value = "disabled";
+      return;
+    }
+    if (activeSource === resolved && activeStore) {
+      openConnection(activeStore);
+      return;
+    }
+    disconnect();
+    activeSource = resolved;
+    openConnection(resolved.reactiveStore());
+  }
+  vue.watch(
+    () => vue.isRef(source) ? source.value : source,
+    () => {
+      connectCurrent();
+    },
+    { flush: "sync" }
+  );
+  vue.onMounted(() => {
+    connectCurrent();
+  });
+  if (!vue.getCurrentInstance()) {
+    connectCurrent();
+  }
+  vue.onScopeDispose(() => {
+    disposed = true;
+    disconnect();
+  });
+  return {
+    data: vue.computed(() => data.value),
+    error: vue.computed(() => error.value),
+    reconnect: () => {
+      connectCurrent();
+    },
+    status: vue.computed(() => status.value)
+  };
+}
+
+exports.useSubscription = useSubscription;

package/dist/shared/vue.BY0qpgYr.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+const useSolanaClient = require('./vue.BIxphCAq.cjs');
+
+class MissingClientCapabilityError extends Error {
+  /** Name of the hook that requested the capability, e.g. `usePayer`. */
+  hookName;
+  /** Human guidance for installing the capability on the client. */
+  providerHint;
+  /** The missing capability name(s). */
+  capabilities;
+  constructor(hookName, capabilities, providerHint) {
+    super(
+      `${hookName} requires the ${capabilities.map((capability) => `\`${capability}\``).join(" and ")} capabilit${capabilities.length === 1 ? "y" : "ies"} on the Solana client, but none ${capabilities.length === 1 ? "was" : "were"} found. ` + providerHint
+    );
+    this.name = "MissingClientCapabilityError";
+    this.hookName = hookName;
+    this.capabilities = capabilities;
+    this.providerHint = providerHint;
+  }
+}
+function useClientCapability(capability, options = {}) {
+  const capabilities = Array.isArray(capability) ? [...capability] : [capability];
+  const hookName = options.hookName ?? "useClientCapability";
+  const providerHint = options.providerHint ?? "Install it by adding the corresponding @solana/kit plugin with `createClient().use(...)`.";
+  const { client } = useSolanaClient.useSolanaClient();
+  for (const name of capabilities) {
+    if (typeof client[name] === "undefined") {
+      throw new MissingClientCapabilityError(hookName, [name], providerHint);
+    }
+  }
+}
+
+exports.MissingClientCapabilityError = MissingClientCapabilityError;
+exports.useClientCapability = useClientCapability;

package/dist/shared/vue.Bfu1dCKe.mjs

@@ -0,0 +1,10 @@
+function decodeBase64(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+
+export { decodeBase64 as d };

package/dist/shared/vue.Bk5xjlUx.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+const action = require('@vue-solana/core/action');
+const errors = require('@vue-solana/core/errors');
+const timeout = require('@vue-solana/core/timeout');
+const vue = require('vue');
+
+const DEFAULT_TIMEOUT_MESSAGE = "Transaction did not return a result before timing out.";
+function useTransaction(handler, options = {}) {
+  const signature = vue.shallowRef(null);
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  const store = action.createSolanaActionStore(async (_signal, ...args) => {
+    const attempt = timeout.withSolanaTimeout(
+      handler(...args),
+      options.timeoutMs,
+      options.timeoutMessage ?? DEFAULT_TIMEOUT_MESSAGE
+    );
+    attempt.catch(() => void 0);
+    return attempt;
+  });
+  const unsubscribe = store.subscribe(() => {
+    const state = store.getState();
+    if (state.status === "running") {
+      loading.value = true;
+    } else if (state.status === "success") {
+      signature.value = state.data;
+      loading.value = false;
+      error.value = null;
+    } else if (state.status === "error") {
+      error.value = errors.normalizeSolanaError(state.error, "RPC_FAILURE");
+      loading.value = false;
+    }
+  });
+  if (vue.getCurrentScope()) {
+    vue.onScopeDispose(() => {
+      unsubscribe();
+      store.reset();
+    });
+  }
+  async function execute(...args) {
+    loading.value = true;
+    error.value = null;
+    try {
+      return await store.dispatchAsync(...args);
+    } catch (cause) {
+      if (action.isSolanaActionAborted(cause)) {
+        throw cause;
+      }
+      throw errors.normalizeSolanaError(cause, "RPC_FAILURE");
+    }
+  }
+  return {
+    signature,
+    loading,
+    error,
+    execute
+  };
+}
+
+exports.useTransaction = useTransaction;

package/dist/shared/{vue.BtUKvuQw.mjs → vue.BsGwt78R.mjs}

@@ -1,5 +1,5 @@
 import { computed } from 'vue';
-import { u as useSolana } from './vue.CYKT65tB.mjs';
+import { u as useSolana } from './vue.CQh3AUE8.mjs';
 
 function useRpc() {
   const solana = useSolana();
@@ -11,7 +11,7 @@ function useRpc() {
     error: solana.error,
     latestBlockhash: solana.latestBlockhash,
     checkConnection: solana.checkConnection,
-    connection: solana.connection
+    client: solana.client
   };
 }
 

package/dist/shared/{vue.BbX3ePDY.cjs → vue.Bwd1sGAM.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 useTokenAccounts(owner, options) {
   const solana = useSolana.tryUseSolana();
-  const connection = solana?.connection ?? useConnection.useConnection();
+  const client = solana?.client ?? useConnection.useConnection();
   const tokenAccounts$1 = vue.shallowRef([]);
   const loading = vue.shallowRef(false);
   const error = vue.shallowRef(null);
@@ -26,17 +26,16 @@ function useTokenAccounts(owner, options) {
     loading.value = true;
     error.value = null;
     try {
-      const publicKey = address.parsePublicKey(value);
-      if (!publicKey) {
+      const parsedAddress = address.parseAddress(value);
+      if (!parsedAddress) {
         tokenAccounts$1.value = [];
         loading.value = false;
         return [];
       }
-      const opts = {
+      const nextAccounts = await tokenAccounts.getTokenAccountsByOwner(client, parsedAddress, {
         commitment: options?.commitment,
         programId: options?.programId
-      };
-      const nextAccounts = await tokenAccounts.getTokenAccountsByOwner(connection, publicKey, opts);
+      });
       if (requestId === refreshId) {
         tokenAccounts$1.value = nextAccounts;
       }