@reown/appkit-solana-react-native 2.0.0-alpha.3 → 2.0.0-alpha.4

package/src/providers/{PhantomProvider.ts → DeeplinkProvider.ts}

@@ -9,27 +9,24 @@ import type {
   Storage
 } from '@reown/appkit-common-react-native';
 import type {
-  PhantomProviderConfig,
-  PhantomConnectResult,
-  PhantomSession,
+  DeeplinkProviderConfig,
+  DeeplinkConnectResult,
+  DeeplinkSession,
   DecryptedConnectData,
-  PhantomDeeplinkResponse,
+  DeeplinkResponse,
   SignAllTransactionsRequestParams,
   SignMessageRequestParams,
   SignTransactionRequestParams,
-  PhantomRpcMethod,
-  PhantomConnectParams,
-  PhantomDisconnectParams,
-  PhantomSignTransactionParams,
-  PhantomSignMessageParams,
-  PhantomSignAllTransactionsParams,
-  PhantomCluster
+  DeeplinkRpcMethod,
+  DeeplinkConnectParams,
+  DeeplinkDisconnectParams,
+  DeeplinkSignTransactionParams,
+  DeeplinkSignMessageParams,
+  DeeplinkSignAllTransactionsParams,
+  Cluster
 } from '../types';
 import EventEmitter from 'events';
 
-const PHANTOM_BASE_URL = 'https://phantom.app/ul/v1';
-const PHANTOM_PROVIDER_STORAGE_KEY = '@appkit/phantom-provider-session';
-
 export const SOLANA_SIGNING_METHODS = {
   SOLANA_SIGN_TRANSACTION: 'solana_signTransaction',
   SOLANA_SIGN_MESSAGE: 'solana_signMessage',
@@ -43,28 +40,34 @@ function isValidSolanaSigningMethod(method: string): method is SolanaSigningMeth
   return Object.values(SOLANA_SIGNING_METHODS).includes(method as SolanaSigningMethod);
 }
 
