@vue-solana/core 4.1.4 → 4.1.6

package/dist/index.mjs

@@ -12,4 +12,4 @@ export { createSolanaPayReference, findTransactionSignaturesByReference, verifyS
 export { getSolanaPayPaymentStatus } from './solana-pay-status.mjs';
 export * from '@solana/kit';
 export { C as CreateTransferError, H as HTTPS_PROTOCOL, M as MEMO_PROGRAM_ID, P as ParseURLError, S as SOLANA_PROTOCOL, a as SOL_DECIMALS, T as TEN, b as TOKEN_PROGRAM_ID, c as createQR, d as createQRCanvas, e as createQRDataURL, f as createQROptions, g as createRecipient, h as createSPLToken, i as createStyledQRCode, j as encodeTransactionRequestURL, k as encodeTransferRequestURL, l as encodeURL, m as isValidSolanaAddress, p as parseURL } from './shared/core.CQFtdLrA.mjs';
-export { S as SOLANA_CHAINS, a as SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME, b as adaptSolanaStandardWallet, d as disconnectSolanaStandardWallet, g as getRegisteredSolanaWallets, c as getSolanaChain, i as isSolanaStandardWallet, s as subscribeSolanaWallets } from './shared/core.D8oIzL0q.mjs';
+export { S as SOLANA_CHAINS, a as SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME, b as adaptSolanaStandardWallet, d as disconnectSolanaStandardWallet, g as getRegisteredSolanaWallets, c as getSolanaChain, i as isSolanaStandardWallet, s as subscribeSolanaWallets } from './shared/core.CSMFFbai.mjs';

package/dist/mobile-wallet.mjs

@@ -1,7 +1,72 @@
 import { createDefaultAuthorizationCache, registerMwa, createDefaultWalletNotFoundHandler, createDefaultChainSelector } from '@solana-mobile/wallet-standard-mobile';
 import { s as setSolanaMobileWalletAuthorizationStore } from './shared/core.DQCWbyEu.mjs';
+import { transact } from '@solana-mobile/mobile-wallet-adapter-protocol';
+import { getBase64Decoder, getBase64Encoder } from '@solana/kit';
+import { createSolanaError } from './errors.mjs';
 import { isSolanaMobileWalletSupported } from './mobile-wallet-support.mjs';
 
+async function signMobileWalletMessages({
+  appIdentity,
+  authorizationCache,
+  publicKey,
+  messages
+}) {
+  const cachedAuthorization = await authorizationCache.get();
+  if (!cachedAuthorization) {
+    throw createSolanaError("WALLET_NOT_CONNECTED", "Solana wallet is not connected");
+  }
+  const base64Decoder = getBase64Decoder();
+  const base64Encoder = getBase64Encoder();
+  const address = base64Decoder.decode(publicKey);
+  const chain = cachedAuthorization.chain;
+  return transact(async (wallet) => {
+    const authorization = await authorizeSession(
+      wallet,
+      appIdentity,
+      chain,
+      cachedAuthorization.auth_token
+    );
+    if (!authorization.accounts.some((account) => account.address === address)) {
+      throw createSolanaError(
+        "WALLET_NOT_CONNECTED",
+        "The wallet authorized a different account than the connected one. Connect the wallet again and retry."
+      );
+    }
+    if (authorization.auth_token !== cachedAuthorization.auth_token) {
+      await authorizationCache.set({
+        ...cachedAuthorization,
+        auth_token: authorization.auth_token,
+        wallet_uri_base: authorization.wallet_uri_base
+      });
+    }
+    const { signed_payloads } = await wallet.signMessages({
+      addresses: messages.map(() => address),
+      payloads: messages.map((message) => base64Decoder.decode(message))
+    });
+    return signed_payloads.map((payload) => Uint8Array.from(base64Encoder.encode(payload)));
+  });
+}
+async function authorizeSession(wallet, identity, chain, authToken) {
+  let reauthorizationError;
+  try {
+    return await wallet.authorize({ auth_token: authToken, identity, chain });
+  } catch (error) {
+    reauthorizationError = error;
+  }
+  try {
+    return await wallet.authorize({ identity, chain });
+  } catch (authorizationError) {
+    throw createSolanaError(
+      "WALLET_FAILURE",
+      `The wallet rejected the saved authorization (${getErrorMessage(reauthorizationError)}) and a fresh one (${getErrorMessage(authorizationError)}).`,
+      { cause: authorizationError }
+    );
+  }
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 const DEFAULT_MOBILE_WALLET_CHAINS = ["solana:mainnet", "solana:devnet"];
 const registeredMobileWalletKeys = /* @__PURE__ */ new Set();
 function registerSolanaMobileWallet(options = {}) {
@@ -30,7 +95,8 @@ function registerSolanaMobileWallet(options = {}) {
   registeredMobileWalletKeys.add(registrationKey);
   setSolanaMobileWalletAuthorizationStore({
     get: () => authorizationCache.get(),
-    set: (authorization) => authorizationCache.set(authorization)
+    set: (authorization) => authorizationCache.set(authorization),
+    signMessages: (publicKey, messages) => signMobileWalletMessages({ appIdentity, authorizationCache, publicKey, messages })
   });
   return true;
 }

package/dist/shared/{core.D8oIzL0q.mjs → core.CSMFFbai.mjs}

@@ -78,10 +78,14 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
   let manuallyDisconnected = false;
   let signingIn = false;
   const isMobileWalletAdapter = walletInfo.source === "mobile-wallet-adapter";
+  const pendingMobileWalletRequests = /* @__PURE__ */ new Set();
   const eventsFeature = wallet.features[StandardEvents];
   const unsubscribeChange = eventsFeature?.on("change", (properties) => {
     if (properties.accounts) {
       accounts = properties.accounts;
+      if (accounts.length === 0) {
+        rejectPendingMobileWalletRequests();
+      }
       if (!signingIn) {
         account = allowAccountUpdates && !manuallyDisconnected ? getSolanaAccount(accounts, options.chain) : void 0;
       }
@@ -91,6 +95,39 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
   function dispose() {
     unsubscribeChange?.();
   }
+  function whileMobileWalletAuthorized(request) {
+    if (!isMobileWalletAdapter) {
+      return request();
+    }
+    let reject;
+    const deauthorized = new Promise((_, rejectRequest) => {
+      reject = rejectRequest;
+    });
+    pendingMobileWalletRequests.add(reject);
+    return Promise.race([request(), deauthorized]).finally(() => {
+      pendingMobileWalletRequests.delete(reject);
+    });
+  }
+  function signMessageThroughMobileWalletSession(activeAccount, message) {
+    const signMessages = isMobileWalletAdapter ? getSolanaMobileWalletAuthorizationStore()?.signMessages : void 0;
+    return signMessages?.(Uint8Array.from(activeAccount.publicKey), [message]).then(
+      (signedPayloads) => signedPayloads.map((signedMessage) => ({
+        signedMessage,
+        signature: signedMessage.slice(-64)
+      }))
+    );
+  }
+  function rejectPendingMobileWalletRequests() {
+    for (const reject of pendingMobileWalletRequests) {
+      reject(
+        createSolanaError(
+          "WALLET_NOT_CONNECTED",
+          "The wallet ended this app's session instead of signing, usually because it no longer accepts the saved authorization. Connect the wallet again and retry."
+        )
+      );
+    }
+    pendingMobileWalletRequests.clear();
+  }
   async function verifySignInResult(result, requestedAddress) {
     if (!result) {
       throw new Error("Solana wallet did not return a sign-in result");
@@ -242,10 +279,12 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
     } : void 0,
     signMessage: hasSignMessage(wallet) ? async (message) => {
       const activeAccount = getActiveAccount(account);
-      const [result] = await wallet.features[SolanaSignMessage].signMessage({
-        account: activeAccount,
-        message
-      });
+      const [result] = await whileMobileWalletAuthorized(
+        () => signMessageThroughMobileWalletSession(activeAccount, message) ?? wallet.features[SolanaSignMessage].signMessage({
+          account: activeAccount,
+          message
+        })
+      );
       if (!result) {
         throw new Error("Solana wallet did not return a message signature");
       }
@@ -264,36 +303,44 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
     } : void 0,
     signTransaction: hasSignTransaction(wallet) ? async (transaction) => {
       const activeAccount = getActiveAccount(account);
-      const [result] = await wallet.features[SolanaSignTransaction].signTransaction({
-        account: activeAccount,
-        transaction: new Uint8Array(transaction),
-        chain: options.chain
-      });
+      const [result] = await whileMobileWalletAuthorized(
+        () => wallet.features[SolanaSignTransaction].signTransaction({
+          account: activeAccount,
+          transaction: new Uint8Array(transaction),
+          chain: options.chain
+        })
+      );
       if (!result) {
         throw new Error("Solana wallet did not return a signed transaction");
       }
       return result.signedTransaction;
     } : void 0,
-    signAllTransactions: hasSignTransaction(wallet) ? async (transactions) => signAllThroughFeature(
-      wallet,
-      () => getActiveAccount(account),
-      transactions,
-      options.chain
+    signAllTransactions: hasSignTransaction(wallet) ? async (transactions) => whileMobileWalletAuthorized(
+      () => signAllThroughFeature(
+        wallet,
+        () => getActiveAccount(account),
+        transactions,
+        options.chain
+      )
     ) : void 0,
-    signTransactions: hasSignTransaction(wallet) ? async (transactions) => signAllThroughFeature(
-      wallet,
-      () => getActiveAccount(account),
-      transactions,
-      options.chain
+    signTransactions: hasSignTransaction(wallet) ? async (transactions) => whileMobileWalletAuthorized(
+      () => signAllThroughFeature(
+        wallet,
+        () => getActiveAccount(account),
+        transactions,
+        options.chain
+      )
     ) : void 0,
     signAndSendTransaction: hasSignAndSendTransaction(wallet) ? async (transaction, sendOptions) => {
       const activeAccount = getActiveAccount(account);
-      const [result] = await wallet.features[SolanaSignAndSendTransaction].signAndSendTransaction({
-        account: activeAccount,
-        transaction: new Uint8Array(transaction),
-        chain: options.chain ?? getSolanaAccountChain(activeAccount),
-        options: sendOptions
-      });
+      const [result] = await whileMobileWalletAuthorized(
+        () => wallet.features[SolanaSignAndSendTransaction].signAndSendTransaction({
+          account: activeAccount,
+          transaction: new Uint8Array(transaction),
+          chain: options.chain ?? getSolanaAccountChain(activeAccount),
+          options: sendOptions
+        })
+      );
       if (!result) {
         throw new Error("Solana wallet did not return a transaction signature");
       }
@@ -302,21 +349,20 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
     signAndSendTransactions: hasSignAndSendTransaction(wallet) ? async (transactions, sendOptions) => {
       const activeAccount = getActiveAccount(account);
       if (isMobileWalletAdapter && options.sendTransaction && transactions.length > 1 && hasSignTransaction(wallet)) {
-        const signedTransactions = await signAllThroughFeature(
-          wallet,
-          () => activeAccount,
-          transactions,
-          options.chain
+        const signedTransactions = await whileMobileWalletAuthorized(
+          () => signAllThroughFeature(wallet, () => activeAccount, transactions, options.chain)
         );
         return sendSequentially(signedTransactions, options.sendTransaction, sendOptions);
       }
-      const results = await wallet.features[SolanaSignAndSendTransaction].signAndSendTransaction(
-        ...transactions.map((transaction) => ({
-          account: activeAccount,
-          transaction: new Uint8Array(transaction),
-          chain: options.chain ?? getSolanaAccountChain(activeAccount),
-          options: sendOptions
-        }))
+      const results = await whileMobileWalletAuthorized(
+        () => wallet.features[SolanaSignAndSendTransaction].signAndSendTransaction(
+          ...transactions.map((transaction) => ({
+            account: activeAccount,
+            transaction: new Uint8Array(transaction),
+            chain: options.chain ?? getSolanaAccountChain(activeAccount),
+            options: sendOptions
+          }))
+        )
       );
       if (results.length !== transactions.length) {
         throw new Error(

package/dist/wallet-standard.mjs

@@ -1 +1 @@
-export { S as SOLANA_CHAINS, a as SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME, b as adaptSolanaStandardWallet, d as disconnectSolanaStandardWallet, g as getRegisteredSolanaWallets, c as getSolanaChain, i as isSolanaStandardWallet, s as subscribeSolanaWallets } from './shared/core.D8oIzL0q.mjs';
+export { S as SOLANA_CHAINS, a as SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME, b as adaptSolanaStandardWallet, d as disconnectSolanaStandardWallet, g as getRegisteredSolanaWallets, c as getSolanaChain, i as isSolanaStandardWallet, s as subscribeSolanaWallets } from './shared/core.CSMFFbai.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue-solana/core",
-  "version": "4.1.4",
+  "version": "4.1.6",
   "description": "Framework-agnostic primitives for Vue Solana libraries.",
   "license": "MIT",
   "keywords": [
@@ -115,6 +115,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@solana-mobile/mobile-wallet-adapter-protocol": "^2.2.9",
     "@solana-mobile/wallet-standard-mobile": "^0.5.3",
     "@solana/kit": "^8.6.0",
     "@solana/kit-plugin-rpc": "^0.19.0",