@vue-solana/vue 2.0.0 → 2.2.0

package/dist/shared/vue.BSfiHqwj.mjs

@@ -0,0 +1,34 @@
+import { u as useAction } from './vue.DYk0Xfr3.mjs';
+import { u as useClientCapability } from './vue.B8LptjZP.mjs';
+import { u as useSolanaClient } from './vue.Mxc8w6Qk.mjs';
+
+function toReadableAirdropError(error) {
+  if (error instanceof Error) {
+    const httpStatus = error.context?.statusCode;
+    const isThrottled = httpStatus === 429 || error.message.startsWith("JSON-RPC error: Internal JSON-RPC error (Internal error)");
+    if (!isThrottled) {
+      throw error;
+    }
+    throw new Error(
+      `${error.message} This likely means the network's airdrop faucet is rate-limited or out of test SOL. Retry later, use https://faucet.solana.com, or point the client at a local validator.`,
+      { cause: error }
+    );
+  }
+  throw new Error(`Airdrop failed: ${String(error)}`);
+}
+function useAirdrop() {
+  useClientCapability("airdrop", {
+    hookName: "useAirdrop",
+    providerHint: "Install it by adding the airdrop capability with `createClient().use(solanaRpcConnection({ ... })).use(rpcAirdrop())` from `@solana/kit-plugin-rpc`."
+  });
+  const { client } = useSolanaClient();
+  return useAction((abortSignal, address, amount) => {
+    const airdrop = client.airdrop;
+    if (!airdrop) {
+      throw new Error("useAirdrop requires the `airdrop` capability on the Solana client.");
+    }
+    return airdrop(address, amount, abortSignal).catch(toReadableAirdropError);
+  });
+}
+
+export { useAirdrop as u };

package/dist/shared/{vue.CZwftA0L.cjs → vue.BVaMoz9y.cjs}

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

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.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.3VLZmw05.mjs → vue.BsGwt78R.mjs}

@@ -1,5 +1,5 @@
 import { computed } from 'vue';
