@vue-solana/core 4.1.6 → 4.1.8

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.CSMFFbai.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

@@ -5,19 +5,12 @@ 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
-}) {
+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 base64Decoder = getBase64Decoder();
-  const base64Encoder = getBase64Encoder();
-  const address = base64Decoder.decode(publicKey);
+  const address = getBase64Decoder().decode(publicKey);
   const chain = cachedAuthorization.chain;
   return transact(async (wallet) => {
     const authorization = await authorizeSession(
@@ -39,11 +32,40 @@ async function signMobileWalletMessages({
         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((message) => base64Decoder.decode(message))
+      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 signed_payloads.map((payload) => Uint8Array.from(base64Encoder.encode(payload)));
+    return signatures.map(fromBase64);
   });
 }
 async function authorizeSession(wallet, identity, chain, authToken) {
@@ -63,6 +85,23 @@ async function authorizeSession(wallet, identity, chain, authToken) {
     );
   }
 }
+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);
 }
@@ -96,7 +135,13 @@ function registerSolanaMobileWallet(options = {}) {
   setSolanaMobileWalletAuthorizationStore({
     get: () => authorizationCache.get(),
     set: (authorization) => authorizationCache.set(authorization),
-    signMessages: (publicKey, messages) => signMobileWalletMessages({ appIdentity, authorizationCache, publicKey, messages })
+    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.CSMFFbai.mjs → core.bHkdj4bp.mjs}

@@ -108,14 +108,51 @@ function adaptSolanaStandardWallet(walletInfo, options = {}) {
       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 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) {
@@ -279,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(
-        () => signMessageThroughMobileWalletSession(activeAccount, message) ?? 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
         })
@@ -302,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
   };
 }
@@ -402,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,
@@ -411,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");
@@ -423,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.CSMFFbai.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.6",
+  "version": "4.1.8",
   "description": "Framework-agnostic primitives for Vue Solana libraries.",
   "license": "MIT",
   "keywords": [