@reown/appkit-solana-react-native 0.0.0-chore-solflare-20250730210452 → 0.0.0-chore-spring-effect-20250909214820

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

@@ -9,21 +9,21 @@ import type {
   Storage
 } from '@reown/appkit-common-react-native';
 import type {
-  SolanaDeeplinkProviderConfig,
-  SolanaConnectResult,
-  SolanaWalletSession,
+  DeeplinkProviderConfig,
+  DeeplinkConnectResult,
+  DeeplinkSession,
   DecryptedConnectData,
-  SolanaDeeplinkResponse,
+  DeeplinkResponse,
   SignAllTransactionsRequestParams,
   SignMessageRequestParams,
   SignTransactionRequestParams,
-  SolanaRpcMethod,
-  SolanaConnectParams,
-  SolanaDisconnectParams,
-  SolanaSignTransactionParams,
-  SolanaSignMessageParams,
-  SolanaSignAllTransactionsParams,
-  SolanaCluster
+  DeeplinkRpcMethod,
+  DeeplinkConnectParams,
+  DeeplinkDisconnectParams,
+  DeeplinkSignTransactionParams,
+  DeeplinkSignMessageParams,
+  DeeplinkSignAllTransactionsParams,
+  Cluster
 } from '../types';
 import EventEmitter from 'events';
 
@@ -40,10 +40,11 @@ function isValidSolanaSigningMethod(method: string): method is SolanaSigningMeth
   return Object.values(SOLANA_SIGNING_METHODS).includes(method as SolanaSigningMethod);
 }
 
