@vue-solana/vue 2.1.0 → 2.3.0

package/dist/shared/vue.BFbIDI66.cjs

@@ -0,0 +1,121 @@
+'use strict';
+
+const errors = require('@vue-solana/core/errors');
+const vue = require('vue');
+const useClientCapability = require('./vue.BY0qpgYr.cjs');
+const useSolanaClient = require('./vue.BIxphCAq.cjs');
+
+const SENDING_PROVIDER_HINT = "Install a transaction planner and a transaction-sending executor plugin, e.g. `createClient().use(rpcTransactionPlanner()).use(rpcTransactionPlanSendingExecutor())` from `@solana/kit-plugin-rpc`.";
+function useSendTransaction() {
+  useClientCapability.useClientCapability(["sendTransaction"], {
+    hookName: "useSendTransaction",
+    providerHint: SENDING_PROVIDER_HINT
+  });
+  const { client } = useSolanaClient.useSolanaClient();
+  const data = vue.shallowRef(null);
+  const status = vue.ref("idle");
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  let executionId = 0;
+  let abortController;
+  vue.onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
+  async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
+    const currentExecutionId = ++executionId;
+    const sender = client;
+    status.value = "sending";
+    loading.value = true;
+    error.value = null;
+    data.value = null;
+    try {
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const result = await sender.sendTransaction(input, { abortSignal });
+      if (currentExecutionId === executionId) {
+        data.value = result;
+        status.value = "sent";
+      }
+      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 {
+    data,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+function useSendTransactions() {
+  useClientCapability.useClientCapability(["sendTransactions"], {
+    hookName: "useSendTransactions",
+    providerHint: SENDING_PROVIDER_HINT
+  });
+  const { client } = useSolanaClient.useSolanaClient();
+  const data = vue.shallowRef(null);
+  const status = vue.ref("idle");
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  let executionId = 0;
+  let abortController;
+  vue.onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
+  async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
+    const currentExecutionId = ++executionId;
+    const sender = client;
+    status.value = "sending";
+    loading.value = true;
+    error.value = null;
+    data.value = null;
+    try {
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const result = await sender.sendTransactions(input, { abortSignal });
+      if (currentExecutionId === executionId) {
+        data.value = result;
+        status.value = "sent";
+      }
+      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 {
+    data,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+
+exports.useSendTransaction = useSendTransaction;
+exports.useSendTransactions = useSendTransactions;

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.B4-LEdSE.cjs → vue.BfGt94sg.cjs}

@@ -16,7 +16,15 @@ function usePlanTransaction() {
   const loading = vue.ref(false);
   const error = vue.ref(null);
   let executionId = 0;
+  let abortController;
+  vue.onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
   async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
     const currentExecutionId = ++executionId;
     const planner = client;
     status.value = "planning";
@@ -24,7 +32,8 @@ function usePlanTransaction() {
     error.value = null;
     transactionMessage.value = null;
     try {
-      const message = await planner.planTransaction(input, config);
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const message = await planner.planTransaction(input, { abortSignal });
       if (currentExecutionId === executionId) {
         transactionMessage.value = message;
         status.value = "planned";
@@ -62,7 +71,15 @@ function usePlanTransactions() {
   const loading = vue.ref(false);
   const error = vue.ref(null);
   let executionId = 0;
+  let abortController;
+  vue.onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
   async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
     const currentExecutionId = ++executionId;
     const planner = client;
     status.value = "planning";
@@ -70,7 +87,8 @@ function usePlanTransactions() {
     error.value = null;
     transactionPlan.value = null;
     try {
-      const plan = await planner.planTransactions(input, config);
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const plan = await planner.planTransactions(input, { abortSignal });
       if (currentExecutionId === executionId) {
         transactionPlan.value = plan;
         status.value = "planned";

package/dist/shared/{vue.C5FVoEZT.mjs → vue.C4hGlFC8.mjs}

@@ -1,5 +1,5 @@
 import { normalizeSolanaError } from '@vue-solana/core/errors';
-import { shallowRef, ref } from 'vue';
+import { shallowRef, ref, onScopeDispose } from 'vue';
 import { u as useClientCapability } from './vue.B8LptjZP.mjs';
 import { u as useSolanaClient } from './vue.Mxc8w6Qk.mjs';
 
@@ -14,7 +14,15 @@ function usePlanTransaction() {
   const loading = ref(false);
   const error = ref(null);
   let executionId = 0;
+  let abortController;
+  onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
   async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
     const currentExecutionId = ++executionId;
     const planner = client;
     status.value = "planning";
@@ -22,7 +30,8 @@ function usePlanTransaction() {
     error.value = null;
     transactionMessage.value = null;
     try {
-      const message = await planner.planTransaction(input, config);
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const message = await planner.planTransaction(input, { abortSignal });
       if (currentExecutionId === executionId) {
         transactionMessage.value = message;
         status.value = "planned";
@@ -60,7 +69,15 @@ function usePlanTransactions() {
   const loading = ref(false);
   const error = ref(null);
   let executionId = 0;
+  let abortController;
+  onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
   async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
     const currentExecutionId = ++executionId;
     const planner = client;
     status.value = "planning";
@@ -68,7 +85,8 @@ function usePlanTransactions() {
     error.value = null;
     transactionPlan.value = null;
     try {
-      const plan = await planner.planTransactions(input, config);
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const plan = await planner.planTransactions(input, { abortSignal });
       if (currentExecutionId === executionId) {
         transactionPlan.value = plan;
         status.value = "planned";

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.CogzzQXM.mjs → vue.CbJFnho-.mjs}

@@ -28,7 +28,7 @@ function useTrackedData(source, options = {}) {
       error.value = null;
     }
   }
-  function buildAndConnect() {
+  function buildAndConnect(override) {
     if (disposed) {
       return;
     }
@@ -104,7 +104,7 @@ function useTrackedData(source, options = {}) {
     }
     connectionCount += 1;
     const connection = connectionCount;
-    const callerSignal = options.getAbortSignal?.(connection);
+    const callerSignal = override ? override.abortSignal : options.getAbortSignal?.(connection);
     const store = createReactiveStoreWithInitialValueAndSlotTracking({
       initialValueMapper: source.rpcValueMapper,
       initialValueSource: rpcRequest,
@@ -158,8 +158,8 @@ function useTrackedData(source, options = {}) {
   return {
     data: computed(() => data.value),
     error: computed(() => error.value),
-    refresh: () => {
-      buildAndConnect();
+    refresh: (options2) => {
+      buildAndConnect(options2);
     },
     status: computed(() => status.value)
   };

package/dist/shared/vue.DT4vCUa6.mjs

@@ -0,0 +1,118 @@
+import { normalizeSolanaError } from '@vue-solana/core/errors';
+import { shallowRef, ref, onScopeDispose } from 'vue';
+import { u as useClientCapability } from './vue.B8LptjZP.mjs';
+import { u as useSolanaClient } from './vue.Mxc8w6Qk.mjs';
+
+const SENDING_PROVIDER_HINT = "Install a transaction planner and a transaction-sending executor plugin, e.g. `createClient().use(rpcTransactionPlanner()).use(rpcTransactionPlanSendingExecutor())` from `@solana/kit-plugin-rpc`.";
+function useSendTransaction() {
+  useClientCapability(["sendTransaction"], {
+    hookName: "useSendTransaction",
+    providerHint: SENDING_PROVIDER_HINT
+  });
+  const { client } = useSolanaClient();
+  const data = shallowRef(null);
+  const status = ref("idle");
+  const loading = ref(false);
+  const error = ref(null);
+  let executionId = 0;
+  let abortController;
+  onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
+  async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
+    const currentExecutionId = ++executionId;
+    const sender = client;
+    status.value = "sending";
+    loading.value = true;
+    error.value = null;
+    data.value = null;
+    try {
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const result = await sender.sendTransaction(input, { abortSignal });
+      if (currentExecutionId === executionId) {
+        data.value = result;
+        status.value = "sent";
+      }
+      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 {
+    data,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+function useSendTransactions() {
+  useClientCapability(["sendTransactions"], {
+    hookName: "useSendTransactions",
+    providerHint: SENDING_PROVIDER_HINT
+  });
+  const { client } = useSolanaClient();
+  const data = shallowRef(null);
+  const status = ref("idle");
+  const loading = ref(false);
+  const error = ref(null);
+  let executionId = 0;
+  let abortController;
+  onScopeDispose(() => {
+    abortController?.abort();
+    executionId++;
+  });
+  async function execute(input, config) {
+    abortController?.abort();
+    const controller = new AbortController();
+    abortController = controller;
+    const currentExecutionId = ++executionId;
+    const sender = client;
+    status.value = "sending";
+    loading.value = true;
+    error.value = null;
+    data.value = null;
+    try {
+      const abortSignal = config?.abortSignal ? AbortSignal.any([controller.signal, config.abortSignal]) : controller.signal;
+      const result = await sender.sendTransactions(input, { abortSignal });
+      if (currentExecutionId === executionId) {
+        data.value = result;
+        status.value = "sent";
+      }
+      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 {
+    data,
+    status,
+    loading,
+    error,
+    execute
+  };
+}
+
+export { useSendTransactions as a, useSendTransaction as u };

package/dist/shared/{vue.DtCbCcPd.cjs → vue.DxM45azl.cjs}

@@ -30,7 +30,7 @@ function useTrackedData(source, options = {}) {
       error.value = null;
     }
   }
-  function buildAndConnect() {
+  function buildAndConnect(override) {
     if (disposed) {
       return;
     }
@@ -106,7 +106,7 @@ function useTrackedData(source, options = {}) {
     }
     connectionCount += 1;
     const connection = connectionCount;
-    const callerSignal = options.getAbortSignal?.(connection);
+    const callerSignal = override ? override.abortSignal : options.getAbortSignal?.(connection);
     const store = kit.createReactiveStoreWithInitialValueAndSlotTracking({
       initialValueMapper: source.rpcValueMapper,
       initialValueSource: rpcRequest,
@@ -160,8 +160,8 @@ function useTrackedData(source, options = {}) {
   return {
     data: vue.computed(() => data.value),
     error: vue.computed(() => error.value),
-    refresh: () => {
-      buildAndConnect();
+    refresh: (options2) => {
+      buildAndConnect(options2);
     },
     status: vue.computed(() => status.value)
   };

package/dist/shared/{vue.B8pLQ8P4.cjs → vue.ZuUCEEab.cjs}

@@ -11,24 +11,22 @@ function useRequest(source, options = {}) {
   const status = vue.shallowRef("fetching");
   let disposed = false;
   let attempt = 0;
-  const store = action.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 kit.getAbortablePromise(pending, composedSignal);
+  const store = action.createSolanaActionStore(async (signal, resolved, override) => {
+    attempt += 1;
+    const callerSignal = override ? override.abortSignal : 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 kit.getAbortablePromise(pending, composedSignal);
+  });
   const unsubscribe = store.subscribe(() => {
     const next = store.getState();
     if (next.status === "success") {
@@ -53,7 +51,7 @@ function useRequest(source, options = {}) {
     }
     return source;
   }
-  async function run() {
+  async function run(override) {
     if (disposed) {
       return void 0;
     }
@@ -67,7 +65,7 @@ function useRequest(source, options = {}) {
     }
     status.value = "fetching";
     try {
-      return await store.dispatchAsync(resolved);
+      return await store.dispatchAsync(resolved, override);
     } catch (cause) {
       if (store.getState().status !== "error") {
         return void 0;
@@ -75,7 +73,7 @@ function useRequest(source, options = {}) {
       throw errors.normalizeSolanaError(cause, "RPC_FAILURE");
     }
   }
-  const refresh = () => run();
+  const refresh = (options2) => run(options2);
   vue.watch(
     () => vue.isRef(source) ? source.value : source,
     () => {

package/dist/shared/{vue.BVj9lWBK.cjs → vue.l3UCdN7z.cjs}

@@ -29,11 +29,11 @@ function useSubscription(source, options = {}) {
       status.value = "loading";
     }
   }
-  function openConnection(store) {
+  function openConnection(store, override) {
     activeStore = store;
     connectionCount += 1;
     const connection = connectionCount;
-    const callerSignal = options.getAbortSignal?.(connection);
+    const callerSignal = override ? override.abortSignal : options.getAbortSignal?.(connection);
     applyState(store.getState());
     disposables.push(
       store.subscribe(() => {
@@ -61,7 +61,7 @@ function useSubscription(source, options = {}) {
     }
     activeSource = void 0;
   }
-  function connectCurrent() {
+  function connectCurrent(override) {
     if (disposed) {
       return;
     }
@@ -74,12 +74,12 @@ function useSubscription(source, options = {}) {
       return;
     }
     if (activeSource === resolved && activeStore) {
-      openConnection(activeStore);
+      openConnection(activeStore, override);
       return;
     }
     disconnect();
     activeSource = resolved;
-    openConnection(resolved.reactiveStore());
+    openConnection(resolved.reactiveStore(), override);
   }
   vue.watch(
     () => vue.isRef(source) ? source.value : source,
@@ -101,8 +101,8 @@ function useSubscription(source, options = {}) {
   return {
     data: vue.computed(() => data.value),
     error: vue.computed(() => error.value),
-    reconnect: () => {
-      connectCurrent();
+    reconnect: (options2) => {
+      connectCurrent(options2);
     },
     status: vue.computed(() => status.value)
   };

package/dist/swr.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
 const vue = require('vue');
-const useRequest = require('./shared/vue.B8pLQ8P4.cjs');
-const useSubscription = require('./shared/vue.BVj9lWBK.cjs');
-const useTrackedData = require('./shared/vue.DtCbCcPd.cjs');
+const useRequest = require('./shared/vue.ZuUCEEab.cjs');
+const useSubscription = require('./shared/vue.l3UCdN7z.cjs');
+const useTrackedData = require('./shared/vue.DxM45azl.cjs');
 require('@vue-solana/core/action');
 require('@vue-solana/core/kit');
 require('@vue-solana/core/errors');

package/dist/swr.mjs

@@ -1,7 +1,7 @@
 import { watch, computed } from 'vue';
-import { u as useRequest } from './shared/vue.DImwKTwJ.mjs';
-import { u as useSubscription } from './shared/vue.B8ub540p.mjs';
-import { u as useTrackedData } from './shared/vue.CogzzQXM.mjs';
+import { u as useRequest } from './shared/vue.B8VvC8d2.mjs';
+import { u as useSubscription } from './shared/vue.BDNOyiGZ.mjs';
+import { u as useTrackedData } from './shared/vue.CbJFnho-.mjs';
 import '@vue-solana/core/action';
 import '@vue-solana/core/kit';
 import '@vue-solana/core/errors';

package/dist/useAirdrop.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+const useAirdrop = require('./shared/vue.CTqPbvz3.cjs');
+require('./shared/vue.CoaIWGPT.cjs');
+require('@vue-solana/core/action');
+require('vue');
+require('./shared/vue.BY0qpgYr.cjs');
+require('./shared/vue.BIxphCAq.cjs');
+require('./shared/vue.DE3emjSF.cjs');
+require('./shared/vue.DEHxNvUX.cjs');
+
+
+
+exports.useAirdrop = useAirdrop.useAirdrop;

package/dist/useAirdrop.d.cts

@@ -0,0 +1,25 @@
+import { Address, Lamports, Signature } from '@vue-solana/core/kit';
+import { UseActionReturn } from './useAction.cjs';
+import 'vue';
+
+/**
+ * Airdrops SOL into an account. Each `dispatch(address, amount)` runs the
+ * airdrop with a fresh `AbortSignal`; calling `dispatch` again while a call is
+ * in flight aborts the previous one.
+ *
+ * Requires the client to expose an `airdrop` capability, typically installed
+ * with the RPC airdrop plugin, e.g.
+ * `createClient().use(solanaRpcConnection({ ... })).use(rpcAirdrop())` from
+ * `@solana/kit-plugin-rpc`. The capability is commonly available on test
+ * networks (devnet, testnet) and local validators.
+ *
+ * Some implementations (e.g. LiteSVM) update balances directly without sending
+ * a transaction, in which case the resolved `data` is `undefined` rather than
+ * a {@link Signature}.
+ */
+declare function useAirdrop(): UseActionReturn<[
+    address: Address,
+    amount: Lamports
+], Signature | undefined>;
+
+export { useAirdrop };