-export class PhantomProvider extends EventEmitter implements Provider {
-  private readonly config: PhantomProviderConfig;
+export class DeeplinkProvider extends EventEmitter implements Provider {
+  private readonly config: DeeplinkProviderConfig;
   private dappEncryptionKeyPair: nacl.BoxKeyPair;
-  private currentCluster: PhantomCluster = 'mainnet-beta';
+  private currentCluster: Cluster;
+  private sharedKey: Uint8Array | null = null;
 
   private storage: Storage;
 
   private sessionToken: string | null = null;
   private userPublicKey: string | null = null;
-  private phantomEncryptionPublicKeyBs58: string | null = null;
+  private walletEncryptionPublicKeyBs58: string | null = null;
 
   // Single subscription management - deep links are sequential by nature
   private activeSubscription: { remove: () => void } | null = null;
   private isOperationPending = false;
 
-  constructor(config: PhantomProviderConfig) {
+  constructor(config: DeeplinkProviderConfig) {
     super();
     this.config = config;
+    this.currentCluster = config.cluster ?? 'mainnet-beta';
     this.dappEncryptionKeyPair = config.dappEncryptionKeyPair;
     this.storage = config.storage;
   }
 
+  private getSessionStorageKey(): string {
+    return `@appkit/${this.config.type}-provider-session`;
+  }
+
   /**
    * Cleanup method to be called when the provider is destroyed
    */
@@ -104,13 +107,70 @@ export class PhantomProvider extends EventEmitter implements Provider {
     return !!this.sessionToken && !!this.userPublicKey && !!this.dappEncryptionKeyPair;
   }
 
-  private buildUrl(rpcMethod: PhantomRpcMethod, params: Record<string, string>): string {
+  public getCurrentCluster(): Cluster {
+    return this.currentCluster;
+  }
+
+  private buildUrl(rpcMethod: DeeplinkRpcMethod, params: Record<string, string>): string {
     const query = new URLSearchParams(params).toString();
 
-    return `${PHANTOM_BASE_URL}/${rpcMethod}?${query}`;
+    return `${this.config.baseUrl}/${rpcMethod}?${query}`;
   }
 
-  private getRpcMethodName(method: SolanaSigningMethod): PhantomRpcMethod {
+  /**
+   * Open a deeplink URL and wait for a redirect back to the app. Handles subscription
+   * lifecycle and common error extraction from `errorCode`/`errorMessage` query params.
+   */
+  private async openDeeplinkAndWait<T>(
+    deeplinkUrl: string,
+    processParams: (params: URLSearchParams) => Promise<T> | T,
+    contextLabel: string
+  ): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      const handleDeepLink = async (event: { url: string }) => {
+        try {
+          this.cleanupActiveSubscription();
+          const fullUrl = event.url;
+          if (!fullUrl.startsWith(this.config.appScheme)) {
+            return reject(
+              new Error(`${this.config.type} provider: ${contextLabel}: Unexpected redirect URI.`)
+            );
+          }
+          const params = new URLSearchParams(fullUrl.substring(fullUrl.indexOf('?') + 1));
+          const errorCode = params.get('errorCode');
+          const errorMessage = params.get('errorMessage');
+          if (errorCode) {
+            return reject(
+              new Error(
+                `${this.config.type} provider: ${contextLabel} Failed: ${
+                  errorMessage || 'Unknown error'
+                } (Code: ${errorCode})`
+              )
+            );
+          }
+          const result = await Promise.resolve(processParams(params));
+          resolve(result);
+        } catch (error) {
+          this.cleanupActiveSubscription();
+          reject(error);
+        }
+      };
+
+      const subscription = Linking.addEventListener('url', handleDeepLink);
+      this.setActiveSubscription(subscription);
+
+      Linking.openURL(deeplinkUrl).catch(err => {
+        this.cleanupActiveSubscription();
+        reject(
+          new Error(
+            `${this.config.type} provider: Failed to open wallet for ${contextLabel}: ${err.message}.`
+          )
+        );
+      });
+    });
+  }
+
+  private getRpcMethodName(method: SolanaSigningMethod): DeeplinkRpcMethod {
     switch (method) {
       case SOLANA_SIGNING_METHODS.SOLANA_SIGN_TRANSACTION:
         return 'signTransaction';
@@ -128,27 +188,34 @@ export class PhantomProvider extends EventEmitter implements Provider {
 
   private encryptPayload(
     payload: Record<string, unknown>,
-    phantomPublicKeyBs58ToEncryptFor: string
+    walletPublicKeyBs58: string
   ): { nonce: string; encryptedPayload: string } | null {
-    if (!phantomPublicKeyBs58ToEncryptFor) {
+    if (!walletPublicKeyBs58) {
       return null;
     }
     try {
-      const phantomPublicKeyBytes = bs58.decode(phantomPublicKeyBs58ToEncryptFor);
       const nonce = nacl.randomBytes(nacl.box.nonceLength);
       const payloadBytes = Buffer.from(JSON.stringify(payload), 'utf8');
-      const encryptedPayload = nacl.box(
-        payloadBytes,
-        nonce,
-        phantomPublicKeyBytes,
-        this.dappEncryptionKeyPair.secretKey
-      );
+      let encryptedPayload: Uint8Array | null;
+      if (this.sharedKey) {
+        encryptedPayload = nacl.box.after(payloadBytes, nonce, this.sharedKey);
+      } else {
+        const walletPublicKeyBytes = bs58.decode(walletPublicKeyBs58);
+        encryptedPayload = nacl.box(
+          payloadBytes,
+          nonce,
+          walletPublicKeyBytes,
+          this.dappEncryptionKeyPair.secretKey
+        );
+      }
 
       return {
         nonce: bs58.encode(nonce),
         encryptedPayload: bs58.encode(encryptedPayload)
       };
     } catch (error) {
+      console.warn(`${this.config.type} provider: Failed to encrypt payload.`, error);
+
       return null;
     }
   }
@@ -156,40 +223,59 @@ export class PhantomProvider extends EventEmitter implements Provider {
   private decryptPayload<T>(
     encryptedDataBs58: string,
     nonceBs58: string,
-    phantomSenderPublicKeyBs58: string
+    walletSenderPublicKeyBs58: string
   ): T | null {
     try {
-      const encryptedDataBytes = bs58.decode(encryptedDataBs58);
+      const formattedEncryptedDataBs58 = encryptedDataBs58.replace('#', '');
+      const encryptedDataBytes = bs58.decode(formattedEncryptedDataBs58);
       const nonceBytes = bs58.decode(nonceBs58);
-      const phantomSenderPublicKeyBytes = bs58.decode(phantomSenderPublicKeyBs58);
-      const decryptedPayloadBytes = nacl.box.open(
-        encryptedDataBytes,
-        nonceBytes,
-        phantomSenderPublicKeyBytes,
-        this.dappEncryptionKeyPair.secretKey
-      );
+      let decryptedPayloadBytes: Uint8Array | null;
+      if (this.sharedKey) {
+        decryptedPayloadBytes = nacl.box.open.after(encryptedDataBytes, nonceBytes, this.sharedKey);
+      } else {
+        const walletSenderPublicKeyBytes = bs58.decode(walletSenderPublicKeyBs58);
+        decryptedPayloadBytes = nacl.box.open(
+          encryptedDataBytes,
+          nonceBytes,
+          walletSenderPublicKeyBytes,
+          this.dappEncryptionKeyPair.secretKey
+        );
+      }
       if (!decryptedPayloadBytes) {
         return null;
       }
 
       return JSON.parse(Buffer.from(decryptedPayloadBytes).toString('utf8')) as T;
     } catch (error) {
+      console.warn(`${this.config.type} provider: Failed to decrypt payload.`, error);
+
       return null;
     }
   }
 
   public async restoreSession(): Promise<boolean> {
     try {
-      const session = await this.storage.getItem<PhantomSession>(PHANTOM_PROVIDER_STORAGE_KEY);
+      const session = await this.storage.getItem<DeeplinkSession>(this.getSessionStorageKey());
       if (session) {
         this.setSession(session);
 
+        // Recompute shared key on session restore
+        try {
+          const walletPublicKeyBytes = bs58.decode(session.walletEncryptionPublicKeyBs58);
+          this.sharedKey = nacl.box.before(
+            walletPublicKeyBytes,
+            this.dappEncryptionKeyPair.secretKey
+          );
+        } catch (e) {
+          this.sharedKey = null;
+        }
+
         return true;
       }
 
       return false;
     } catch (error) {
-      // console.error('PhantomProvider: Failed to restore session.', error);
+      // console.error(`${this.config.type} provider: Failed to restore session.`, error);
       await this.clearSessionStorage(); // Clear potentially corrupt data
 
       return false;
@@ -197,36 +283,34 @@ export class PhantomProvider extends EventEmitter implements Provider {
   }
 
   private async saveSession(): Promise<void> {
-    if (!this.sessionToken || !this.userPublicKey || !this.phantomEncryptionPublicKeyBs58) {
+    if (!this.sessionToken || !this.userPublicKey || !this.walletEncryptionPublicKeyBs58) {
       return; // Cannot save incomplete session
     }
-    const session: PhantomSession = {
+    const session: DeeplinkSession = {
       sessionToken: this.sessionToken,
       userPublicKey: this.userPublicKey,
-      phantomEncryptionPublicKeyBs58: this.phantomEncryptionPublicKeyBs58,
+      walletEncryptionPublicKeyBs58: this.walletEncryptionPublicKeyBs58,
       cluster: this.currentCluster
     };
     try {
-      await this.storage.setItem(PHANTOM_PROVIDER_STORAGE_KEY, session);
+      await this.storage.setItem(this.getSessionStorageKey(), session);
     } catch (error) {
-      // console.error('PhantomProvider: Failed to save session.', error);
+      // console.error(`${this.config.type} provider: Failed to save session.`, error);
     }
   }
 
   private async clearSessionStorage(): Promise<void> {
     try {
-      await this.storage.removeItem(PHANTOM_PROVIDER_STORAGE_KEY);
+      await this.storage.removeItem(this.getSessionStorageKey());
     } catch (error) {
-      // console.error('PhantomProvider: Failed to clear session storage.', error);
+      // console.error(`${this.config.type} provider: Failed to clear session storage.`, error);
     }
   }
 
-  public async connect<T = PhantomConnectResult>(params?: {
-    cluster?: PhantomCluster;
-  }): Promise<T> {
+  public async connect<T = DeeplinkConnectResult>(params?: { cluster?: Cluster }): Promise<T> {
     const cluster = params?.cluster ?? 'mainnet-beta';
     this.currentCluster = cluster;
-    const connectDeeplinkParams: PhantomConnectParams = {
+    const connectDeeplinkParams: DeeplinkConnectParams = {
       app_url: this.config.dappUrl,
       dapp_encryption_public_key: bs58.encode(this.dappEncryptionKeyPair.publicKey),
       redirect_link: this.config.appScheme,
@@ -234,84 +318,63 @@ export class PhantomProvider extends EventEmitter implements Provider {
     };
     const url = this.buildUrl('connect', connectDeeplinkParams as any);
 
-    return new Promise<PhantomConnectResult>((resolve, reject) => {
-      const handleDeepLink = async (event: { url: string }) => {
-        try {
-          this.cleanupActiveSubscription();
-          const fullUrl = event.url;
-          if (fullUrl.startsWith(this.config.appScheme)) {
-            const responseUrlParams = new URLSearchParams(
-              fullUrl.substring(fullUrl.indexOf('?') + 1)
-            );
-            const errorCode = responseUrlParams.get('errorCode');
-            const errorMessage = responseUrlParams.get('errorMessage');
-            if (errorCode) {
-              return reject(
-                new Error(
-                  `Phantom Connection Failed: ${
-                    errorMessage || 'Unknown error'
-                  } (Code: ${errorCode})`
-                )
-              );
-            }
-            const responsePayload: PhantomDeeplinkResponse = {
-              phantom_encryption_public_key: responseUrlParams.get(
-                'phantom_encryption_public_key'
-              )!,
-              nonce: responseUrlParams.get('nonce')!,
-              data: responseUrlParams.get('data')!
-            };
-            if (
-              !responsePayload.phantom_encryption_public_key ||
-              !responsePayload.nonce ||
-              !responsePayload.data
-            ) {
-              return reject(new Error('Phantom Connect: Invalid response - missing parameters.'));
-            }
-            const decryptedData = this.decryptPayload<DecryptedConnectData>(
-              responsePayload.data,
-              responsePayload.nonce,
-              responsePayload.phantom_encryption_public_key
-            );
-            if (!decryptedData || !decryptedData.public_key || !decryptedData.session) {
-              return reject(
-                new Error('Phantom Connect: Failed to decrypt or invalid decrypted data.')
-              );
-            }
-            this.userPublicKey = decryptedData.public_key;
-            this.sessionToken = decryptedData.session;
-            this.phantomEncryptionPublicKeyBs58 = responsePayload.phantom_encryption_public_key;
-
-            // Save session on successful connect
-            this.saveSession();
-
-            resolve({
-              userPublicKey: this.userPublicKey,
-              sessionToken: this.sessionToken,
-              phantomEncryptionPublicKeyBs58: this.phantomEncryptionPublicKeyBs58,
-              cluster
-            });
-          } else {
-            reject(new Error('Phantom Connect: Unexpected redirect URI.'));
-          }
-        } catch (error) {
-          this.cleanupActiveSubscription();
-          reject(error);
+    return this.openDeeplinkAndWait<DeeplinkConnectResult>(
+      url,
+      (responseUrlParams: URLSearchParams) => {
+        const responsePayload: DeeplinkResponse = {
+          wallet_encryption_public_key: responseUrlParams.get(this.config.encryptionKeyFieldName)!,
+          nonce: responseUrlParams.get('nonce')!,
+          data: responseUrlParams.get('data')!
+        };
+        if (
+          !responsePayload.wallet_encryption_public_key ||
+          !responsePayload.nonce ||
+          !responsePayload.data
+        ) {
+          throw new Error(`${this.config.type} provider: Invalid response - missing parameters.`);
         }
-      };
 
-      const subscription = Linking.addEventListener('url', handleDeepLink);
-      this.setActiveSubscription(subscription);
+        const decryptedData = this.decryptPayload<DecryptedConnectData>(
+          responsePayload.data,
+          responsePayload.nonce,
+          responsePayload.wallet_encryption_public_key
+        );
+        if (!decryptedData || !decryptedData.public_key || !decryptedData.session) {
+          throw new Error(
+            `${this.config.type} provider: Failed to decrypt or invalid decrypted data.`
+          );
+        }
+        this.userPublicKey = decryptedData.public_key;
+        this.sessionToken = decryptedData.session;
+        this.walletEncryptionPublicKeyBs58 = responsePayload.wallet_encryption_public_key;
 
-      Linking.openURL(url).catch(err => {
-        this.cleanupActiveSubscription();
-        reject(new Error(`Failed to open Phantom wallet: ${err.message}. Is it installed?`));
-      });
-    }) as Promise<T>;
+        // Precompute shared key for subsequent communications
+        try {
+          const walletPublicKeyBytes = bs58.decode(this.walletEncryptionPublicKeyBs58);
+          this.sharedKey = nacl.box.before(
+            walletPublicKeyBytes,
+            this.dappEncryptionKeyPair.secretKey
+          );
+        } catch (e) {
+          this.sharedKey = null;
+        }
+
+        // Save session on successful connect
+        this.saveSession();
+
+        return {
+          userPublicKey: this.userPublicKey!,
+          sessionToken: this.sessionToken!,
+          walletEncryptionPublicKeyBs58: this.walletEncryptionPublicKeyBs58!,
+          cluster
+        } as DeeplinkConnectResult;
+      },
+      'Connection'
+    ) as Promise<T>;
   }
 
   public async disconnect(): Promise<void> {
-    if (!this.sessionToken || !this.phantomEncryptionPublicKeyBs58) {
+    if (!this.sessionToken || !this.walletEncryptionPublicKeyBs58) {
       await this.clearSession();
       this.emit('disconnect');
 
@@ -321,18 +384,18 @@ export class PhantomProvider extends EventEmitter implements Provider {
     const payloadToEncrypt = { session: this.sessionToken };
     const encryptedDisconnectPayload = this.encryptPayload(
       payloadToEncrypt,
-      this.phantomEncryptionPublicKeyBs58
+      this.walletEncryptionPublicKeyBs58
     );
 
     if (!encryptedDisconnectPayload) {
-      // console.warn('PhantomProvider: Failed to encrypt disconnect payload. Clearing session locally.');
+      // console.warn(`${this.config.type} provider: Failed to encrypt disconnect payload. Clearing session locally.`);
       await this.clearSession();
       this.emit('disconnect');
 
       return Promise.resolve(); // Or reject, depending on desired strictness
     }
 
-    const disconnectDeeplinkParams: PhantomDisconnectParams = {
+    const disconnectDeeplinkParams: DeeplinkDisconnectParams = {
       dapp_encryption_public_key: bs58.encode(this.dappEncryptionKeyPair.publicKey),
       redirect_link: this.config.appScheme,
       payload: encryptedDisconnectPayload.encryptedPayload,
@@ -340,62 +403,46 @@ export class PhantomProvider extends EventEmitter implements Provider {
     };
     const url = this.buildUrl('disconnect', disconnectDeeplinkParams as any);
 
-    return new Promise<void>((resolve, reject) => {
-      const handleDeepLink = (event: { url: string }) => {
-        try {
-          this.cleanupActiveSubscription();
-          if (event.url.startsWith(this.config.appScheme)) {
-            this.clearSession();
-            resolve();
-          } else {
-            this.clearSession();
-            reject(new Error('Phantom Disconnect: Unexpected redirect URI.'));
-          }
-        } catch (error) {
-          this.cleanupActiveSubscription();
-          this.clearSession();
-          reject(error);
-        }
-      };
-
-      const subscription = Linking.addEventListener('url', handleDeepLink);
-      this.setActiveSubscription(subscription);
-
-      Linking.openURL(url).catch(err => {
-        this.cleanupActiveSubscription();
+    return this.openDeeplinkAndWait<void>(
+      url,
+      () => {
         this.clearSession();
-        reject(new Error(`Failed to open Phantom for disconnection: ${err.message}.`));
-      });
-    });
+      },
+      'Disconnection'
+    );
   }
 
   public async clearSession(): Promise<void> {
     this.sessionToken = null;
     this.userPublicKey = null;
-    this.phantomEncryptionPublicKeyBs58 = null;
+    this.walletEncryptionPublicKeyBs58 = null;
+    if (this.sharedKey) {
+      this.sharedKey.fill(0);
+    }
+    this.sharedKey = null;
     this.cleanupActiveSubscription();
     await this.clearSessionStorage();
   }
 
-  public setSession(session: PhantomSession): void {
+  public setSession(session: DeeplinkSession): void {
     this.sessionToken = session.sessionToken;
     this.userPublicKey = session.userPublicKey;
-    this.phantomEncryptionPublicKeyBs58 = session.phantomEncryptionPublicKeyBs58;
+    this.walletEncryptionPublicKeyBs58 = session.walletEncryptionPublicKeyBs58;
     this.currentCluster = session.cluster;
   }
 
   public async request<T>(args: RequestArguments, _chainId?: CaipNetworkId): Promise<T> {
     if (!isValidSolanaSigningMethod(args.method)) {
       throw new Error(
-        `PhantomProvider: Unsupported method: ${args.method}. Only Solana signing methods are supported.`
+        `${this.config.type} provider: Unsupported method: ${args.method}. Only Solana signing methods are supported.`
       );
     }
     const signingMethod = args.method as SolanaSigningMethod;
     const requestParams = args.params as any;
 
-    if (!this.isConnected() || !this.sessionToken || !this.phantomEncryptionPublicKeyBs58) {
+    if (!this.isConnected() || !this.sessionToken || !this.walletEncryptionPublicKeyBs58) {
       throw new Error(
-        'PhantomProvider: Not connected or session details missing. Cannot process request.'
+        `${this.config.type} provider: Not connected or session details missing. Cannot process request.`
       );
     }
 
@@ -413,18 +460,20 @@ export class PhantomProvider extends EventEmitter implements Provider {
         }
 
         const dataToEncrypt = {
-          session: this.sessionToken!,
+          session: this.sessionToken,
           transaction: typedParams.transaction
         };
         const encryptedData = this.encryptPayload(
           dataToEncrypt,
-          this.phantomEncryptionPublicKeyBs58!
+          this.walletEncryptionPublicKeyBs58
         );
         if (!encryptedData) {
-          throw new Error(`PhantomProvider: Failed to encrypt payload for ${signingMethod}.`);
+          throw new Error(
+            `${this.config.type} provider: Failed to encrypt payload for ${signingMethod}.`
+          );
         }
 
-        const signTxDeeplinkParams: PhantomSignTransactionParams = {
+        const signTxDeeplinkParams: DeeplinkSignTransactionParams = {
           dapp_encryption_public_key: bs58.encode(this.dappEncryptionKeyPair.publicKey),
           redirect_link: this.config.appScheme,
           cluster: this.currentCluster,
@@ -437,7 +486,9 @@ export class PhantomProvider extends EventEmitter implements Provider {
       case SOLANA_SIGNING_METHODS.SOLANA_SIGN_MESSAGE: {
         const typedParams = requestParams as SignMessageRequestParams;
         if (!typedParams || typeof typedParams.message === 'undefined') {
-          throw new Error(`Missing 'message' in params for ${signingMethod}`);
+          throw new Error(
+            `${this.config.type} provider: Missing 'message' in params for ${signingMethod}`
+          );
         }
 
         let messageBs58: string;
@@ -451,25 +502,29 @@ export class PhantomProvider extends EventEmitter implements Provider {
             messageBs58 = bs58.encode(Buffer.from(typedParams.message));
           }
         } else {
-          throw new Error('Invalid message format for signMessage. Expected Uint8Array or string.');
+          throw new Error(
+            `${this.config.type} provider: Invalid message format for signMessage. Expected Uint8Array or string.`
+          );
         }
 
         const dataToEncrypt = {
           message: messageBs58,
-          session: this.sessionToken!,
+          session: this.sessionToken,
           display: typedParams.display || 'utf8'
         };
 
         const encryptedPayloadData = this.encryptPayload(
           dataToEncrypt,
-          this.phantomEncryptionPublicKeyBs58!
+          this.walletEncryptionPublicKeyBs58
         );
 
         if (!encryptedPayloadData) {
-          throw new Error('PhantomProvider: Failed to encrypt payload for signMessage.');
+          throw new Error(
+            `${this.config.type} provider: Failed to encrypt payload for signMessage.`
+          );
         }
 
-        const signMsgDeeplinkQueryPayload: PhantomSignMessageParams = {
+        const signMsgDeeplinkQueryPayload: DeeplinkSignMessageParams = {
           dapp_encryption_public_key: bs58.encode(this.dappEncryptionKeyPair.publicKey),
           redirect_link: this.config.appScheme,
           payload: encryptedPayloadData.encryptedPayload,
@@ -486,23 +541,25 @@ export class PhantomProvider extends EventEmitter implements Provider {
           !typedParams.transactions.every((t: any) => typeof t === 'string')
         ) {
           throw new Error(
-            `Missing or invalid 'transactions' (array of base58 strings) in params for ${signingMethod}`
+            `${this.config.type} provider: Missing or invalid 'transactions' (array of base58 strings) in params for ${signingMethod}`
           );
         }
 
         const dataToEncrypt = {
-          session: this.sessionToken!,
+          session: this.sessionToken,
           transactions: typedParams.transactions
         };
         const encryptedData = this.encryptPayload(
           dataToEncrypt,
-          this.phantomEncryptionPublicKeyBs58!
+          this.walletEncryptionPublicKeyBs58
         );
         if (!encryptedData) {
-          throw new Error(`PhantomProvider: Failed to encrypt payload for ${signingMethod}.`);
+          throw new Error(
+            `${this.config.type} provider: Failed to encrypt payload for ${signingMethod}.`
+          );
         }
 
-        const signAllTxDeeplinkParams: PhantomSignAllTransactionsParams = {
+        const signAllTxDeeplinkParams: DeeplinkSignAllTransactionsParams = {
           dapp_encryption_public_key: bs58.encode(this.dappEncryptionKeyPair.publicKey),
           redirect_link: this.config.appScheme,
           cluster: this.currentCluster,
@@ -513,69 +570,35 @@ export class PhantomProvider extends EventEmitter implements Provider {
         break;
       }
       default: {
-        throw new Error(`PhantomProvider: Unhandled signing method: ${signingMethod}`);
+        throw new Error(`${this.config.type} provider: Unhandled signing method: ${signingMethod}`);
       }
     }
 
-    return new Promise<T>((resolve, reject) => {
-      const handleDeepLink = async (event: { url: string }) => {
-        try {
-          this.cleanupActiveSubscription();
-          const fullUrl = event.url;
-          if (fullUrl.startsWith(this.config.appScheme)) {
-            const responseUrlParams = new URLSearchParams(
-              fullUrl.substring(fullUrl.indexOf('?') + 1)
-            );
-            const errorCode = responseUrlParams.get('errorCode');
-            const errorMessage = responseUrlParams.get('errorMessage');
-            if (errorCode) {
-              return reject(
-                new Error(
-                  `Phantom ${signingMethod} Failed: ${
-                    errorMessage || 'Unknown error'
-                  } (Code: ${errorCode})`
-                )
-              );
-            }
-            const responseNonce = responseUrlParams.get('nonce');
-            const responseData = responseUrlParams.get('data');
-            if (!responseNonce || !responseData) {
-              return reject(
-                new Error(`Phantom ${signingMethod}: Invalid response - missing nonce or data.`)
-              );
-            }
-            const decryptedResult = this.decryptPayload<any>(
-              responseData,
-              responseNonce,
-              this.phantomEncryptionPublicKeyBs58!
-            );
-            if (!decryptedResult) {
-              return reject(
-                new Error(
-                  `Phantom ${signingMethod}: Failed to decrypt response or invalid decrypted data.`
-                )
-              );
-            }
-            resolve(decryptedResult as T);
-          } else {
-            reject(new Error(`Phantom ${signingMethod}: Unexpected redirect URI.`));
-          }
-        } catch (error) {
-          this.cleanupActiveSubscription();
-          reject(error);
+    return this.openDeeplinkAndWait<T>(
+      deeplinkUrl,
+      (responseUrlParams: URLSearchParams) => {
+        const responseNonce = responseUrlParams.get('nonce');
+        const responseData = responseUrlParams.get('data');
+        if (!responseNonce || !responseData) {
+          throw new Error(
+            `${this.config.type} provider: ${signingMethod}: Invalid response - missing nonce or data.`
+          );
         }
-      };
-
-      const subscription = Linking.addEventListener('url', handleDeepLink);
-      this.setActiveSubscription(subscription);
-
-      Linking.openURL(deeplinkUrl).catch(err => {
-        this.cleanupActiveSubscription();
-        reject(
-          new Error(`Failed to open Phantom for ${signingMethod}: ${err.message}. Is it installed?`)
+        const decryptedResult = this.decryptPayload<any>(
+          responseData,
+          responseNonce,
+          this.walletEncryptionPublicKeyBs58!
         );
-      });
-    });
+        if (!decryptedResult) {
+          throw new Error(
+            `${this.config.type} provider: ${signingMethod}: Failed to decrypt response or invalid decrypted data.`
+          );
+        }
+
+        return decryptedResult as T;
+      },
+      signingMethod
+    );
   }
 }