@dynamic-labs/solana 4.49.0 → 4.50.1

package/src/phantomRedirect/PhantomRedirect/PhantomRedirect.js

@@ -1,15 +1,16 @@
 'use client'
 import { __awaiter } from '../../../_virtual/_tslib.js';
-import { PublicKey, Transaction } from '@solana/web3.js';
+import { Transaction, VersionedTransaction, PublicKey } from '@solana/web3.js';
 import bs58 from 'bs58';
 import nacl from 'tweetnacl';
 import { SolanaWalletConnector } from '@dynamic-labs/solana-core';
-import { StorageService, PHANTOM_REDIRECT_CONNECTION_TYPE_KEY, PlatformService } from '@dynamic-labs/utils';
+import { PlatformService, StorageService, PHANTOM_REDIRECT_CONNECTION_TYPE_KEY } from '@dynamic-labs/utils';
 import { buildUrl } from '../buildUrl/buildUrl.js';
 import { clearRedirectUrlForPhantom } from '../clearRedirectUrlForPhantom/clearRedirectUrlForPhantom.js';
 import { decryptPayload } from '../decryptPayload/decryptPayload.js';
 import { encryptPayload } from '../encryptPayload/encryptPayload.js';
 import { storage, clearStorage } from '../storage/storage.js';