-export class SolanaDeeplinkProvider extends EventEmitter implements Provider {
-  private readonly config: SolanaDeeplinkProviderConfig;
+export class DeeplinkProvider extends EventEmitter implements Provider {
+  private readonly config: DeeplinkProviderConfig;
   private dappEncryptionKeyPair: nacl.BoxKeyPair;
-  private currentCluster: SolanaCluster = 'mainnet-beta';
+  private currentCluster: Cluster;
+  private sharedKey: Uint8Array | null = null;
 
   private storage: Storage;
 
@@ -51,15 +52,51 @@ export class SolanaDeeplinkProvider extends EventEmitter implements Provider {
   private userPublicKey: string | null = null;
   private walletEncryptionPublicKeyBs58: string | null = null;
 
-  constructor(config: SolanaDeeplinkProviderConfig) {
+  // Single subscription management - deep links are sequential by nature
+  private activeSubscription: { remove: () => void } | null = null;
+  private isOperationPending = false;
+
+  constructor(config: DeeplinkProviderConfig) {
     super();
     this.config = config;
+    this.currentCluster = config.cluster ?? 'mainnet-beta';
     this.dappEncryptionKeyPair = config.dappEncryptionKeyPair;
     this.storage = config.storage;
   }
 
-  private getStorageKey(): string {
-    return `@appkit/${this.config.walletType}-provider-session`;
+  private getSessionStorageKey(): string {
+    return `@appkit/${this.config.type}-provider-session`;
+  }
+
+  /**
+   * Cleanup method to be called when the provider is destroyed
+   */
+  public destroy(): void {
+    this.cleanupActiveSubscription();
+    this.removeAllListeners();
+  }
+
+  /**
+   * Safely cleanup the active subscription
+   */
+  private cleanupActiveSubscription(): void {
+    if (this.activeSubscription) {
+      this.activeSubscription.remove();
+      this.activeSubscription = null;
+    }
+    this.isOperationPending = false;
+  }
+
+  /**
+   * Safely set a new subscription, ensuring no operation is pending
+   */
+  private setActiveSubscription(subscription: { remove: () => void }): void {
+    // If there's already a pending operation, reject it
+    if (this.isOperationPending) {
+      this.cleanupActiveSubscription();
+    }
+    this.activeSubscription = subscription;
+    this.isOperationPending = true;
   }
 
   getUserPublicKey(): string | null {
@@ -70,13 +107,70 @@ export class SolanaDeeplinkProvider extends EventEmitter implements Provider {
     return !!this.sessionToken && !!this.userPublicKey && !!this.dappEncryptionKeyPair;
   }
 
-  private buildUrl(rpcMethod: SolanaRpcMethod, 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 `${this.config.baseUrl}/${rpcMethod}?${query}`;
   }
 
-  private getRpcMethodName(method: SolanaSigningMethod): SolanaRpcMethod {
+  /**
+   * 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';
@@ -94,27 +188,34 @@ export class SolanaDeeplinkProvider extends EventEmitter implements Provider {
 
   private encryptPayload(
     payload: Record<string, unknown>,
-    walletPublicKeyBs58ToEncryptFor: string
+    walletPublicKeyBs58: string
   ): { nonce: string; encryptedPayload: string } | null {
-    if (!walletPublicKeyBs58ToEncryptFor) {
+    if (!walletPublicKeyBs58) {
       return null;
     }
     try {
-      const walletPublicKeyBytes = bs58.decode(walletPublicKeyBs58ToEncryptFor);
       const nonce = nacl.randomBytes(nacl.box.nonceLength);
       const payloadBytes = Buffer.from(JSON.stringify(payload), 'utf8');
-      const encryptedPayload = nacl.box(
-        payloadBytes,
-        nonce,
-        walletPublicKeyBytes,
-        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;
     }
   }
@@ -125,37 +226,56 @@ export class SolanaDeeplinkProvider extends EventEmitter implements Provider {
     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 walletSenderPublicKeyBytes = bs58.decode(walletSenderPublicKeyBs58);
-      const decryptedPayloadBytes = nacl.box.open(
-        encryptedDataBytes,
-        nonceBytes,
-        walletSenderPublicKeyBytes,
-        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<SolanaWalletSession>(this.getStorageKey());
+      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(`${this.config.walletType}Provider: 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;
@@ -166,31 +286,31 @@ export class SolanaDeeplinkProvider extends EventEmitter implements Provider {
     if (!this.sessionToken || !this.userPublicKey || !this.walletEncryptionPublicKeyBs58) {
       return; // Cannot save incomplete session
     }
-    const session: SolanaWalletSession = {
+    const session: DeeplinkSession = {
       sessionToken: this.sessionToken,
       userPublicKey: this.userPublicKey,
       walletEncryptionPublicKeyBs58: this.walletEncryptionPublicKeyBs58,
       cluster: this.currentCluster
     };
     try {
-      await this.storage.setItem(this.getStorageKey(), session);
+      await this.storage.setItem(this.getSessionStorageKey(), session);
     } catch (error) {
-      // console.error(`${this.config.walletType}Provider: 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(this.getStorageKey());
+      await this.storage.removeItem(this.getSessionStorageKey());
     } catch (error) {
-      // console.error(`${this.config.walletType}Provider: Failed to clear session storage.`, error);
+      // console.error(`${this.config.type} provider: Failed to clear session storage.`, error);
     }
   }
 
-  public async connect<T = SolanaConnectResult>(params?: { cluster?: SolanaCluster }): Promise<T> {
+  public async connect<T = DeeplinkConnectResult>(params?: { cluster?: Cluster }): Promise<T> {
     const cluster = params?.cluster ?? 'mainnet-beta';
     this.currentCluster = cluster;
-    const connectDeeplinkParams: SolanaConnectParams = {
+    const connectDeeplinkParams: DeeplinkConnectParams = {
       app_url: this.config.dappUrl,
       dapp_encryption_public_key: bs58.encode(this.dappEncryptionKeyPair.publicKey),
       redirect_link: this.config.appScheme,
@@ -198,87 +318,59 @@ export class SolanaDeeplinkProvider extends EventEmitter implements Provider {
     };
     const url = this.buildUrl('connect', connectDeeplinkParams as any);
 
-    return new Promise<SolanaConnectResult>((resolve, reject) => {
-      let subscription: { remove: () => void } | null = null;
-      const handleDeepLink = async (event: { url: string }) => {
-        if (subscription) {
-          subscription.remove();
+    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 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(
-                `${this.config.walletType} Connection Failed: ${
-                  errorMessage || 'Unknown error'
-                } (Code: ${errorCode})`
-              )
-            );
-          }
-          const walletEncryptionPublicKey = responseUrlParams.get(
-            this.config.encryptionKeyFieldName
-          );
 
-          const responsePayload: SolanaDeeplinkResponse = {
-            wallet_encryption_public_key: walletEncryptionPublicKey!,
-            nonce: responseUrlParams.get('nonce')!,
-            data: responseUrlParams.get('data')!
-          };
-          if (
-            !responsePayload.wallet_encryption_public_key ||
-            !responsePayload.nonce ||
-            !responsePayload.data
-          ) {
-            return reject(
-              new Error(`${this.config.walletType} Connect: Invalid response - missing parameters.`)
-            );
-          }
-          const decryptedData = this.decryptPayload<DecryptedConnectData>(
-            responsePayload.data,
-            responsePayload.nonce,
-            responsePayload.wallet_encryption_public_key
+        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.`
           );
-          if (!decryptedData || !decryptedData.public_key || !decryptedData.session) {
-            return reject(
-              new Error(
-                `${this.config.walletType} Connect: Failed to decrypt or invalid decrypted data.`
-              )
-            );
-          }
-          this.userPublicKey = decryptedData.public_key;
-          this.sessionToken = decryptedData.session;
-          this.walletEncryptionPublicKeyBs58 = responsePayload.wallet_encryption_public_key;
-
-          // Save session on successful connect
-          this.saveSession();
-
-          resolve({
-            userPublicKey: this.userPublicKey,
-            sessionToken: this.sessionToken,
-            walletEncryptionPublicKeyBs58: this.walletEncryptionPublicKeyBs58,
-            cluster
-          });
-        } else {
-          reject(new Error(`${this.config.walletType} Connect: Unexpected redirect URI.`));
         }
-      };
-      subscription = Linking.addEventListener('url', handleDeepLink);
-      Linking.openURL(url).catch(err => {
-        if (subscription) {
-          subscription.remove();
+        this.userPublicKey = decryptedData.public_key;
+        this.sessionToken = decryptedData.session;
+        this.walletEncryptionPublicKeyBs58 = responsePayload.wallet_encryption_public_key;
+
+        // 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;
         }
-        reject(
-          new Error(
-            `Failed to open ${this.config.walletType} wallet: ${err.message}. Is it installed?`
-          )
-        );
-      });
-    }) as Promise<T>;
+
+        // 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> {
@@ -296,14 +388,14 @@ export class SolanaDeeplinkProvider extends EventEmitter implements Provider {
     );
 
     if (!encryptedDisconnectPayload) {
-      // console.warn(`${this.config.walletType}Provider: 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: SolanaDisconnectParams = {
+    const disconnectDeeplinkParams: DeeplinkDisconnectParams = {
       dapp_encryption_public_key: bs58.encode(this.dappEncryptionKeyPair.publicKey),
       redirect_link: this.config.appScheme,
       payload: encryptedDisconnectPayload.encryptedPayload,
@@ -311,41 +403,28 @@ export class SolanaDeeplinkProvider extends EventEmitter implements Provider {
     };
     const url = this.buildUrl('disconnect', disconnectDeeplinkParams as any);
 
-    return new Promise<void>((resolve, reject) => {
-      let subscription: { remove: () => void } | null = null;
-      const handleDeepLink = (event: { url: string }) => {
-        if (subscription) {
-          subscription.remove();
-        }
-        if (event.url.startsWith(this.config.appScheme)) {
-          this.clearSession();
-          resolve();
-        } else {
-          this.clearSession();
-          reject(new Error(`${this.config.walletType} Disconnect: Unexpected redirect URI.`));
-        }
-      };
-      subscription = Linking.addEventListener('url', handleDeepLink);
-      Linking.openURL(url).catch(err => {
-        if (subscription) {
-          subscription.remove();
-        }
+    return this.openDeeplinkAndWait<void>(
+      url,
+      () => {
         this.clearSession();
-        reject(
-          new Error(`Failed to open ${this.config.walletType} for disconnection: ${err.message}.`)
-        );
-      });
-    });
+      },
+      'Disconnection'
+    );
   }
 
   public async clearSession(): Promise<void> {
     this.sessionToken = null;
     this.userPublicKey = null;
     this.walletEncryptionPublicKeyBs58 = null;
+    if (this.sharedKey) {
+      this.sharedKey.fill(0);
+    }
+    this.sharedKey = null;
+    this.cleanupActiveSubscription();
     await this.clearSessionStorage();
   }
 
-  public setSession(session: SolanaWalletSession): void {
+  public setSession(session: DeeplinkSession): void {
     this.sessionToken = session.sessionToken;
     this.userPublicKey = session.userPublicKey;
     this.walletEncryptionPublicKeyBs58 = session.walletEncryptionPublicKeyBs58;
@@ -355,7 +434,7 @@ export class SolanaDeeplinkProvider extends EventEmitter implements Provider {
   public async request<T>(args: RequestArguments, _chainId?: CaipNetworkId): Promise<T> {
     if (!isValidSolanaSigningMethod(args.method)) {
       throw new Error(
-        `${this.config.walletType}Provider: 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;
@@ -363,7 +442,7 @@ export class SolanaDeeplinkProvider extends EventEmitter implements Provider {
 
     if (!this.isConnected() || !this.sessionToken || !this.walletEncryptionPublicKeyBs58) {
       throw new Error(
-        `${this.config.walletType}Provider: Not connected or session details missing. Cannot process request.`
+        `${this.config.type} provider: Not connected or session details missing. Cannot process request.`
       );
     }
 
@@ -381,20 +460,20 @@ export class SolanaDeeplinkProvider extends EventEmitter implements Provider {
         }
 
         const dataToEncrypt = {
-          session: this.sessionToken!,
+          session: this.sessionToken,
           transaction: typedParams.transaction
         };
         const encryptedData = this.encryptPayload(
           dataToEncrypt,
-          this.walletEncryptionPublicKeyBs58!
+          this.walletEncryptionPublicKeyBs58
         );
         if (!encryptedData) {
           throw new Error(
-            `${this.config.walletType}Provider: Failed to encrypt payload for ${signingMethod}.`
+            `${this.config.type} provider: Failed to encrypt payload for ${signingMethod}.`
           );
         }
 
-        const signTxDeeplinkParams: SolanaSignTransactionParams = {
+        const signTxDeeplinkParams: DeeplinkSignTransactionParams = {
           dapp_encryption_public_key: bs58.encode(this.dappEncryptionKeyPair.publicKey),
           redirect_link: this.config.appScheme,
           cluster: this.currentCluster,
@@ -407,7 +486,9 @@ export class SolanaDeeplinkProvider 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;
@@ -421,27 +502,29 @@ export class SolanaDeeplinkProvider 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.walletEncryptionPublicKeyBs58!
+          this.walletEncryptionPublicKeyBs58
         );
 
         if (!encryptedPayloadData) {
           throw new Error(
-            `${this.config.walletType}Provider: Failed to encrypt payload for signMessage.`
+            `${this.config.type} provider: Failed to encrypt payload for signMessage.`
           );
         }
 
-        const signMsgDeeplinkQueryPayload: SolanaSignMessageParams = {
+        const signMsgDeeplinkQueryPayload: DeeplinkSignMessageParams = {
           dapp_encryption_public_key: bs58.encode(this.dappEncryptionKeyPair.publicKey),
           redirect_link: this.config.appScheme,
           payload: encryptedPayloadData.encryptedPayload,
@@ -458,25 +541,25 @@ export class SolanaDeeplinkProvider 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.walletEncryptionPublicKeyBs58!
+          this.walletEncryptionPublicKeyBs58
         );
         if (!encryptedData) {
           throw new Error(
-            `${this.config.walletType}Provider: Failed to encrypt payload for ${signingMethod}.`
+            `${this.config.type} provider: Failed to encrypt payload for ${signingMethod}.`
           );
         }
 
-        const signAllTxDeeplinkParams: SolanaSignAllTransactionsParams = {
+        const signAllTxDeeplinkParams: DeeplinkSignAllTransactionsParams = {
           dapp_encryption_public_key: bs58.encode(this.dappEncryptionKeyPair.publicKey),
           redirect_link: this.config.appScheme,
           cluster: this.currentCluster,
@@ -487,72 +570,35 @@ export class SolanaDeeplinkProvider extends EventEmitter implements Provider {
         break;
       }
       default: {
-        throw new Error(
-          `${this.config.walletType}Provider: Unhandled signing method: ${signingMethod}`
-        );
+        throw new Error(`${this.config.type} provider: Unhandled signing method: ${signingMethod}`);
       }
     }
 
-    return new Promise<T>((resolve, reject) => {
-      let subscription: { remove: () => void } | null = null;
-      const handleDeepLink = async (event: { url: string }) => {
-        if (subscription) {
-          subscription.remove();
-        }
-        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(
-                `${this.config.walletType} ${signingMethod} Failed: ${
-                  errorMessage || 'Unknown error'
-                } (Code: ${errorCode})`
-              )
-            );
-          }
-          const responseNonce = responseUrlParams.get('nonce');
-          const responseData = responseUrlParams.get('data');
-          if (!responseNonce || !responseData) {
-            return reject(
-              new Error(
-                `${this.config.walletType} ${signingMethod}: Invalid response - missing nonce or data.`
-              )
-            );
-          }
-          const decryptedResult = this.decryptPayload<any>(
-            responseData,
-            responseNonce,
-            this.walletEncryptionPublicKeyBs58!
+    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.`
           );
-          if (!decryptedResult) {
-            return reject(
-              new Error(
-                `${this.config.walletType} ${signingMethod}: Failed to decrypt response or invalid decrypted data.`
-              )
-            );
-          }
-          resolve(decryptedResult as T);
-        } else {
-          reject(new Error(`${this.config.walletType} ${signingMethod}: Unexpected redirect URI.`));
         }
-      };
-      subscription = Linking.addEventListener('url', handleDeepLink);
-      Linking.openURL(deeplinkUrl).catch(err => {
-        if (subscription) {
-          subscription.remove();
-        }
-        reject(
-          new Error(
-            `Failed to open ${this.config.walletType} 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
+    );
   }
 }