@dynamic-labs/solana 4.49.0 → 4.50.1

package/CHANGELOG.md

@@ -1,4 +1,19 @@
 
+## [4.50.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.49.0...v4.50.0) (2025-12-09)
+
+
+### Features
+
+* add usePhantomRedirectEvents hook ([#10030](https://github.com/dynamic-labs/dynamic-auth/issues/10030)) ([fb8585e](https://github.com/dynamic-labs/dynamic-auth/commit/fb8585eec9847cd350be71d28291e9831a3f31b1))
+* introduce embedded wallet reveal complete events ([#10068](https://github.com/dynamic-labs/dynamic-auth/issues/10068)) ([8ea79ce](https://github.com/dynamic-labs/dynamic-auth/commit/8ea79ceaba36745d46759c8e8c6681895b092096))
+* **react-native:** add download file ([#9954](https://github.com/dynamic-labs/dynamic-auth/issues/9954)) ([408b00f](https://github.com/dynamic-labs/dynamic-auth/commit/408b00fabd2afbd87d12efb51e78ecbd89a323d3))
+* **react-native:** add solana Phantom support with client module for listening to events ([#10033](https://github.com/dynamic-labs/dynamic-auth/issues/10033)) ([a5a2d11](https://github.com/dynamic-labs/dynamic-auth/commit/a5a2d11ccd3c102e22dece808a0ba4116155a582))
+
+
+### Bug Fixes
+
+* remove overflow from token balance dropdown ([#10044](https://github.com/dynamic-labs/dynamic-auth/issues/10044)) ([b37c5bb](https://github.com/dynamic-labs/dynamic-auth/commit/b37c5bb8e8c916b8d685b495555a3a3481cd5f0d))
+
 ## [4.49.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.48.2...v4.49.0) (2025-12-05)
 
 

package/package.cjs

@@ -3,6 +3,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "4.49.0";
+var version = "4.50.1";
 
 exports.version = version;

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.49.0";
+var version = "4.50.1";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/solana",
-  "version": "4.49.0",
+  "version": "4.50.1",
   "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -18,7 +18,7 @@
   },
   "homepage": "https://www.dynamic.xyz/",
   "dependencies": {
-    "@dynamic-labs/wallet-connect": "4.49.0",
+    "@dynamic-labs/wallet-connect": "4.50.1",
     "@solana/web3.js": "1.98.1",
     "@wallet-standard/app": "1.0.1",
     "@wallet-standard/base": "1.0.1",
@@ -29,17 +29,17 @@
     "@walletconnect/sign-client": "2.21.5",
     "@walletconnect/utils": "2.21.5",
     "@walletconnect/types": "2.21.5",
-    "@dynamic-labs/assert-package-version": "4.49.0",
-    "@dynamic-labs/embedded-wallet-solana": "4.49.0",
-    "@dynamic-labs/logger": "4.49.0",
-    "@dynamic-labs/rpc-providers": "4.49.0",
+    "@dynamic-labs/assert-package-version": "4.50.1",
+    "@dynamic-labs/embedded-wallet-solana": "4.50.1",
+    "@dynamic-labs/logger": "4.50.1",
+    "@dynamic-labs/rpc-providers": "4.50.1",
     "@dynamic-labs/sdk-api-core": "0.0.831",
-    "@dynamic-labs/solana-core": "4.49.0",
-    "@dynamic-labs/types": "4.49.0",
-    "@dynamic-labs/utils": "4.49.0",
-    "@dynamic-labs/waas-svm": "4.49.0",
-    "@dynamic-labs/wallet-book": "4.49.0",
-    "@dynamic-labs/wallet-connector-core": "4.49.0",
+    "@dynamic-labs/solana-core": "4.50.1",
+    "@dynamic-labs/types": "4.50.1",
+    "@dynamic-labs/utils": "4.50.1",
+    "@dynamic-labs/waas-svm": "4.50.1",
+    "@dynamic-labs/wallet-book": "4.50.1",
+    "@dynamic-labs/wallet-connector-core": "4.50.1",
     "eventemitter3": "5.0.1"
   },
   "peerDependencies": {}

package/src/index.cjs

@@ -22,6 +22,7 @@ var createSolanaSignerFromWalletStandard = require('./injected/walletStandard/cr
 var getWalletStandardWallets = require('./injected/walletStandard/getWalletStandardWallets/getWalletStandardWallets.cjs');
 var hasAllWalletStandardRequiredFeatures = require('./injected/walletStandard/hasAllWalletStandardRequiredFeatures/hasAllWalletStandardRequiredFeatures.cjs');
 require('./injected/FallbackSolanaConnector/FallbackSolanaConnector.cjs');
+var PhantomRedirect = require('./phantomRedirect/PhantomRedirect/PhantomRedirect.cjs');
 
 /* eslint-disable @typescript-eslint/no-unused-vars */
 assertPackageVersion.assertPackageVersion('@dynamic-labs/solana', _package.version);
@@ -44,3 +45,4 @@ exports.isSignedMessage = isSignedMessage.isSignedMessage;
 exports.createSolanaSignerFromWalletStandard = createSolanaSignerFromWalletStandard.createSolanaSignerFromWalletStandard;
 exports.getWalletStandardWallets = getWalletStandardWallets.getWalletStandardWallets;
 exports.hasAllWalletStandardRequiredFeatures = hasAllWalletStandardRequiredFeatures.hasAllWalletStandardRequiredFeatures;
+exports.PhantomRedirect = PhantomRedirect.PhantomRedirect;

package/src/index.d.ts

@@ -8,3 +8,4 @@ export { SolanaWalletConnectorsWithConfig } from './SolanaWalletConnectorsWithCo
 export { isBackpackSolanaSigner } from './utils/isBackpackSolanaSigner';
 export { isSignedMessage } from './utils/isSignedMessage';
 export { getWalletStandardWallets, createSolanaSignerFromWalletStandard, hasAllWalletStandardRequiredFeatures, } from './injected';
+export { PhantomRedirect } from './phantomRedirect/PhantomRedirect';

package/src/index.js

@@ -18,6 +18,7 @@ export { createSolanaSignerFromWalletStandard } from './injected/walletStandard/
 export { getWalletStandardWallets } from './injected/walletStandard/getWalletStandardWallets/getWalletStandardWallets.js';
 export { hasAllWalletStandardRequiredFeatures } from './injected/walletStandard/hasAllWalletStandardRequiredFeatures/hasAllWalletStandardRequiredFeatures.js';
 import './injected/FallbackSolanaConnector/FallbackSolanaConnector.js';
+export { PhantomRedirect } from './phantomRedirect/PhantomRedirect/PhantomRedirect.js';
 
 /* eslint-disable @typescript-eslint/no-unused-vars */
 assertPackageVersion('@dynamic-labs/solana', version);

package/src/injected/walletStandard/createSolanaSignerFromWalletStandard/createSolanaSignerFromWalletStandard.cjs

@@ -79,20 +79,30 @@ const createSolanaSignerFromWalletStandard = ({ wallet, walletConnector, }) => {
         return `solana:${cluster}`;
     };
     const signTransaction = (transaction) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const signedTransactions = yield signAllTransactions([transaction]);
+        return signedTransactions[0];
+    });
+    const signAllTransactions = (transactions) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const signTransactionMethod = features['solana:signTransaction'].signTransaction;
         const account = yield getCurrentAccount();
-        const signTransactionResult = yield features['solana:signTransaction'].signTransaction({
+        const chain = getChain();
+        const transactionsInput = transactions.map((transaction) => ({
             account,
-            chain: getChain(),
+            chain,
             transaction: transaction.serialize({
                 requireAllSignatures: false,
             }),
+        }));
+        const signTransactionResult = yield signTransactionMethod(...transactionsInput);
+        const signedTransactions = signTransactionResult.map(({ signedTransaction }, index) => {
+            const inputTransaction = transactions[index];
+            if (isVersionedTransaction(inputTransaction)) {
+                return web3_js.VersionedTransaction.deserialize(signedTransaction);
+            }
+            return web3_js.Transaction.from(signedTransaction);
         });
-        if (isVersionedTransaction(transaction)) {
-            return web3_js.VersionedTransaction.deserialize(signTransactionResult[0].signedTransaction);
-        }
-        return web3_js.Transaction.from(signTransactionResult[0].signedTransaction);
+        return signedTransactions;
     });
-    const signAllTransactions = (transactions) => _tslib.__awaiter(void 0, void 0, void 0, function* () { return Promise.all(transactions.map(signTransaction)); });
     const signAndSendTransaction = (transaction) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
         var _c;
         const signAndSendTransactionMethod = (_c = features['solana:signAndSendTransaction']) === null || _c === void 0 ? void 0 : _c.signAndSendTransaction;

package/src/injected/walletStandard/createSolanaSignerFromWalletStandard/createSolanaSignerFromWalletStandard.js

@@ -71,20 +71,30 @@ const createSolanaSignerFromWalletStandard = ({ wallet, walletConnector, }) => {
         return `solana:${cluster}`;
     };
     const signTransaction = (transaction) => __awaiter(void 0, void 0, void 0, function* () {
+        const signedTransactions = yield signAllTransactions([transaction]);
+        return signedTransactions[0];
+    });
+    const signAllTransactions = (transactions) => __awaiter(void 0, void 0, void 0, function* () {
+        const signTransactionMethod = features['solana:signTransaction'].signTransaction;
         const account = yield getCurrentAccount();
-        const signTransactionResult = yield features['solana:signTransaction'].signTransaction({
+        const chain = getChain();
+        const transactionsInput = transactions.map((transaction) => ({
             account,
-            chain: getChain(),
+            chain,
             transaction: transaction.serialize({
                 requireAllSignatures: false,
             }),
+        }));
+        const signTransactionResult = yield signTransactionMethod(...transactionsInput);
+        const signedTransactions = signTransactionResult.map(({ signedTransaction }, index) => {
+            const inputTransaction = transactions[index];
+            if (isVersionedTransaction(inputTransaction)) {
+                return VersionedTransaction.deserialize(signedTransaction);
+            }
+            return Transaction.from(signedTransaction);
         });
-        if (isVersionedTransaction(transaction)) {
-            return VersionedTransaction.deserialize(signTransactionResult[0].signedTransaction);
-        }
-        return Transaction.from(signTransactionResult[0].signedTransaction);
+        return signedTransactions;
     });
-    const signAllTransactions = (transactions) => __awaiter(void 0, void 0, void 0, function* () { return Promise.all(transactions.map(signTransaction)); });
     const signAndSendTransaction = (transaction) => __awaiter(void 0, void 0, void 0, function* () {
         var _c;
         const signAndSendTransactionMethod = (_c = features['solana:signAndSendTransaction']) === null || _c === void 0 ? void 0 : _c.signAndSendTransaction;

package/src/phantomRedirect/PhantomRedirect/PhantomRedirect.cjs

@@ -14,6 +14,7 @@ var clearRedirectUrlForPhantom = require('../clearRedirectUrlForPhantom/clearRed
 var decryptPayload = require('../decryptPayload/decryptPayload.cjs');
 var encryptPayload = require('../encryptPayload/encryptPayload.cjs');
 var storage = require('../storage/storage.cjs');
+var logger = require('../../utils/logger.cjs');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -29,6 +30,59 @@ class PhantomRedirect extends solanaCore.SolanaWalletConnector {
     getMethod() {
         throw new Error('Method not implemented.');
     }
+    /**
+     * Sets up a Promise/listener pattern for native mobile redirects.
+     * Returns undefined if not on native mobile.
+     */
+    setupNativeMobileListener({ eventName, methodName, getResult, shouldIgnoreEvent, }) {
+        if (!utils.PlatformService.isNativeMobile) {
+            return undefined;
+        }
+        const requestId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        storage.storage.requestId.set(requestId);
+        logger.logger.logVerboseTroubleshootingMessage(`[PhantomRedirect] ${methodName} - setting up listener`, { requestId });
+        return new Promise((resolve, reject) => {
+            const listener = (event) => {
+                // Check requestId mismatch or custom validation
+                if (event.requestId !== requestId ||
+                    (shouldIgnoreEvent === null || shouldIgnoreEvent === void 0 ? void 0 : shouldIgnoreEvent(event, requestId))) {
+                    logger.logger.logVerboseTroubleshootingMessage(`[PhantomRedirect] ${methodName} - ignoring event (requestId mismatch)`, {
+                        expectedRequestId: requestId,
+                        receivedRequestId: event.requestId,
+                    });
+                    return;
+                }
+                logger.logger.logVerboseTroubleshootingMessage(`[PhantomRedirect] ${methodName} - listener received matching event`, { errorCode: event.errorCode, requestId });
+                // Clean up this listener
+                this.off(eventName, listener);
+                if (event.errorCode) {
+                    reject(new Error(event.errorMessage || event.errorCode));
+                }
+                else {
+                    resolve(getResult(event));
+                }
+            };
+            this.on(eventName, listener);
+        });
+    }
+    /**
+     * Encrypts payload, builds Phantom redirect URL, stores method, and opens URL.
+     */
+    openPhantomUrl({ payload, sharedSecret, encryptionPublicKey, phantomEndpoint, methodToStore, }) {
+        const [nonce, encryptedPayload] = encryptPayload.encryptPayload(payload, sharedSecret);
+        const params = new URLSearchParams({
+            dapp_encryption_public_key: bs58__default["default"].encode(encryptionPublicKey),
+            nonce: bs58__default["default"].encode(nonce),
+            payload: bs58__default["default"].encode(encryptedPayload),
+            redirect_link: clearRedirectUrlForPhantom.clearRedirectUrlForPhantom(utils.PlatformService.getUrl()),
+        });
+        const url = buildUrl.buildUrl(phantomEndpoint, params);
+        storage.storage.method.set(methodToStore);
+        logger.logger.debug(`[PhantomRedirect] ${methodToStore} - opening Phantom`, {
+            isNativeMobile: utils.PlatformService.isNativeMobile,
+        });
+        utils.PlatformService.openURL(url);
+    }
     getAddress() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             const address = storage.storage.address.get();
@@ -92,36 +146,58 @@ class PhantomRedirect extends solanaCore.SolanaWalletConnector {
     }
     signMessage(messageToSign) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
+            logger.logger.debug('[PhantomRedirect] signMessage called', {
+                messageLength: messageToSign.length,
+                messagePreview: messageToSign.substring(0, 200),
+            });
             const { session, sharedSecret, encryptionPublicKey } = this.getInputsOrThrow('signMessage', [], ['session', 'sharedSecret', 'encryptionPublicKey']);
             storage.storage.message.set(messageToSign);
             const payload = {
                 message: bs58__default["default"].encode(Buffer.from(messageToSign)),
                 session,
             };
-            const [nonce, encryptedPayload] = encryptPayload.encryptPayload(payload, sharedSecret);
-            const params = new URLSearchParams({
-                dapp_encryption_public_key: bs58__default["default"].encode(encryptionPublicKey),
-                nonce: bs58__default["default"].encode(nonce),
-                payload: bs58__default["default"].encode(encryptedPayload),
-                redirect_link: clearRedirectUrlForPhantom.clearRedirectUrlForPhantom(utils.PlatformService.getUrl()),
+            this.openPhantomUrl({
+                encryptionPublicKey,
+                methodToStore: 'signMessage',
+                payload,
+                phantomEndpoint: 'signMessage',
+                sharedSecret,
             });
-            const url = buildUrl.buildUrl('signMessage', params);
-            storage.storage.method.set('signMessage');
-            utils.PlatformService.openURL(url);
-            // throwing this to prevent local storage from being cleared.
-            // when verifying signature, the SDK calls endSession when no
-            // signature is returned. in the case of phantom mobile, a signature
-            // is not returned from signMessage, so an error will always be thrown.
-            // this is a workaround to prevent the SDK from clearing local storage
-            // ideally we would figure out how to:
-            //   1. kick off the sign message on one tab
-            //   2. resume the process on that tab after the user signs in phantom
+            const nativePromise = this.setupNativeMobileListener({
+                eventName: 'signMessage',
+                getResult: (event) => event.signature,
+                methodName: 'signMessage',
+                shouldIgnoreEvent: (event) => event.message !== messageToSign,
+            });
+            if (nativePromise) {
+                return nativePromise;
+            }
+            // On mobile web browsers, Phantom opens in a new tab and redirects back
+            // to a fresh page load, losing this Promise/listener context.
+            // The signature is handled via PhantomRedirectContext which reads URL
+            // params on page load and emits the 'signMessage' event, but there's
+            // no way to return it to the original caller. Throwing here prevents
+            // the SDK from clearing local storage when no signature is returned.
+            logger.logger.debug('[PhantomRedirect] signMessage - mobile web, throwing ignore error');
             throw new Error('ignore');
         });
     }
     extractSignature() {
+        var _a;
+        logger.logger.debug('[PhantomRedirect] extractSignature called');
         const { data, nonce, sharedSecret, message } = this.getInputsOrThrow('extractSignature', ['data', 'nonce'], ['sharedSecret', 'message']);
+        logger.logger.debug('[PhantomRedirect] extractSignature - retrieved from storage', {
+            dataPresent: Boolean(data),
+            message,
+            messageLength: message === null || message === void 0 ? void 0 : message.length,
+            noncePresent: Boolean(nonce),
+            sharedSecretPresent: Boolean(sharedSecret),
+        });
         const signMessageData = decryptPayload.decryptPayload(data, nonce, sharedSecret);
+        logger.logger.debug('[PhantomRedirect] extractSignature - decrypted payload', {
+            signature: signMessageData.signature,
+            signatureLength: (_a = signMessageData.signature) === null || _a === void 0 ? void 0 : _a.length,
+        });
         return {
             message,
             signature: signMessageData.signature,
@@ -136,14 +212,55 @@ class PhantomRedirect extends solanaCore.SolanaWalletConnector {
     extractTransaction() {
         const { data, nonce, sharedSecret } = this.getInputsOrThrow('extractTransaction', ['data', 'nonce'], ['sharedSecret']);
         const signTransactionData = decryptPayload.decryptPayload(data, nonce, sharedSecret);
-        const decodedTransaction = web3_js.Transaction.from(bs58__default["default"].decode(signTransactionData.transaction));
-        return decodedTransaction;
+        const transactionBytes = bs58__default["default"].decode(signTransactionData.transaction);
+        // Try to deserialize as VersionedTransaction first, fall back to legacy Transaction
+        // VersionedTransaction has a version prefix byte, legacy transactions don't
+        try {
+            return web3_js.VersionedTransaction.deserialize(transactionBytes);
+        }
+        catch (_a) {
+            // If VersionedTransaction fails, try legacy Transaction
+            return web3_js.Transaction.from(transactionBytes);
+        }
+    }
+    /**
+     * Extracts the signed transaction and sends it to the network.
+     * Used for signAndSendTransaction since Phantom redirect doesn't support it natively.
+     * @returns The transaction signature
+     */
+    extractAndSendTransaction() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            logger.logger.debug('[PhantomRedirect] extractAndSendTransaction called');
+            const signedTransaction = this.extractTransaction();
+            // Get stored send options if any
+            const sendOptionsJson = storage.storage.sendOptions.get();
+            storage.storage.sendOptions.remove();
+            const sendOptions = sendOptionsJson
+                ? JSON.parse(sendOptionsJson)
+                : undefined;
+            logger.logger.debug('[PhantomRedirect] Sending transaction to network', {
+                hasSendOptions: Boolean(sendOptions),
+                isVersioned: signedTransaction instanceof web3_js.VersionedTransaction,
+            });
+            // Send the signed transaction to the network
+            const serialized = signedTransaction.serialize();
+            const signature = yield this.getWalletClient().sendRawTransaction(serialized, sendOptions);
+            logger.logger.debug('[PhantomRedirect] Transaction sent successfully', {
+                signature,
+            });
+            return signature;
+        });
     }
     consumeMethod() {
         const method = storage.storage.method.get();
         storage.storage.method.remove();
         return method;
     }
+    consumeRequestId() {
+        const requestId = storage.storage.requestId.get();
+        storage.storage.requestId.remove();
+        return requestId;
+    }
     getSigner() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             const address = storage.storage.address.get();
@@ -206,55 +323,67 @@ class PhantomRedirect extends solanaCore.SolanaWalletConnector {
                         session,
                         transactions: serializedTransactions,
                     };
-                    const [nonce, encryptedPayload] = encryptPayload.encryptPayload(payload, sharedSecret);
-                    const params = new URLSearchParams({
-                        dapp_encryption_public_key: bs58__default["default"].encode(encryptionPublicKey),
-                        nonce: bs58__default["default"].encode(nonce),
-                        payload: bs58__default["default"].encode(encryptedPayload),
-                        redirect_link: clearRedirectUrlForPhantom.clearRedirectUrlForPhantom(utils.PlatformService.getUrl()),
+                    this.openPhantomUrl({
+                        encryptionPublicKey,
+                        methodToStore: 'signAllTransactions',
+                        payload,
+                        phantomEndpoint: 'signAllTransactions',
+                        sharedSecret,
+                    });
+                    const nativePromise = this.setupNativeMobileListener({
+                        eventName: 'signAllTransactions',
+                        getResult: (event) => (event.transactions || []),
+                        methodName: 'signAllTransactions',
                     });
-                    const url = buildUrl.buildUrl('signAllTransactions', params);
-                    utils.PlatformService.openURL(url);
-                    // actual signatures will be retrieved upon redirect back to dapp
+                    if (nativePromise) {
+                        return nativePromise;
+                    }
+                    // On mobile web browsers, return empty array
+                    // The signed transactions are handled via PhantomRedirectContext
                     return [];
                 }),
                 signAndSendTransaction: (transaction, options) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                    // Phantom redirect doesn't support signAndSendTransaction natively,
+                    // so we use signTransaction and then send it manually after redirect
+                    const serializedTransaction = bs58__default["default"].encode(transaction.serialize({ requireAllSignatures: false }));
                     const { session, sharedSecret, encryptionPublicKey } = this.getInputsOrThrow('signAndSendTransaction', [], ['session', 'sharedSecret', 'encryptionPublicKey']);
                     const payload = {
-                        options,
                         session,
-                        transaction: bs58__default["default"].encode(transaction.serialize({ requireAllSignatures: false })),
+                        transaction: serializedTransaction,
                     };
-                    const [nonce, encryptedPayload] = encryptPayload.encryptPayload(payload, sharedSecret);
-                    const params = new URLSearchParams({
-                        dapp_encryption_public_key: bs58__default["default"].encode(encryptionPublicKey),
-                        nonce: bs58__default["default"].encode(nonce),
-                        payload: bs58__default["default"].encode(encryptedPayload),
-                        redirect_link: clearRedirectUrlForPhantom.clearRedirectUrlForPhantom(utils.PlatformService.getUrl()),
+                    // Store send options to use when sending the transaction
+                    if (options) {
+                        storage.storage.sendOptions.set(JSON.stringify(options));
+                    }
+                    // Use signTransaction endpoint since Phantom redirect doesn't support signAndSendTransaction
+                    // but store method as signAndSendTransaction so we know to send after signing
+                    this.openPhantomUrl({
+                        encryptionPublicKey,
+                        methodToStore: 'signAndSendTransaction',
+                        payload,
+                        phantomEndpoint: 'signTransaction',
+                        sharedSecret,
                     });
-                    const url = buildUrl.buildUrl('signAndSendTransaction', params);
-                    storage.storage.method.set('signAndSendTransaction');
-                    utils.PlatformService.openURL(url);
-                    // actual signature will be retrived upon redirect back to dapp
+                    const nativePromise = this.setupNativeMobileListener({
+                        eventName: 'signAndSendTransaction',
+                        getResult: (event) => ({ signature: event.signature || '' }),
+                        methodName: 'signAndSendTransaction',
+                    });
+                    if (nativePromise) {
+                        return nativePromise;
+                    }
+                    // On mobile web browsers, return empty signature
+                    // The actual signature is handled via PhantomRedirectContext
                     return { signature: '' };
                 }),
                 signMessage: (message) => _tslib.__awaiter(this, void 0, void 0, function* () {
-                    const { session, sharedSecret, encryptionPublicKey } = this.getInputsOrThrow('signMessage', [], ['session', 'sharedSecret', 'encryptionPublicKey']);
-                    const payload = {
-                        message: bs58__default["default"].encode(Buffer.from(message)),
-                        session,
+                    // Delegate to connector's signMessage which properly stores method and sets up listeners
+                    const messageString = new TextDecoder().decode(message);
+                    const signature = yield this.signMessage(messageString);
+                    // Convert signature string to Uint8Array for ISolana interface
+                    return {
+                        signature: signature ? bs58__default["default"].decode(signature) : new Uint8Array(0),
                     };
-                    const [nonce, encryptedPayload] = encryptPayload.encryptPayload(payload, sharedSecret);
-                    const params = new URLSearchParams({
-                        dapp_encryption_public_key: bs58__default["default"].encode(encryptionPublicKey),
-                        nonce: bs58__default["default"].encode(nonce),
-                        payload: bs58__default["default"].encode(encryptedPayload),
-                        redirect_link: clearRedirectUrlForPhantom.clearRedirectUrlForPhantom(utils.PlatformService.getUrl()),
-                    });
-                    const url = buildUrl.buildUrl('signMessage', params);
-                    utils.PlatformService.openURL(url);
-                    // actual signature will be retrived upon redirect back to dapp
-                    return { signature: Buffer.from('') };
                 }),
                 signTransaction: (transaction) => _tslib.__awaiter(this, void 0, void 0, function* () {
                     const serializedTransaction = bs58__default["default"].encode(transaction.serialize({
@@ -265,15 +394,23 @@ class PhantomRedirect extends solanaCore.SolanaWalletConnector {
                         session,
                         transaction: serializedTransaction,
                     };
-                    const [nonce, encryptedPayload] = encryptPayload.encryptPayload(payload, sharedSecret);
-                    const params = new URLSearchParams({
-                        dapp_encryption_public_key: bs58__default["default"].encode(encryptionPublicKey),
-                        nonce: bs58__default["default"].encode(nonce),
-                        payload: bs58__default["default"].encode(encryptedPayload),
-                        redirect_link: clearRedirectUrlForPhantom.clearRedirectUrlForPhantom(utils.PlatformService.getUrl()),
+                    this.openPhantomUrl({
+                        encryptionPublicKey,
+                        methodToStore: 'signTransaction',
+                        payload,
+                        phantomEndpoint: 'signTransaction',
+                        sharedSecret,
+                    });
+                    const nativePromise = this.setupNativeMobileListener({
+                        eventName: 'signTransaction',
+                        getResult: (event) => event.transaction,
+                        methodName: 'signTransaction',
                     });
-                    const url = buildUrl.buildUrl('signTransaction', params);
-                    utils.PlatformService.openURL(url);
+                    if (nativePromise) {
+                        return nativePromise;
+                    }
+                    // On mobile web browsers, return the original transaction
+                    // The signed transaction is handled via PhantomRedirectContext
                     return transaction;
                 }),
             };

package/src/phantomRedirect/PhantomRedirect/PhantomRedirect.d.ts

@@ -1,4 +1,4 @@
-import { Transaction } from '@solana/web3.js';
+import { Transaction, VersionedTransaction } from '@solana/web3.js';
 import { SolanaWalletConnector, type ISolana } from '@dynamic-labs/solana-core';
 import { IPhantomRedirectConnector } from '@dynamic-labs/wallet-connector-core';
 import { Method } from '../types';
@@ -7,6 +7,15 @@ export declare class PhantomRedirect extends SolanaWalletConnector implements IP
     overrideKey: string;
     constructor(props: any);
     getMethod(): 'signMessage' | 'signAndSendTransaction' | undefined;
+    /**
+     * Sets up a Promise/listener pattern for native mobile redirects.
+     * Returns undefined if not on native mobile.
+     */
+    private setupNativeMobileListener;
+    /**
+     * Encrypts payload, builds Phantom redirect URL, stores method, and opens URL.
+     */
+    private openPhantomUrl;
     getAddress(): Promise<string | undefined>;
     connect(): Promise<void>;
     getSession(): Promise<string>;
@@ -16,8 +25,15 @@ export declare class PhantomRedirect extends SolanaWalletConnector implements IP
         message: string;
     };
     extractTransactions(): Transaction[];
-    extractTransaction(): Transaction;
+    extractTransaction(): Transaction | VersionedTransaction;
+    /**
+     * Extracts the signed transaction and sends it to the network.
+     * Used for signAndSendTransaction since Phantom redirect doesn't support it natively.
+     * @returns The transaction signature
+     */
+    extractAndSendTransaction(): Promise<string>;
     consumeMethod(): Method | undefined;
+    consumeRequestId(): string | undefined;
     getSigner(): Promise<ISolana | undefined>;
     getConnectedAccounts(): Promise<string[]>;
     endSession(): Promise<void>;