+import { logger } from '../../utils/logger.js';
 
 class PhantomRedirect extends SolanaWalletConnector {
     constructor(props) {
@@ -20,6 +21,59 @@ class PhantomRedirect extends 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 (!PlatformService.isNativeMobile) {
+            return undefined;
+        }
+        const requestId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        storage.requestId.set(requestId);
+        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.logVerboseTroubleshootingMessage(`[PhantomRedirect] ${methodName} - ignoring event (requestId mismatch)`, {
+                        expectedRequestId: requestId,
+                        receivedRequestId: event.requestId,
+                    });
+                    return;
+                }
+                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(payload, sharedSecret);
+        const params = new URLSearchParams({
+            dapp_encryption_public_key: bs58.encode(encryptionPublicKey),
+            nonce: bs58.encode(nonce),
+            payload: bs58.encode(encryptedPayload),
+            redirect_link: clearRedirectUrlForPhantom(PlatformService.getUrl()),
+        });
+        const url = buildUrl(phantomEndpoint, params);
+        storage.method.set(methodToStore);
+        logger.debug(`[PhantomRedirect] ${methodToStore} - opening Phantom`, {
+            isNativeMobile: PlatformService.isNativeMobile,
+        });
+        PlatformService.openURL(url);
+    }
     getAddress() {
         return __awaiter(this, void 0, void 0, function* () {
             const address = storage.address.get();
@@ -83,36 +137,58 @@ class PhantomRedirect extends SolanaWalletConnector {
     }
     signMessage(messageToSign) {
         return __awaiter(this, void 0, void 0, function* () {
+            logger.debug('[PhantomRedirect] signMessage called', {
+                messageLength: messageToSign.length,
+                messagePreview: messageToSign.substring(0, 200),
+            });
             const { session, sharedSecret, encryptionPublicKey } = this.getInputsOrThrow('signMessage', [], ['session', 'sharedSecret', 'encryptionPublicKey']);
             storage.message.set(messageToSign);
             const payload = {
                 message: bs58.encode(Buffer.from(messageToSign)),
                 session,
             };
-            const [nonce, encryptedPayload] = encryptPayload(payload, sharedSecret);
-            const params = new URLSearchParams({
-                dapp_encryption_public_key: bs58.encode(encryptionPublicKey),
-                nonce: bs58.encode(nonce),
-                payload: bs58.encode(encryptedPayload),
-                redirect_link: clearRedirectUrlForPhantom(PlatformService.getUrl()),
+            this.openPhantomUrl({
+                encryptionPublicKey,
+                methodToStore: 'signMessage',
+                payload,
+                phantomEndpoint: 'signMessage',
+                sharedSecret,
             });
-            const url = buildUrl('signMessage', params);
-            storage.method.set('signMessage');
-            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.debug('[PhantomRedirect] signMessage - mobile web, throwing ignore error');
             throw new Error('ignore');
         });
     }
     extractSignature() {
+        var _a;
+        logger.debug('[PhantomRedirect] extractSignature called');
         const { data, nonce, sharedSecret, message } = this.getInputsOrThrow('extractSignature', ['data', 'nonce'], ['sharedSecret', 'message']);
+        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(data, nonce, sharedSecret);
+        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,
@@ -127,14 +203,55 @@ class PhantomRedirect extends SolanaWalletConnector {
     extractTransaction() {
         const { data, nonce, sharedSecret } = this.getInputsOrThrow('extractTransaction', ['data', 'nonce'], ['sharedSecret']);
         const signTransactionData = decryptPayload(data, nonce, sharedSecret);
-        const decodedTransaction = Transaction.from(bs58.decode(signTransactionData.transaction));
-        return decodedTransaction;
+        const transactionBytes = bs58.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 VersionedTransaction.deserialize(transactionBytes);
+        }
+        catch (_a) {
+            // If VersionedTransaction fails, try legacy Transaction
+            return 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 __awaiter(this, void 0, void 0, function* () {
+            logger.debug('[PhantomRedirect] extractAndSendTransaction called');
+            const signedTransaction = this.extractTransaction();
+            // Get stored send options if any
+            const sendOptionsJson = storage.sendOptions.get();
+            storage.sendOptions.remove();
+            const sendOptions = sendOptionsJson
+                ? JSON.parse(sendOptionsJson)
+                : undefined;
+            logger.debug('[PhantomRedirect] Sending transaction to network', {
+                hasSendOptions: Boolean(sendOptions),
+                isVersioned: signedTransaction instanceof VersionedTransaction,
+            });
+            // Send the signed transaction to the network
+            const serialized = signedTransaction.serialize();
+            const signature = yield this.getWalletClient().sendRawTransaction(serialized, sendOptions);
+            logger.debug('[PhantomRedirect] Transaction sent successfully', {
+                signature,
+            });
+            return signature;
+        });
     }
     consumeMethod() {
         const method = storage.method.get();
         storage.method.remove();
         return method;
     }
+    consumeRequestId() {
+        const requestId = storage.requestId.get();
+        storage.requestId.remove();
+        return requestId;
+    }
     getSigner() {
         return __awaiter(this, void 0, void 0, function* () {
             const address = storage.address.get();
@@ -197,55 +314,67 @@ class PhantomRedirect extends SolanaWalletConnector {
                         session,
                         transactions: serializedTransactions,
                     };
-                    const [nonce, encryptedPayload] = encryptPayload(payload, sharedSecret);
-                    const params = new URLSearchParams({
-                        dapp_encryption_public_key: bs58.encode(encryptionPublicKey),
-                        nonce: bs58.encode(nonce),
-                        payload: bs58.encode(encryptedPayload),
-                        redirect_link: clearRedirectUrlForPhantom(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('signAllTransactions', params);
-                    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) => __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.encode(transaction.serialize({ requireAllSignatures: false }));
                     const { session, sharedSecret, encryptionPublicKey } = this.getInputsOrThrow('signAndSendTransaction', [], ['session', 'sharedSecret', 'encryptionPublicKey']);
                     const payload = {
-                        options,
                         session,
-                        transaction: bs58.encode(transaction.serialize({ requireAllSignatures: false })),
+                        transaction: serializedTransaction,
                     };
-                    const [nonce, encryptedPayload] = encryptPayload(payload, sharedSecret);
-                    const params = new URLSearchParams({
-                        dapp_encryption_public_key: bs58.encode(encryptionPublicKey),
-                        nonce: bs58.encode(nonce),
-                        payload: bs58.encode(encryptedPayload),
-                        redirect_link: clearRedirectUrlForPhantom(PlatformService.getUrl()),
+                    // Store send options to use when sending the transaction
+                    if (options) {
+                        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('signAndSendTransaction', params);
-                    storage.method.set('signAndSendTransaction');
-                    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) => __awaiter(this, void 0, void 0, function* () {
-                    const { session, sharedSecret, encryptionPublicKey } = this.getInputsOrThrow('signMessage', [], ['session', 'sharedSecret', 'encryptionPublicKey']);
-                    const payload = {
-                        message: bs58.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.decode(signature) : new Uint8Array(0),
                     };
-                    const [nonce, encryptedPayload] = encryptPayload(payload, sharedSecret);
-                    const params = new URLSearchParams({
-                        dapp_encryption_public_key: bs58.encode(encryptionPublicKey),
-                        nonce: bs58.encode(nonce),
-                        payload: bs58.encode(encryptedPayload),
-                        redirect_link: clearRedirectUrlForPhantom(PlatformService.getUrl()),
-                    });
-                    const url = buildUrl('signMessage', params);
-                    PlatformService.openURL(url);
-                    // actual signature will be retrived upon redirect back to dapp
-                    return { signature: Buffer.from('') };
                 }),
                 signTransaction: (transaction) => __awaiter(this, void 0, void 0, function* () {
                     const serializedTransaction = bs58.encode(transaction.serialize({
@@ -256,15 +385,23 @@ class PhantomRedirect extends SolanaWalletConnector {
                         session,
                         transaction: serializedTransaction,
                     };
-                    const [nonce, encryptedPayload] = encryptPayload(payload, sharedSecret);
-                    const params = new URLSearchParams({
-                        dapp_encryption_public_key: bs58.encode(encryptionPublicKey),
-                        nonce: bs58.encode(nonce),
-                        payload: bs58.encode(encryptedPayload),
-                        redirect_link: clearRedirectUrlForPhantom(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('signTransaction', params);
-                    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/storage/storage.cjs

@@ -3,13 +3,26 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var logger = require('../../utils/logger.cjs');
+
 const storage = {
     address: {
-        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_wallet_address')) !== null && _a !== void 0 ? _a : undefined; },
+        get: () => {
+            var _a;
+            const value = (_a = localStorage.getItem('dynamic_phantom_wallet_address')) !== null && _a !== void 0 ? _a : undefined;
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] address.get', {
+                value,
+            });
+            return value;
+        },
         remove: () => {
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] address.remove');
             localStorage.removeItem('dynamic_phantom_wallet_address');
         },
         set: (address) => {
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] address.set', {
+                address: address.toString(),
+            });
             localStorage.setItem('dynamic_phantom_wallet_address', address.toString());
         },
     },
@@ -44,49 +57,109 @@ const storage = {
         },
     },
     message: {
-        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_message_to_sign')) !== null && _a !== void 0 ? _a : undefined; },
+        get: () => {
+            var _a;
+            const value = (_a = localStorage.getItem('dynamic_phantom_message_to_sign')) !== null && _a !== void 0 ? _a : undefined;
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] message.get', {
+                hasMessage: Boolean(value),
+                messageLength: value === null || value === void 0 ? void 0 : value.length,
+                messagePreview: value === null || value === void 0 ? void 0 : value.substring(0, 100),
+            });
+            return value;
+        },
         remove: () => {
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] message.remove');
             localStorage.removeItem('dynamic_phantom_message_to_sign');
         },
         set: (message) => {
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] message.set', {
+                messageLength: message.length,
+                messagePreview: message.substring(0, 100),
+            });
             localStorage.setItem('dynamic_phantom_message_to_sign', message);
         },
     },
     method: {
-        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_method')) !== null && _a !== void 0 ? _a : undefined; },
+        get: () => {
+            var _a;
+            const value = (_a = localStorage.getItem('dynamic_phantom_method')) !== null && _a !== void 0 ? _a : undefined;
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] method.get', {
+                value,
+            });
+            return value;
+        },
         remove: () => {
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] method.remove');
             localStorage.removeItem('dynamic_phantom_method');
         },
         set: (method) => {
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] method.set', {
+                method,
+            });
             localStorage.setItem('dynamic_phantom_method', method);
         },
     },
+    requestId: {
+        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_request_id')) !== null && _a !== void 0 ? _a : undefined; },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_request_id');
+        },
+        set: (requestId) => {
+            localStorage.setItem('dynamic_phantom_request_id', requestId);
+        },
+    },
+    sendOptions: {
+        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_send_options')) !== null && _a !== void 0 ? _a : undefined; },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_send_options');
+        },
+        set: (options) => {
+            localStorage.setItem('dynamic_phantom_send_options', options);
+        },
+    },
     session: {
-        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_session')) !== null && _a !== void 0 ? _a : undefined; },
+        get: () => {
+            var _a;
+            const value = (_a = localStorage.getItem('dynamic_phantom_session')) !== null && _a !== void 0 ? _a : undefined;
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] session.get', {
+                hasSession: Boolean(value),
+            });
+            return value;
+        },
         remove: () => {
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] session.remove');
             localStorage.removeItem('dynamic_phantom_session');
         },
         set: (session) => {
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] session.set', {
+                session,
+            });
             localStorage.setItem('dynamic_phantom_session', session);
         },
     },
     sharedSecret: {
         get: () => {
             const rawSharedSecret = localStorage.getItem('dynamic_phantom_shared_secret');
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] sharedSecret.get', { hasSharedSecret: Boolean(rawSharedSecret) });
             if (!rawSharedSecret) {
                 return undefined;
             }
             return new Uint8Array(JSON.parse(rawSharedSecret));
         },
         remove: () => {
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] sharedSecret.remove');
             localStorage.removeItem('dynamic_phantom_shared_secret');
         },
         set: (sharedSecret) => {
+            logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] sharedSecret.set', {
+                sharedSecretLength: sharedSecret.length,
+            });
             localStorage.setItem('dynamic_phantom_shared_secret', JSON.stringify([...sharedSecret]));
         },
     },
 };
 const clearStorage = () => {
+    logger.logger.logVerboseTroubleshootingMessage('[PhantomStorage] clearStorage called');
     for (const key in storage) {
         storage[key].remove();
     }

package/src/phantomRedirect/storage/storage.d.ts

@@ -26,6 +26,16 @@ export declare const storage: {
         remove: () => void;
         set: (method: Method) => void;
     };
+    requestId: {
+        get: () => string | undefined;
+        remove: () => void;
+        set: (requestId: string) => void;
+    };
+    sendOptions: {
+        get: () => string | undefined;
+        remove: () => void;
+        set: (options: string) => void;
+    };
     session: {
         get: () => string | undefined;
         remove: () => void;

package/src/phantomRedirect/storage/storage.js

@@ -1,11 +1,24 @@
 'use client'
+import { logger } from '../../utils/logger.js';
+
 const storage = {
     address: {
-        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_wallet_address')) !== null && _a !== void 0 ? _a : undefined; },
+        get: () => {
+            var _a;
+            const value = (_a = localStorage.getItem('dynamic_phantom_wallet_address')) !== null && _a !== void 0 ? _a : undefined;
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] address.get', {
+                value,
+            });
+            return value;
+        },
         remove: () => {
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] address.remove');
             localStorage.removeItem('dynamic_phantom_wallet_address');
         },
         set: (address) => {
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] address.set', {
+                address: address.toString(),
+            });
             localStorage.setItem('dynamic_phantom_wallet_address', address.toString());
         },
     },
