@vue-solana/vue 1.2.0 → 2.1.0

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.CPjEwHSg.mjs → vue.C13umiQi.mjs}

@@ -1,12 +1,13 @@
-import { parsePublicKey } from '@vue-solana/core/address';
 import { normalizeSolanaError } from '@vue-solana/core/errors';
 import { shallowRef, onMounted, onUnmounted, watch, toValue } from 'vue';
-import { u as useConnection } from './vue.DiNn3XHm.mjs';
-import { t as tryUseSolana } from './vue.CYKT65tB.mjs';
+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 useProgramAccounts(programId, options = {}) {
   const solana = tryUseSolana();
-  const connection = solana?.connection ?? useConnection();
+  const client = solana?.client ?? useConnection();
   const accounts = shallowRef([]);
   const loading = shallowRef(false);
   const error = shallowRef(null);
@@ -23,16 +24,27 @@ function useProgramAccounts(programId, options = {}) {
     loading.value = true;
     error.value = null;
     try {
-      const publicKey = parsePublicKey(value);
-      if (!publicKey) {
+      const parsedAddress = parseAddress(value);
+      if (!parsedAddress) {
         accounts.value = [];
         return [];
       }
-      const nextAccounts = await connection.getProgramAccounts(publicKey, {
+      const { value: response } = await client.rpc.getProgramAccounts(parsedAddress, {
+        encoding: "base64",
         commitment: options.commitment,
         dataSlice: options.dataSlice,
         filters: options.filters
-      });
+      }).send();
+      const nextAccounts = response.map(({ pubkey, account }) => ({
+        pubkey,
+        account: {
+          executable: account.executable,
+          lamports: Number(account.lamports),
+          owner: account.owner,
+          space: Number(account.space),
+          data: decodeBase64(account.data[0])
+        }
+      }));
       if (requestId === refreshId) {
         accounts.value = nextAccounts;
       }

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.Bhdhmz8d.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.DCgByzxg.cjs');
-const useSolana = require('./vue.BE4KHksm.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; }
 
@@ -12,16 +12,13 @@ const bs58__default = /*#__PURE__*/_interopDefaultCompat(bs58);
 
 function useSignatureStatus(signature, options = {}) {
   const solana = useSolana.tryUseSolana();
-  const connection = solana?.connection ?? useConnection.useConnection();
+  const client = solana?.client ?? 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);
@@ -35,10 +32,11 @@ function useSignatureStatus(signature, options = {}) {
     error.value = null;
     try {
       const validSignature = parseTransactionSignature(value);
-      const response = await connection.getSignatureStatuses([validSignature], {
+      const response = await client.rpc.getSignatureStatuses([validSignature], {
         searchTransactionHistory: options.searchTransactionHistory
-      });
-      const nextStatus = response.value[0] ?? null;
+      }).send();
+      const nextRawStatus = response.value[0] ?? null;
+      const nextStatus = nextRawStatus ? normalizeSignatureStatus(nextRawStatus) : null;
       if (requestId === refreshId) {
         status.value = nextStatus;
       }
@@ -87,80 +85,19 @@ function useSignatureStatus(signature, options = {}) {
       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 = errors.normalizeSolanaError(cause, "RPC_FAILURE");
-    }
-  }
-  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 = errors.normalizeSolanaError(cause, "RPC_FAILURE");
-      }
-    }
-  }
-  function resetIntervals() {
-    startPolling();
-    void startSubscription();
-  }
   vue.onMounted(() => {
     void refresh().catch(() => void 0);
-    resetIntervals();
+    startPolling();
   });
   vue.onUnmounted(() => {
     refreshId += 1;
     stopPolling();
-    void stopSubscription();
   });
   vue.watch(
     () => vue.toValue(signature),
     () => {
       void refresh().catch(() => void 0);
-      resetIntervals();
+      startPolling();
     }
   );
   return {
@@ -168,8 +105,7 @@ function useSignatureStatus(signature, options = {}) {
     loading,
     error,
     refresh,
-    stopPolling,
-    stopSubscription
+    stopPolling
   };
 }
 function parseTransactionSignature(signature) {
@@ -184,5 +120,13 @@ function parseTransactionSignature(signature) {
   }
   return signature;
 }
+function normalizeSignatureStatus(status) {
+  return {
+    slot: Number(status.slot),
+    confirmations: status.confirmations === null ? null : Number(status.confirmations),
+    err: status.err,
+    confirmationStatus: status.confirmationStatus
+  };
+}
 
 exports.useSignatureStatus = useSignatureStatus;

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.CYKT65tB.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() {
@@ -16,7 +13,6 @@ function getSsrContext() {
     cluster: "devnet",
     endpoint: "",
     wsEndpoint: "",
-    connection: createUnavailableProxy(),
     client: createUnavailableProxy(),
     wallet: shallowRef(null),
     status: ref("idle"),
@@ -46,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.DzKfcfpX.cjs → vue.CWZSMVnB.cjs}

@@ -5,13 +5,13 @@ 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.DCgByzxg.cjs');
-const useWallet = require('./vue.BEesxsrA.cjs');
-const useTransactionConfirmation = require('./vue.ByUemLSf.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() {
-  const connection = useConnection.useConnection();
+  const client = useConnection.useConnection();
   const { wallet: wallet$1 } = useWallet.useWallet();
   const signature = vue.ref(null);
   const confirmation = vue.ref(null);
@@ -37,7 +37,7 @@ function useSignAndSendTransaction() {
     }
     try {
       const nextSignature = await timeout.withSolanaTimeout(
-        transaction.signAndSendTransaction(connection, activeWallet, transaction$1, transactionOptions),
+        transaction.signAndSendTransaction(client, activeWallet, transaction$1, transactionOptions),
         SIGN_AND_SEND_TIMEOUT_MS,
         "Wallet transaction did not return a result. Check your wallet or explorer for the final status."
       );
@@ -49,7 +49,7 @@ function useSignAndSendTransaction() {
         return nextSignature;
       }
       const nextConfirmation = await transaction.confirmTransactionSignature(
-        connection,
+        client,
         nextSignature,
         confirmationOptions
       );

package/dist/shared/{vue.B12Pt1PQ.mjs → vue.CXB4NEMA.mjs}

@@ -1,21 +1,18 @@
 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.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 useSignatureStatus(signature, options = {}) {
   const solana = tryUseSolana();
-  const connection = solana?.connection ?? useConnection();
+  const client = solana?.client ?? 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);
@@ -29,10 +26,11 @@ function useSignatureStatus(signature, options = {}) {
     error.value = null;
     try {
       const validSignature = parseTransactionSignature(value);
-      const response = await connection.getSignatureStatuses([validSignature], {
+      const response = await client.rpc.getSignatureStatuses([validSignature], {
         searchTransactionHistory: options.searchTransactionHistory
-      });
-      const nextStatus = response.value[0] ?? null;
+      }).send();
+      const nextRawStatus = response.value[0] ?? null;
+      const nextStatus = nextRawStatus ? normalizeSignatureStatus(nextRawStatus) : null;
       if (requestId === refreshId) {
         status.value = nextStatus;
       }
@@ -81,80 +79,19 @@ function useSignatureStatus(signature, options = {}) {
       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 = normalizeSolanaError(cause, "RPC_FAILURE");
-    }
-  }
-  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 = normalizeSolanaError(cause, "RPC_FAILURE");
-      }
-    }
-  }
-  function resetIntervals() {
-    startPolling();
-    void startSubscription();
-  }
   onMounted(() => {
     void refresh().catch(() => void 0);
-    resetIntervals();
+    startPolling();
   });
   onUnmounted(() => {
     refreshId += 1;
     stopPolling();
-    void stopSubscription();
   });
   watch(
     () => toValue(signature),
     () => {
       void refresh().catch(() => void 0);
-      resetIntervals();
+      startPolling();
     }
   );
   return {
@@ -162,8 +99,7 @@ function useSignatureStatus(signature, options = {}) {
     loading,
     error,
     refresh,
-    stopPolling,
-    stopSubscription
+    stopPolling
   };
 }
 function parseTransactionSignature(signature) {
@@ -178,5 +114,13 @@ function parseTransactionSignature(signature) {
   }
   return signature;
 }
+function normalizeSignatureStatus(status) {
+  return {
+    slot: Number(status.slot),
+    confirmations: status.confirmations === null ? null : Number(status.confirmations),
+    err: status.err,
+    confirmationStatus: status.confirmationStatus
+  };
+}
 
 export { useSignatureStatus as u };

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

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