-import { u as useSolana } from './vue.CnUlZSe8.mjs';
+import { u as useSolana } from './vue.CQh3AUE8.mjs';
 
 function useRpc() {
   const solana = useSolana();

package/dist/shared/{vue.B_LRH8SM.cjs → vue.Bwd1sGAM.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 useTokenAccounts(owner, options) {
   const solana = useSolana.tryUseSolana();

package/dist/shared/vue.ByxbBC3y.mjs

@@ -0,0 +1,57 @@
+import { normalizeSolanaError } from '@vue-solana/core/errors';
+import { createNoWalletSelectedError, assertWalletCanSignIn } from '@vue-solana/core/wallet';
+import { shallowRef, ref } from 'vue';
+import { u as useWallet } from './vue.D218Ow7t.mjs';
+
+function useSignIn() {
+  const { wallet } = useWallet();
+  const signInResult = shallowRef(null);
+  const status = ref("idle");
+  const loading = ref(false);
+  const error = ref(null);
+  let executionId = 0;
+  async function signIn(input) {
+    const currentExecutionId = ++executionId;
+    status.value = "signing-in";
+    loading.value = true;
+    error.value = null;
+    signInResult.value = null;
+    const activeWallet = wallet.value;
+    if (!activeWallet) {
+      const normalizedError = createNoWalletSelectedError();
+      error.value = normalizedError;
+      status.value = "error";
+      loading.value = false;
+      throw normalizedError;
+    }
+    try {
+      assertWalletCanSignIn(activeWallet);
+      const result = await activeWallet.signIn(input);
+      if (currentExecutionId === executionId) {
+        signInResult.value = result;
+        status.value = "signed-in";
+      }
+      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 {
+    signInResult,
+    status,
+    loading,
+    error,
+    signIn
+  };
+}
+
+export { useSignIn as u };

package/dist/shared/{vue.BbMPRDeO.mjs → vue.C13umiQi.mjs}

@@ -1,8 +1,8 @@
 import { normalizeSolanaError } from '@vue-solana/core/errors';
 import { shallowRef, onMounted, onUnmounted, watch, toValue } from 'vue';
 import { parseAddress } from '@vue-solana/core/address';
-import { u as useConnection } from './vue.ChujsB0B.mjs';
-import { t as tryUseSolana } from './vue.CnUlZSe8.mjs';
+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 useProgramAccounts(programId, options = {}) {

package/dist/shared/vue.C5FVoEZT.mjs

@@ -0,0 +1,99 @@
+import { normalizeSolanaError } from '@vue-solana/core/errors';
+import { shallowRef, ref } from 'vue';
+import { u as useClientCapability } from './vue.B8LptjZP.mjs';
+import { u as useSolanaClient } from './vue.Mxc8w6Qk.mjs';
+
+function usePlanTransaction() {
+  useClientCapability(["planTransaction"], {
+    hookName: "usePlanTransaction",
+    providerHint: "Install a planner plugin, e.g. `createClient().use(rpcTransactionPlanner())` from `@solana/kit-plugin-rpc`."
+  });
+  const { client } = useSolanaClient();
+  const transactionMessage = shallowRef(null);
+  const status = ref("idle");
+  const loading = ref(false);
+  const error = ref(null);
+  let executionId = 0;
+  async function execute(input, config) {
+    const currentExecutionId = ++executionId;
+    const planner = client;
+    status.value = "planning";
+    loading.value = true;
+    error.value = null;
+    transactionMessage.value = null;
+    try {
+      const message = await planner.planTransaction(input, config);
+      if (currentExecutionId === executionId) {
+        transactionMessage.value = message;
+        status.value = "planned";
+      }
+      return message;
+    } 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 {
+    transactionMessage,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+function usePlanTransactions() {
+  useClientCapability(["planTransactions"], {
+    hookName: "usePlanTransactions",
+    providerHint: "Install a planner plugin, e.g. `createClient().use(rpcTransactionPlanner())` from `@solana/kit-plugin-rpc`."
+  });
+  const { client } = useSolanaClient();
+  const transactionPlan = shallowRef(null);
+  const status = ref("idle");
+  const loading = ref(false);
+  const error = ref(null);
+  let executionId = 0;
+  async function execute(input, config) {
+    const currentExecutionId = ++executionId;
+    const planner = client;
+    status.value = "planning";
+    loading.value = true;
+    error.value = null;
+    transactionPlan.value = null;
+    try {
+      const plan = await planner.planTransactions(input, config);
+      if (currentExecutionId === executionId) {
+        transactionPlan.value = plan;
+        status.value = "planned";
+      }
+      return plan;
+    } 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 {
+    transactionPlan,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+
+export { usePlanTransactions as a, usePlanTransaction as u };

package/dist/shared/vue.CATOh_9G.mjs

@@ -0,0 +1,42 @@
+import { shallowRef, onScopeDispose } from 'vue';
+import { u as useClientCapability } from './vue.B8LptjZP.mjs';
+import { u as useSolanaClient } from './vue.Mxc8w6Qk.mjs';
+
+function useIdentity() {
+  useClientCapability(["identity"], {
+    hookName: "useIdentity",
+    providerHint: "Install a signer plugin, e.g. `createClient().use(generatedIdentity())` from `@solana/kit-plugin-signer`."
+  });
+  const { client } = useSolanaClient();
+  const identity = shallowRef(
+    client.identity
+  );
+  const subscribable = client;
+  if (typeof subscribable.subscribeToIdentity === "function") {
+    const unsubscribe = subscribable.subscribeToIdentity(() => {
+      identity.value = client.identity;
+    });
+    onScopeDispose(unsubscribe);
+  }
+  return identity;
+}
+function usePayer() {
+  useClientCapability(["payer"], {
+    hookName: "usePayer",
+    providerHint: "Install a signer plugin, e.g. `createClient().use(generatedPayer())` from `@solana/kit-plugin-signer`."
+  });
+  const { client } = useSolanaClient();
+  const payer = shallowRef(
+    client.payer
+  );
+  const subscribable = client;
+  if (typeof subscribable.subscribeToPayer === "function") {
+    const unsubscribe = subscribable.subscribeToPayer(() => {
+      payer.value = client.payer;
+    });
+    onScopeDispose(unsubscribe);
+  }
+  return payer;
+}
+
+export { usePayer as a, useIdentity as u };

package/dist/shared/{vue.XQFqlMId.cjs → vue.CIs8QhCw.cjs}

@@ -3,8 +3,8 @@
 const errors = require('@vue-solana/core/errors');
 const bs58 = require('bs58');
 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 _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 

package/dist/shared/vue.CMohL_Cz.mjs

@@ -0,0 +1,58 @@
+import { normalizeSolanaError } from '@vue-solana/core/errors';
+import { createNoWalletSelectedError, assertWalletCanSignTransactions } from '@vue-solana/core/wallet';
+import { shallowRef, ref } from 'vue';
+import { u as useWallet } from './vue.D218Ow7t.mjs';
+
+function useSignTransactions() {
+  const { wallet } = useWallet();
+  const signedTransactions = shallowRef(null);
+  const status = ref("idle");
+  const loading = ref(false);
+  const error = 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.value;
+    if (!activeWallet) {
+      const normalizedError = createNoWalletSelectedError();
+      error.value = normalizedError;
+      status.value = "error";
+      loading.value = false;
+      throw normalizedError;
+    }
+    try {
+      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 = 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
+  };
+}
+
+export { useSignTransactions as u };

package/dist/shared/{vue.CnUlZSe8.mjs → vue.CQh3AUE8.mjs}

@@ -1,8 +1,5 @@
 import { inject, shallowRef, ref } from 'vue';
-
-const solanaInjectionKey = Symbol.for(
-  "vue-solana:context"
-);
+import { s as solanaInjectionKey } from './vue.D_P5SqqD.mjs';
 
 let ssrContext;
 function tryUseSolana() {
@@ -45,4 +42,4 @@ function createUnavailableProxy() {
   );
 }
 
-export { solanaInjectionKey as s, tryUseSolana as t, useSolana as u };
+export { tryUseSolana as t, useSolana as u };

package/dist/shared/vue.CTqPbvz3.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+const useAction = require('./vue.CoaIWGPT.cjs');
+const useClientCapability = require('./vue.BY0qpgYr.cjs');
+const useSolanaClient = require('./vue.BIxphCAq.cjs');
+
+function toReadableAirdropError(error) {
+  if (error instanceof Error) {
+    const httpStatus = error.context?.statusCode;
+    const isThrottled = httpStatus === 429 || error.message.startsWith("JSON-RPC error: Internal JSON-RPC error (Internal error)");
+    if (!isThrottled) {
+      throw error;
+    }
+    throw new Error(
+      `${error.message} This likely means the network's airdrop faucet is rate-limited or out of test SOL. Retry later, use https://faucet.solana.com, or point the client at a local validator.`,
+      { cause: error }
+    );
+  }
+  throw new Error(`Airdrop failed: ${String(error)}`);
+}
+function useAirdrop() {
+  useClientCapability.useClientCapability("airdrop", {
+    hookName: "useAirdrop",
+    providerHint: "Install it by adding the airdrop capability with `createClient().use(solanaRpcConnection({ ... })).use(rpcAirdrop())` from `@solana/kit-plugin-rpc`."
+  });
+  const { client } = useSolanaClient.useSolanaClient();
+  return useAction.useAction((abortSignal, address, amount) => {
+    const airdrop = client.airdrop;
+    if (!airdrop) {
+      throw new Error("useAirdrop requires the `airdrop` capability on the Solana client.");
+    }
+    return airdrop(address, amount, abortSignal).catch(toReadableAirdropError);
+  });
+}
+
+exports.useAirdrop = useAirdrop;

package/dist/shared/{vue.CSJSK0Nq.cjs → vue.CWZSMVnB.cjs}

@@ -5,9 +5,9 @@ const timeout = require('@vue-solana/core/timeout');
 const transaction = require('@vue-solana/core/transaction');
 const wallet = require('@vue-solana/core/wallet');
 const vue = require('vue');
-const useConnection = require('./vue.CZwftA0L.cjs');
-const useWallet = require('./vue.BAlo-tIh.cjs');
-const useTransactionConfirmation = require('./vue.C32ozdA1.cjs');
+const useConnection = require('./vue.BVaMoz9y.cjs');
+const useWallet = require('./vue.BGxz4dru.cjs');
+const useTransactionConfirmation = require('./vue.Sbbm9JSu.cjs');
 
 const SIGN_AND_SEND_TIMEOUT_MS = 12e4;
 function useSignAndSendTransaction() {

package/dist/shared/{vue.DL-yMCNc.mjs → vue.CXB4NEMA.mjs}

@@ -1,8 +1,8 @@
 import { normalizeSolanaError, createSolanaError } from '@vue-solana/core/errors';
 import bs58 from 'bs58';
 import { shallowRef, onMounted, onUnmounted, watch, toValue } from 'vue';
-import { u as useConnection } from './vue.ChujsB0B.mjs';
-import { t as tryUseSolana } from './vue.CnUlZSe8.mjs';
+import { u as useConnection } from './vue.CpkwC8Th.mjs';
+import { t as tryUseSolana } from './vue.CQh3AUE8.mjs';
 
 function useSignatureStatus(signature, options = {}) {
   const solana = tryUseSolana();

package/dist/shared/{vue.D7xFeC2m.mjs → vue.C_4qJDiF.mjs}

@@ -1,4 +1,4 @@
-import { u as useSolana } from './vue.CnUlZSe8.mjs';
+import { u as useSolana } from './vue.CQh3AUE8.mjs';
 
 function useWallets() {
   const solana = useSolana();