@@ -40,49 +53,109 @@ const storage = {
         },
     },
     message: {
-        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_message_to_sign')) !== null && _a !== void 0 ? _a : undefined; },
+        get: () => {
+            var _a;
+            const value = (_a = localStorage.getItem('dynamic_phantom_message_to_sign')) !== null && _a !== void 0 ? _a : undefined;
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] message.get', {
+                hasMessage: Boolean(value),
+                messageLength: value === null || value === void 0 ? void 0 : value.length,
+                messagePreview: value === null || value === void 0 ? void 0 : value.substring(0, 100),
+            });
+            return value;
+        },
         remove: () => {
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] message.remove');
             localStorage.removeItem('dynamic_phantom_message_to_sign');
         },
         set: (message) => {
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] message.set', {
+                messageLength: message.length,
+                messagePreview: message.substring(0, 100),
+            });
             localStorage.setItem('dynamic_phantom_message_to_sign', message);
         },
     },
     method: {
-        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_method')) !== null && _a !== void 0 ? _a : undefined; },
+        get: () => {
+            var _a;
+            const value = (_a = localStorage.getItem('dynamic_phantom_method')) !== null && _a !== void 0 ? _a : undefined;
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] method.get', {
+                value,
+            });
+            return value;
+        },
         remove: () => {
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] method.remove');
             localStorage.removeItem('dynamic_phantom_method');
         },
         set: (method) => {
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] method.set', {
+                method,
+            });
             localStorage.setItem('dynamic_phantom_method', method);
         },
     },
