@vue-solana/vue 1.2.0 → 2.1.0

package/dist/shared/vue.DDbVk0Zh.cjs

@@ -0,0 +1,180 @@
+'use strict';
+
+const vue = require('vue');
+const injection = require('./vue.DEHxNvUX.cjs');
+
+const SELECTED_WALLET_ACCOUNT_STORAGE_KEY = "vue-solana:selected-wallet-account";
+function createLocalStorageSelectedWalletAccountStorage(storage = defaultLocalStorage()) {
+  return {
+    storeSelectedWallet(key) {
+      try {
+        storage?.setItem(SELECTED_WALLET_ACCOUNT_STORAGE_KEY, key);
+      } catch {
+      }
+    },
+    getSelectedWallet() {
+      try {
+        return storage?.getItem(SELECTED_WALLET_ACCOUNT_STORAGE_KEY) ?? null;
+      } catch {
+        return null;
+      }
+    },
+    deleteSelectedWallet() {
+      try {
+        storage?.removeItem(SELECTED_WALLET_ACCOUNT_STORAGE_KEY);
+      } catch {
+      }
+    }
+  };
+}
+function defaultLocalStorage() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+
+const selectedWalletAccountInjectionKey = Symbol.for("vue-solana:selected-wallet-account");
+function provideSelectedWalletAccount(options = {}) {
+  const context = createSelectedWalletAccountContext(options);
+  vue.provide(selectedWalletAccountInjectionKey, context);
+  return context;
+}
+function createSelectedWalletAccountContext(options = {}, solanaContextOverride) {
+  const solanaContext = solanaContextOverride ?? vue.inject(injection.solanaInjectionKey, null);
+  const stateSync = options.stateSync === void 0 ? defaultStateSync() : options.stateSync;
+  const selectedWalletAccount = vue.ref(null);
+  const walletsValue = () => solanaContext?.wallets.value ?? [];
+  let pendingKey = null;
+  let selectionGeneration = 0;
+  function findAccount(key) {
+    const separatorIndex = key.lastIndexOf(":");
+    const walletName = separatorIndex === -1 ? key : key.slice(0, separatorIndex);
+    const address = separatorIndex === -1 ? "" : key.slice(separatorIndex + 1);
+    const wallet = walletsValue().find((candidate) => candidate.name === walletName);
+    const account = wallet?.accounts.find((candidate) => candidate.address === address);
+    if (!wallet || !account) {
+      return null;
+    }
+    return { ...account, walletName: wallet.name };
+  }
+  function clearSelection() {
+    selectionGeneration += 1;
+    pendingKey = null;
+    selectedWalletAccount.value = null;
+  }
+  function applyExternalSelection(key) {
+    if (!key) {
+      clearSelection();
+      return;
+    }
+    const account = findAccount(key);
+    if (account) {
+      selectionGeneration += 1;
+      pendingKey = null;
+      selectedWalletAccount.value = account;
+      return;
+    }
+    pendingKey = key;
+  }
+  function restoreIfAvailable() {
+    if (!pendingKey || selectedWalletAccount.value) {
+      return;
+    }
+    const account = findAccount(pendingKey);
+    if (account) {
+      selectedWalletAccount.value = account;
+      pendingKey = null;
+    }
+  }
+  if (stateSync) {
+    const generation = selectionGeneration;
+    void Promise.resolve(stateSync.getSelectedWallet()).then((key) => {
+      if (generation !== selectionGeneration || !key || selectedWalletAccount.value) {
+        return;
+      }
+      pendingKey = key;
+      restoreIfAvailable();
+    }).catch(() => void 0);
+  }
+  if (solanaContext) {
+    vue.watch(
+      () => solanaContext.wallets.value,
+      () => restoreIfAvailable()
+    );
+  }
+  if (stateSync && typeof window !== "undefined") {
+    const onStorage = () => {
+      void Promise.resolve(stateSync.getSelectedWallet()).then((key) => applyExternalSelection(key)).catch(() => void 0);
+    };
+    window.addEventListener("storage", onStorage);
+    if (vue.getCurrentScope()) {
+      vue.onScopeDispose(() => window.removeEventListener("storage", onStorage));
+    }
+  }
+  const context = {
+    selectedWalletAccount,
+    setSelectedWalletAccount(account) {
+      selectionGeneration += 1;
+      selectedWalletAccount.value = account;
+      pendingKey = null;
+      if (!stateSync) {
+        return;
+      }
+      const persisted = account ? stateSync.storeSelectedWallet(`${account.walletName}:${account.address}`) : stateSync.deleteSelectedWallet();
+      void Promise.resolve(persisted).catch(() => void 0);
+    },
+    filteredWallets: vue.computed(() => {
+      const filter = options.filterWallet;
+      if (!filter) {
+        return walletsValue();
+      }
+      return walletsValue().map((wallet) => {
+        const accounts = wallet.accounts.filter((account) => filter(wallet.name, account));
+        return accounts.length === 0 ? null : { ...wallet, accounts };
+      }).filter((wallet) => wallet !== null);
+    })
+  };
+  return context;
+}
+function useSelectedWalletAccount() {
+  const context = vue.inject(selectedWalletAccountInjectionKey, null);
+  if (!context) {
+    throw new Error("useSelectedWalletAccount must be used inside a SelectedWalletAccountProvider");
+  }
+  return [context.selectedWalletAccount, context.setSelectedWalletAccount, context.filteredWallets];
+}
+function defaultStateSync() {
+  return createLocalStorageSelectedWalletAccountStorage();
+}
+
+const SelectedWalletAccountProvider = vue.defineComponent({
+  name: "SelectedWalletAccountProvider",
+  props: {
+    filterWallet: {
+      type: Function,
+      default: void 0
+    },
+    stateSync: {
+      type: [Object, null],
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    provideSelectedWalletAccount({
+      filterWallet: props.filterWallet,
+      stateSync: props.stateSync
+    });
+    return () => slots.default?.();
+  }
+});
+
+exports.SelectedWalletAccountProvider = SelectedWalletAccountProvider;
+exports.createSelectedWalletAccountContext = createSelectedWalletAccountContext;
+exports.provideSelectedWalletAccount = provideSelectedWalletAccount;
+exports.selectedWalletAccountInjectionKey = selectedWalletAccountInjectionKey;
+exports.useSelectedWalletAccount = useSelectedWalletAccount;

package/dist/shared/{vue.BE4KHksm.cjs → vue.DE3emjSF.cjs}

@@ -1,14 +1,11 @@
 'use strict';
 
 const vue = require('vue');
-
-const solanaInjectionKey = Symbol.for(
-  "vue-solana:context"
-);
+const injection = require('./vue.DEHxNvUX.cjs');
 
 let ssrContext;
 function tryUseSolana() {
-  return vue.inject(solanaInjectionKey, null);
+  return vue.inject(injection.solanaInjectionKey, null);
 }
 function useSolana() {
   return tryUseSolana() ?? getSsrContext();
@@ -18,7 +15,6 @@ function getSsrContext() {
     cluster: "devnet",
     endpoint: "",
     wsEndpoint: "",
-    connection: createUnavailableProxy(),
     client: createUnavailableProxy(),
     wallet: vue.shallowRef(null),
     status: vue.ref("idle"),
@@ -48,6 +44,5 @@ function createUnavailableProxy() {
   );
 }
 
-exports.solanaInjectionKey = solanaInjectionKey;
 exports.tryUseSolana = tryUseSolana;
 exports.useSolana = useSolana;

package/dist/shared/vue.DEHxNvUX.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+const solanaInjectionKey = Symbol.for(
+  "vue-solana:context"
+);
+
+exports.solanaInjectionKey = solanaInjectionKey;

package/dist/shared/vue.DFaMJLAQ.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+const errors = require('@vue-solana/core/errors');
+const wallet = require('@vue-solana/core/wallet');
+const vue = require('vue');
+const useWallet = require('./vue.BGxz4dru.cjs');
+
+function useSignTransactions() {
+  const { wallet: wallet$1 } = useWallet.useWallet();
+  const signedTransactions = 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) {
+    const currentExecutionId = ++executionId;
+    status.value = "signing";
+    loading.value = true;
+    error.value = null;
+    signedTransactions.value = null;
+    const activeWallet = wallet$1.value;
+    if (!activeWallet) {
+      const normalizedError = wallet.createNoWalletSelectedError();
+      error.value = normalizedError;
+      status.value = "error";
+      loading.value = false;
+      throw normalizedError;
+    }
+    try {
+      wallet.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 = errors.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
+  };
+}
+
+exports.useSignTransactions = useSignTransactions;

package/dist/shared/vue.DImwKTwJ.mjs

@@ -0,0 +1,103 @@
+import { createSolanaActionStore } from '@vue-solana/core/action';
+import { getAbortablePromise } from '@vue-solana/core/kit';
+import { normalizeSolanaError } from '@vue-solana/core/errors';
+import { shallowRef, onScopeDispose, watch, isRef, onMounted, getCurrentInstance, computed } from 'vue';
+
+function useRequest(source, options = {}) {
+  const data = shallowRef(void 0);
+  const error = shallowRef(null);
+  const status = shallowRef("fetching");
+  let disposed = false;
+  let attempt = 0;
+  const store = createSolanaActionStore(
+    async (signal, resolved) => {
+      attempt += 1;
+      const callerSignal = options.getAbortSignal?.(attempt);
+      const composedSignal = callerSignal ? AbortSignal.any([signal, callerSignal]) : signal;
+      let pending;
+      if (isSendSource(resolved)) {
+        pending = Promise.resolve(resolved.send({ abortSignal: composedSignal }));
+      } else if (typeof resolved === "function") {
+        pending = Promise.resolve(resolved(composedSignal)).then(
+          (result) => isSendSource(result) ? result.send({ abortSignal: composedSignal }) : result
+        );
+      } else {
+        throw new Error("useRequest source did not resolve to a request function");
+      }
+      return getAbortablePromise(pending, composedSignal);
+    }
+  );
+  const unsubscribe = store.subscribe(() => {
+    const next = store.getState();
+    if (next.status === "success") {
+      data.value = next.data;
+      error.value = null;
+      status.value = "success";
+    } else if (next.status === "error") {
+      error.value = normalizeSolanaError(next.error, "RPC_FAILURE");
+      status.value = "error";
+    } else if (next.status === "running") {
+      status.value = "fetching";
+    }
+  });
+  onScopeDispose(() => {
+    disposed = true;
+    unsubscribe();
+    store.reset();
+  });
+  function unwrapSource() {
+    if (isRef(source)) {
+      return source.value;
+    }
+    return source;
+  }
+  async function run() {
+    if (disposed) {
+      return void 0;
+    }
+    const resolved = unwrapSource();
+    if (isDisabled(resolved)) {
+      data.value = void 0;
+      error.value = null;
+      status.value = "disabled";
+      store.reset();
+      return void 0;
+    }
+    status.value = "fetching";
+    try {
+      return await store.dispatchAsync(resolved);
+    } catch (cause) {
+      if (store.getState().status !== "error") {
+        return void 0;
+      }
+      throw normalizeSolanaError(cause, "RPC_FAILURE");
+    }
+  }
+  const refresh = () => run();
+  watch(
+    () => isRef(source) ? source.value : source,
+    () => {
+      void refresh().catch(() => void 0);
+    }
+  );
+  onMounted(() => {
+    void refresh().catch(() => void 0);
+  });
+  if (!getCurrentInstance()) {
+    void refresh().catch(() => void 0);
+  }
+  return {
+    data: computed(() => data.value),
+    error: computed(() => error.value),
+    refresh,
+    status: computed(() => status.value)
+  };
+}
+function isDisabled(resolved) {
+  return resolved === null || resolved === void 0;
+}
+function isSendSource(resolved) {
+  return typeof resolved === "object" && resolved !== null && "send" in resolved && typeof resolved.send === "function";
+}
+
+export { useRequest as u };

package/dist/shared/{vue.G9t8pE0J.cjs → vue.DKyQ7J67.cjs}

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

package/dist/shared/vue.DNxOpDXz.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+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;
+}
+
+exports.decodeBase64 = decodeBase64;

package/dist/shared/vue.DXQVIRZA.mjs

@@ -0,0 +1,174 @@
+import { provide, inject, ref, watch, getCurrentScope, onScopeDispose, computed, defineComponent } from 'vue';
+import { s as solanaInjectionKey } from './vue.D_P5SqqD.mjs';
+
+const SELECTED_WALLET_ACCOUNT_STORAGE_KEY = "vue-solana:selected-wallet-account";
+function createLocalStorageSelectedWalletAccountStorage(storage = defaultLocalStorage()) {
+  return {
+    storeSelectedWallet(key) {
+      try {
+        storage?.setItem(SELECTED_WALLET_ACCOUNT_STORAGE_KEY, key);
+      } catch {
+      }
+    },
+    getSelectedWallet() {
+      try {
+        return storage?.getItem(SELECTED_WALLET_ACCOUNT_STORAGE_KEY) ?? null;
+      } catch {
+        return null;
+      }
+    },
+    deleteSelectedWallet() {
+      try {
+        storage?.removeItem(SELECTED_WALLET_ACCOUNT_STORAGE_KEY);
+      } catch {
+      }
+    }
+  };
+}
+function defaultLocalStorage() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+
+const selectedWalletAccountInjectionKey = Symbol.for("vue-solana:selected-wallet-account");
+function provideSelectedWalletAccount(options = {}) {
+  const context = createSelectedWalletAccountContext(options);
+  provide(selectedWalletAccountInjectionKey, context);
+  return context;
+}
+function createSelectedWalletAccountContext(options = {}, solanaContextOverride) {
+  const solanaContext = solanaContextOverride ?? inject(solanaInjectionKey, null);
+  const stateSync = options.stateSync === void 0 ? defaultStateSync() : options.stateSync;
+  const selectedWalletAccount = ref(null);
+  const walletsValue = () => solanaContext?.wallets.value ?? [];
+  let pendingKey = null;
+  let selectionGeneration = 0;
+  function findAccount(key) {
+    const separatorIndex = key.lastIndexOf(":");
+    const walletName = separatorIndex === -1 ? key : key.slice(0, separatorIndex);
+    const address = separatorIndex === -1 ? "" : key.slice(separatorIndex + 1);
+    const wallet = walletsValue().find((candidate) => candidate.name === walletName);
+    const account = wallet?.accounts.find((candidate) => candidate.address === address);
+    if (!wallet || !account) {
+      return null;
+    }
+    return { ...account, walletName: wallet.name };
+  }
+  function clearSelection() {
+    selectionGeneration += 1;
+    pendingKey = null;
+    selectedWalletAccount.value = null;
+  }
+  function applyExternalSelection(key) {
+    if (!key) {
+      clearSelection();
+      return;
+    }
+    const account = findAccount(key);
+    if (account) {
+      selectionGeneration += 1;
+      pendingKey = null;
+      selectedWalletAccount.value = account;
+      return;
+    }
+    pendingKey = key;
+  }
+  function restoreIfAvailable() {
+    if (!pendingKey || selectedWalletAccount.value) {
+      return;
+    }
+    const account = findAccount(pendingKey);
+    if (account) {
+      selectedWalletAccount.value = account;
+      pendingKey = null;
+    }
+  }
+  if (stateSync) {
+    const generation = selectionGeneration;
+    void Promise.resolve(stateSync.getSelectedWallet()).then((key) => {
+      if (generation !== selectionGeneration || !key || selectedWalletAccount.value) {
+        return;
+      }
+      pendingKey = key;
+      restoreIfAvailable();
+    }).catch(() => void 0);
+  }
+  if (solanaContext) {
+    watch(
+      () => solanaContext.wallets.value,
+      () => restoreIfAvailable()
+    );
+  }
+  if (stateSync && typeof window !== "undefined") {
+    const onStorage = () => {
+      void Promise.resolve(stateSync.getSelectedWallet()).then((key) => applyExternalSelection(key)).catch(() => void 0);
+    };
+    window.addEventListener("storage", onStorage);
+    if (getCurrentScope()) {
+      onScopeDispose(() => window.removeEventListener("storage", onStorage));
+    }
+  }
+  const context = {
+    selectedWalletAccount,
+    setSelectedWalletAccount(account) {
+      selectionGeneration += 1;
+      selectedWalletAccount.value = account;
+      pendingKey = null;
+      if (!stateSync) {
+        return;
+      }
+      const persisted = account ? stateSync.storeSelectedWallet(`${account.walletName}:${account.address}`) : stateSync.deleteSelectedWallet();
+      void Promise.resolve(persisted).catch(() => void 0);
+    },
+    filteredWallets: computed(() => {
+      const filter = options.filterWallet;
+      if (!filter) {
+        return walletsValue();
+      }
+      return walletsValue().map((wallet) => {
+        const accounts = wallet.accounts.filter((account) => filter(wallet.name, account));
+        return accounts.length === 0 ? null : { ...wallet, accounts };
+      }).filter((wallet) => wallet !== null);
+    })
+  };
+  return context;
+}
+function useSelectedWalletAccount() {
+  const context = inject(selectedWalletAccountInjectionKey, null);
+  if (!context) {
+    throw new Error("useSelectedWalletAccount must be used inside a SelectedWalletAccountProvider");
+  }
+  return [context.selectedWalletAccount, context.setSelectedWalletAccount, context.filteredWallets];
+}
+function defaultStateSync() {
+  return createLocalStorageSelectedWalletAccountStorage();
+}
+
+const SelectedWalletAccountProvider = defineComponent({
+  name: "SelectedWalletAccountProvider",
+  props: {
+    filterWallet: {
+      type: Function,
+      default: void 0
+    },
+    stateSync: {
+      type: [Object, null],
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    provideSelectedWalletAccount({
+      filterWallet: props.filterWallet,
+      stateSync: props.stateSync
+    });
+    return () => slots.default?.();
+  }
+});
+
+export { SelectedWalletAccountProvider as S, createSelectedWalletAccountContext as c, provideSelectedWalletAccount as p, selectedWalletAccountInjectionKey as s, useSelectedWalletAccount as u };

package/dist/shared/vue.DYk0Xfr3.mjs

@@ -0,0 +1,36 @@
+import { createSolanaActionStore } from '@vue-solana/core/action';
+import { unref, shallowRef, onScopeDispose, computed } from 'vue';
+
+function useAction(action, options = {}) {
+  const store = createSolanaActionStore(
+    (signal, ...args) => unref(action)(signal, ...args)
+  );
+  const state = 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;
+  });
+  onScopeDispose(() => {
+    unsubscribe();
+    store.reset();
+  });
+  return {
+    data: computed(() => state.value.data),
+    dispatch: (...args) => store.dispatchAsync(...args),
+    error: computed(() => state.value.error),
+    isRunning: computed(() => state.value.status === "running"),
+    reset: () => {
+      store.reset();
+    },
+    status: computed(() => state.value.status)
+  };
+}
+
+export { useAction as u };

