@vue-solana/core 4.1.5 → 4.1.7

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.Fb0vU7a_.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.bHkdj4bp.mjs';

package/dist/mobile-wallet.mjs

@@ -1,7 +1,111 @@
 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 runMobileWalletSession({ appIdentity, authorizationCache, publicKey }, request) {
+  const cachedAuthorization = await authorizationCache.get();
+  if (!cachedAuthorization) {
+    throw createSolanaError("WALLET_NOT_CONNECTED", "Solana wallet is not connected");
+  }
+  const address = getBase64Decoder().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
+      });
+    }
+    return request(wallet, address);
+  });
+}
+function signMobileWalletMessages(options, messages) {
+  return runMobileWalletSession(options, async (wallet, address) => {
+    const { signed_payloads } = await wallet.signMessages({
+      addresses: messages.map(() => address),
+      payloads: messages.map(toBase64)
+    });
+    return signed_payloads.map(fromBase64);
+  });
+}
+function signMobileWalletTransactions(options, transactions) {
+  return runMobileWalletSession(options, async (wallet) => {
+    const { signed_payloads } = await wallet.signTransactions({
+      payloads: transactions.map(toBase64)
+    });
+    return signed_payloads.map(fromBase64);
+  });
+}
+function signAndSendMobileWalletTransactions(options, transactions, sendOptions) {
+  return runMobileWalletSession(options, async (wallet) => {
+    const capabilities = await wallet.getCapabilities();
+    if (!capabilities.supports_sign_and_send_transactions) {
+      throw createSolanaError(
+        "WALLET_FEATURE_UNSUPPORTED",
+        "The connected wallet does not support signAndSendTransaction"
+      );
+    }
+    const { signatures } = await wallet.signAndSendTransactions({
+      payloads: transactions.map(toBase64),
+      options: toMobileWalletSendOptions(sendOptions)
+    });
+    return signatures.map(fromBase64);
+  });
+}
+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 toMobileWalletSendOptions(sendOptions) {
+  if (!sendOptions) {
+    return void 0;
+  }
+  return {
+    commitment: sendOptions.preflightCommitment,
+    skip_preflight: sendOptions.skipPreflight,
+    max_retries: sendOptions.maxRetries === void 0 ? void 0 : Number(sendOptions.maxRetries),
+    min_context_slot: sendOptions.minContextSlot === void 0 ? void 0 : Number(sendOptions.minContextSlot)
+  };
+}
+function toBase64(bytes) {
+  return getBase64Decoder().decode(bytes);
+}
+function fromBase64(value) {
+  return Uint8Array.from(getBase64Encoder().encode(value));
+}
+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 +134,14 @@ 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),
+    signTransactions: (publicKey, transactions) => signMobileWalletTransactions({ appIdentity, authorizationCache, publicKey }, transactions),
+    signAndSendTransactions: (publicKey, transactions, sendOptions) => signAndSendMobileWalletTransactions(
+      { appIdentity, authorizationCache, publicKey },
+      transactions,
+      sendOptions
+    )
   });
   return true;
 }

package/dist/shared/{core.Fb0vU7a_.mjs → core.bHkdj4bp.mjs}

@@ -108,6 +108,52 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
       pendingMobileWalletRequests.delete(reject);
     });
   }