+    requestId: {
+        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_request_id')) !== null && _a !== void 0 ? _a : undefined; },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_request_id');
+        },
+        set: (requestId) => {
+            localStorage.setItem('dynamic_phantom_request_id', requestId);
+        },
+    },
+    sendOptions: {
+        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_send_options')) !== null && _a !== void 0 ? _a : undefined; },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_send_options');
+        },
+        set: (options) => {
+            localStorage.setItem('dynamic_phantom_send_options', options);
+        },
+    },
     session: {
-        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_session')) !== null && _a !== void 0 ? _a : undefined; },
+        get: () => {
+            var _a;
+            const value = (_a = localStorage.getItem('dynamic_phantom_session')) !== null && _a !== void 0 ? _a : undefined;
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] session.get', {
+                hasSession: Boolean(value),
+            });
+            return value;
+        },
         remove: () => {
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] session.remove');
             localStorage.removeItem('dynamic_phantom_session');
         },
         set: (session) => {
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] session.set', {
+                session,
+            });
             localStorage.setItem('dynamic_phantom_session', session);
         },
     },
     sharedSecret: {
         get: () => {
             const rawSharedSecret = localStorage.getItem('dynamic_phantom_shared_secret');
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] sharedSecret.get', { hasSharedSecret: Boolean(rawSharedSecret) });
             if (!rawSharedSecret) {
                 return undefined;
             }
             return new Uint8Array(JSON.parse(rawSharedSecret));
         },
         remove: () => {
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] sharedSecret.remove');
             localStorage.removeItem('dynamic_phantom_shared_secret');
         },
         set: (sharedSecret) => {
+            logger.logVerboseTroubleshootingMessage('[PhantomStorage] sharedSecret.set', {
+                sharedSecretLength: sharedSecret.length,
+            });
             localStorage.setItem('dynamic_phantom_shared_secret', JSON.stringify([...sharedSecret]));
         },
     },
 };
 const clearStorage = () => {
+    logger.logVerboseTroubleshootingMessage('[PhantomStorage] clearStorage called');
     for (const key in storage) {
         storage[key].remove();
     }

package/src/phantomRedirect/types.d.ts

@@ -1 +1 @@
-export type Method = 'signMessage' | 'signAndSendTransaction';
+export type Method = 'signMessage' | 'signTransaction' | 'signAllTransactions' | 'signAndSendTransaction';