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

package/src/providers/PhantomProvider.ts

@@ -54,6 +54,10 @@ export class PhantomProvider extends EventEmitter implements Provider {
   private userPublicKey: string | null = null;
   private phantomEncryptionPublicKeyBs58: string | null = null;
 
+  // Single subscription management - deep links are sequential by nature
+  private activeSubscription: { remove: () => void } | null = null;
+  private isOperationPending = false;
+
   constructor(config: PhantomProviderConfig) {
     super();
     this.config = config;
@@ -61,6 +65,37 @@ export class PhantomProvider extends EventEmitter implements Provider {
     this.storage = config.storage;
   }
 
+  /**
+   * 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 {
     return this.userPublicKey;
   }
@@ -172,7 +207,7 @@ export class PhantomProvider extends EventEmitter implements Provider {
       cluster: this.currentCluster
     };
     try {
-      await this.storage.setItem(PHANTOM_PROVIDER_STORAGE_KEY, JSON.stringify(session));
+      await this.storage.setItem(PHANTOM_PROVIDER_STORAGE_KEY, session);
     } catch (error) {
       // console.error('PhantomProvider: Failed to save session.', error);
     }
@@ -200,69 +235,76 @@ export class PhantomProvider extends EventEmitter implements Provider {
     const url = this.buildUrl('connect', connectDeeplinkParams as any);
 
     return new Promise<PhantomConnectResult>((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(
-                `Phantom Connection Failed: ${errorMessage || 'Unknown error'} (Code: ${errorCode})`
-              )
+        try {
+          this.cleanupActiveSubscription();
+          const fullUrl = event.url;
+          if (fullUrl.startsWith(this.config.appScheme)) {
+            const responseUrlParams = new URLSearchParams(
+              fullUrl.substring(fullUrl.indexOf('?') + 1)
             );
-          }
-          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.')
+            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.'));
           }
-          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);
         }
       };
-      subscription = Linking.addEventListener('url', handleDeepLink);
+
+      const subscription = Linking.addEventListener('url', handleDeepLink);
+      this.setActiveSubscription(subscription);
+
       Linking.openURL(url).catch(err => {
-        if (subscription) {
-          subscription.remove();
-        }
+        this.cleanupActiveSubscription();
         reject(new Error(`Failed to open Phantom wallet: ${err.message}. Is it installed?`));
       });
     }) as Promise<T>;
@@ -271,6 +313,7 @@ export class PhantomProvider extends EventEmitter implements Provider {
   public async disconnect(): Promise<void> {
     if (!this.sessionToken || !this.phantomEncryptionPublicKeyBs58) {
       await this.clearSession();
+      this.emit('disconnect');
 
       return Promise.resolve();
     }
@@ -284,6 +327,7 @@ export class PhantomProvider extends EventEmitter implements Provider {
     if (!encryptedDisconnectPayload) {
       // console.warn('PhantomProvider: Failed to encrypt disconnect payload. Clearing session locally.');
       await this.clearSession();
+      this.emit('disconnect');
 
       return Promise.resolve(); // Or reject, depending on desired strictness
     }
@@ -297,24 +341,28 @@ export class PhantomProvider 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 {
+        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(new Error('Phantom Disconnect: Unexpected redirect URI.'));
+          reject(error);
         }
       };
-      subscription = Linking.addEventListener('url', handleDeepLink);
+
+      const subscription = Linking.addEventListener('url', handleDeepLink);
+      this.setActiveSubscription(subscription);
+
       Linking.openURL(url).catch(err => {
-        if (subscription) {
-          subscription.remove();
-        }
+        this.cleanupActiveSubscription();
         this.clearSession();
         reject(new Error(`Failed to open Phantom for disconnection: ${err.message}.`));
       });
@@ -325,6 +373,7 @@ export class PhantomProvider extends EventEmitter implements Provider {
     this.sessionToken = null;
     this.userPublicKey = null;
     this.phantomEncryptionPublicKeyBs58 = null;
+    this.cleanupActiveSubscription();
     await this.clearSessionStorage();
   }
 
@@ -469,56 +518,59 @@ export class PhantomProvider extends EventEmitter implements Provider {
     }
 
     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(
-                `Phantom ${signingMethod} Failed: ${
-                  errorMessage || 'Unknown error'
-                } (Code: ${errorCode})`
-              )
+        try {
+          this.cleanupActiveSubscription();
+          const fullUrl = event.url;
+          if (fullUrl.startsWith(this.config.appScheme)) {
+            const responseUrlParams = new URLSearchParams(
+              fullUrl.substring(fullUrl.indexOf('?') + 1)
             );
-          }
-          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.`
-              )
+            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.`));
           }
-          resolve(decryptedResult as T);
-        } else {
-          reject(new Error(`Phantom ${signingMethod}: Unexpected redirect URI.`));
+        } catch (error) {
+          this.cleanupActiveSubscription();
+          reject(error);
         }
       };
-      subscription = Linking.addEventListener('url', handleDeepLink);
+
+      const subscription = Linking.addEventListener('url', handleDeepLink);
+      this.setActiveSubscription(subscription);
+
       Linking.openURL(deeplinkUrl).catch(err => {
-        if (subscription) {
-          subscription.remove();
-        }
+        this.cleanupActiveSubscription();
         reject(
           new Error(`Failed to open Phantom for ${signingMethod}: ${err.message}. Is it installed?`)
         );

package/src/utils/createSendTransaction.ts

@@ -0,0 +1,57 @@
+import {
+  ComputeBudgetProgram,
+  type Connection,
+  LAMPORTS_PER_SOL,
+  PublicKey,
+  SystemProgram,
+  Transaction
+} from '@solana/web3.js';
+
+// import type { Provider } from '@reown/appkit-utils/solana'
+
+type SendTransactionArgs = {
+  connection: Connection;
+  fromAddress: string;
+  toAddress: string;
+  value: number;
+};
+
+/**
+ * These constants defines the cost of running the program, allowing to calculate the maximum
+ * amount of SOL that can be sent in case of cleaning the account and remove the rent exemption error.
+ */
+const COMPUTE_BUDGET_CONSTANTS = {
+  UNIT_PRICE_MICRO_LAMPORTS: 20000000,
+  UNIT_LIMIT: 500
+};
+
+export async function createSendTransaction({
+  fromAddress,
+  toAddress,
+  value,
+  connection
+}: SendTransactionArgs): Promise<Transaction> {
+  const fromPubkey = new PublicKey(fromAddress);
+  const toPubkey = new PublicKey(toAddress);
+  const lamports = Math.floor(value * LAMPORTS_PER_SOL);
+
+  const { blockhash } = await connection.getLatestBlockhash();
+
+  const instructions = [
+    ComputeBudgetProgram.setComputeUnitPrice({
+      microLamports: COMPUTE_BUDGET_CONSTANTS.UNIT_PRICE_MICRO_LAMPORTS
+    }),
+    ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_BUDGET_CONSTANTS.UNIT_LIMIT }),
+    SystemProgram.transfer({
+      fromPubkey,
+      toPubkey,
+      lamports
+    })
+  ];
+
+  const transaction = new Transaction().add(...instructions);
+  transaction.feePayer = fromPubkey;
+  transaction.recentBlockhash = blockhash;
+
+  return transaction;
+}