+  function getMobileWalletSession() {
+    return isMobileWalletAdapter ? getSolanaMobileWalletAuthorizationStore() : void 0;
+  }
+  function signTransactionsThroughWallet(activeAccount, transactions) {
+    const signTransactions = getMobileWalletSession()?.signTransactions;
+    return whileMobileWalletAuthorized(async () => {
+      if (!signTransactions) {
+        return signAllThroughFeature(
+          wallet,
+          activeAccount,
+          transactions,
+          options.chain
+        );
+      }
+      const signedTransactions = await signTransactions(
+        Uint8Array.from(activeAccount.publicKey),
+        transactions.map((transaction) => new Uint8Array(transaction))
+      );
+      assertResultCount(signedTransactions, transactions, "signed transactions");
+      return signedTransactions;
+    });
+  }
+  function signAndSendTransactionsThroughWallet(activeAccount, transactions, sendOptions) {
+    const signAndSendTransactions = getMobileWalletSession()?.signAndSendTransactions;
+    return whileMobileWalletAuthorized(async () => {
+      const signatures = signAndSendTransactions ? await signAndSendTransactions(
+        Uint8Array.from(activeAccount.publicKey),
+        transactions.map((transaction) => new Uint8Array(transaction)),
+        sendOptions
+      ) : (await wallet.features[SolanaSignAndSendTransaction].signAndSendTransaction(
+        ...transactions.map((transaction) => ({
+          account: activeAccount,
+          transaction: new Uint8Array(transaction),
+          chain: options.chain ?? getSolanaAccountChain(activeAccount),
+          options: sendOptions
+        }))
+      )).map((result) => {
+        if (!result) {
+          throw new Error("Solana wallet did not return a transaction signature");
+        }
+        return result.signature;
+      });
+      assertResultCount(signatures, transactions, "signatures");
+      return signatures;
+    });
+  }
   function rejectPendingMobileWalletRequests() {
     for (const reject of pendingMobileWalletRequests) {
       reject(
@@ -270,8 +316,14 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
     } : void 0,
     signMessage: hasSignMessage(wallet) ? async (message) => {
       const activeAccount = getActiveAccount(account);
+      const signMessages = getMobileWalletSession()?.signMessages;
       const [result] = await whileMobileWalletAuthorized(
-        () => wallet.features[SolanaSignMessage].signMessage({
+        async () => signMessages ? (await signMessages(Uint8Array.from(activeAccount.publicKey), [message])).map(
+          (signedMessage2) => ({
+            signedMessage: signedMessage2,
+            signature: signedMessage2.slice(-64)
+          })
+        ) : wallet.features[SolanaSignMessage].signMessage({
           account: activeAccount,
           message
         })
@@ -293,79 +345,43 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
       return { ...result, signedMessage };
     } : void 0,
     signTransaction: hasSignTransaction(wallet) ? async (transaction) => {
-      const activeAccount = getActiveAccount(account);
-      const [result] = await whileMobileWalletAuthorized(
-        () => wallet.features[SolanaSignTransaction].signTransaction({
-          account: activeAccount,
-          transaction: new Uint8Array(transaction),
-          chain: options.chain
-        })
+      const [signedTransaction] = await signTransactionsThroughWallet(
+        getActiveAccount(account),
+        [transaction]
       );
-      if (!result) {
+      if (!signedTransaction) {
         throw new Error("Solana wallet did not return a signed transaction");
       }
-      return result.signedTransaction;
+      return signedTransaction;
     } : void 0,
-    signAllTransactions: hasSignTransaction(wallet) ? async (transactions) => whileMobileWalletAuthorized(
-      () => signAllThroughFeature(
-        wallet,
-        () => getActiveAccount(account),
-        transactions,
-        options.chain
-      )
-    ) : void 0,
-    signTransactions: hasSignTransaction(wallet) ? async (transactions) => whileMobileWalletAuthorized(
-      () => signAllThroughFeature(
-        wallet,
-        () => getActiveAccount(account),
-        transactions,
-        options.chain
-      )
-    ) : void 0,
+    signAllTransactions: hasSignTransaction(wallet) ? async (transactions) => signTransactionsThroughWallet(getActiveAccount(account), transactions) : void 0,
+    signTransactions: hasSignTransaction(wallet) ? async (transactions) => signTransactionsThroughWallet(getActiveAccount(account), transactions) : void 0,
     signAndSendTransaction: hasSignAndSendTransaction(wallet) ? async (transaction, sendOptions) => {
-      const activeAccount = getActiveAccount(account);
-      const [result] = await whileMobileWalletAuthorized(
-        () => wallet.features[SolanaSignAndSendTransaction].signAndSendTransaction({
-          account: activeAccount,
-          transaction: new Uint8Array(transaction),
-          chain: options.chain ?? getSolanaAccountChain(activeAccount),
-          options: sendOptions
-        })
+      const [signature] = await signAndSendTransactionsThroughWallet(
+        getActiveAccount(account),
+        [transaction],
+        sendOptions
       );
-      if (!result) {
+      if (!signature) {
         throw new Error("Solana wallet did not return a transaction signature");
       }
-      return { signature: getBase58Decoder().decode(result.signature) };
+      return { signature: getBase58Decoder().decode(signature) };
     } : void 0,
     signAndSendTransactions: hasSignAndSendTransaction(wallet) ? async (transactions, sendOptions) => {
       const activeAccount = getActiveAccount(account);
       if (isMobileWalletAdapter && options.sendTransaction && transactions.length > 1 && hasSignTransaction(wallet)) {
-        const signedTransactions = await whileMobileWalletAuthorized(
-          () => signAllThroughFeature(wallet, () => activeAccount, transactions, options.chain)
+        const signedTransactions = await signTransactionsThroughWallet(
+          activeAccount,
+          transactions
         );
         return sendSequentially(signedTransactions, options.sendTransaction, 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
-          }))
-        )
+      const signatures = await signAndSendTransactionsThroughWallet(
+        activeAccount,
+        transactions,
+        sendOptions
       );
-      if (results.length !== transactions.length) {
-        throw new Error(
-          `Solana wallet returned ${results.length} signatures for ${transactions.length} requested transactions`
-        );
-      }
-      return results.map((result) => {
-        if (!result) {
-          throw new Error("Solana wallet did not return a transaction signature");
-        }
-        return getBase58Decoder().decode(result.signature);
-      });
+      return signatures.map((signature) => getBase58Decoder().decode(signature));
     } : void 0
   };
 }
@@ -393,8 +409,7 @@ async function sendSequentially(signedTransactions, sendTransaction, sendOptions
   }
   return signatures;
 }
-async function signAllThroughFeature(wallet, getAccount, transactions, chain) {
-  const activeAccount = getAccount();
+async function signAllThroughFeature(wallet, activeAccount, transactions, chain) {
   const results = await wallet.features[SolanaSignTransaction].signTransaction(
     ...transactions.map((transaction) => ({
       account: activeAccount,
@@ -402,11 +417,7 @@ async function signAllThroughFeature(wallet, getAccount, transactions, chain) {
       chain
     }))
   );
-  if (results.length !== transactions.length) {
-    throw new Error(
-      `Solana wallet returned ${results.length} signed transactions for ${transactions.length} requested transactions`
-    );
-  }
+  assertResultCount(results, transactions, "signed transactions");
   return results.map((result) => {
     if (!result) {
       throw new Error("Solana wallet did not return a signed transaction");
@@ -414,6 +425,13 @@ async function signAllThroughFeature(wallet, getAccount, transactions, chain) {
     return result.signedTransaction;
   });
 }
+function assertResultCount(results, transactions, label) {
+  if (results.length !== transactions.length) {
+    throw new Error(
+      `Solana wallet returned ${results.length} ${label} for ${transactions.length} requested transactions`
+    );
+  }
+}
 function getDefaultSignInInput(account) {
   const domain = typeof location === "undefined" ? "" : location.host;
   return account ? { domain, address: account.address } : { domain };

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.Fb0vU7a_.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.bHkdj4bp.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue-solana/core",
-  "version": "4.1.5",
+  "version": "4.1.7",
   "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",