package/dist/shared/vue.D_P5SqqD.mjs

@@ -0,0 +1,5 @@
+const solanaInjectionKey = Symbol.for(
+  "vue-solana:context"
+);
+
+export { solanaInjectionKey as s };

package/dist/shared/{vue.B14U1xmP.cjs → vue.Di7yjJ-R.cjs}

@@ -1,14 +1,15 @@
 'use strict';
 
-const address = require('@vue-solana/core/address');
 const errors = require('@vue-solana/core/errors');
 const vue = require('vue');
-const useConnection = require('./vue.DCgByzxg.cjs');
-const useSolana = require('./vue.BE4KHksm.cjs');
+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 useProgramAccounts(programId, options = {}) {
   const solana = useSolana.tryUseSolana();
-  const connection = solana?.connection ?? useConnection.useConnection();
+  const client = solana?.client ?? useConnection.useConnection();
   const accounts = vue.shallowRef([]);
   const loading = vue.shallowRef(false);
   const error = vue.shallowRef(null);
@@ -25,16 +26,27 @@ function useProgramAccounts(programId, options = {}) {
     loading.value = true;
     error.value = null;
     try {
-      const publicKey = address.parsePublicKey(value);
-      if (!publicKey) {
+      const parsedAddress = address.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.decodeBase64(account.data[0])
+        }
+      }));
       if (requestId === refreshId) {
         accounts.value = nextAccounts;
       }