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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reown/appkit-solana-react-native",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-alpha.2",
   "main": "lib/commonjs/index.js",
   "types": "lib/typescript/index.d.ts",
   "module": "lib/module/index.js",
@@ -28,7 +28,7 @@
     "react-native"
   ],
   "repository": "https://github.com/reown-com/appkit-react-native",
-  "author": "Reown <support@reown.com> (https://reown.com)",
+  "author": "Reown (https://discord.gg/reown)",
   "homepage": "https://reown.com/appkit",
   "license": "Apache-2.0",
   "bugs": {
@@ -39,8 +39,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@reown/appkit-common-react-native": "2.0.0-alpha.1",
+    "@reown/appkit-common-react-native": "2.0.0-alpha.2",
+    "@solana/web3.js": "1.98.2",
     "bs58": "6.0.0",
     "tweetnacl": "1.0.3"
+  },
+  "peerDependencies": {
+    "@walletconnect/react-native-compat": ">=2.16.1",
+    "react": ">=18",
+    "react-native": ">=0.72"
   }
 }

package/src/adapter.ts

@@ -7,6 +7,17 @@ import {
   type GetBalanceResponse
 } from '@reown/appkit-common-react-native';
 import { getSolanaNativeBalance, getSolanaTokenBalance } from './helpers';
+import { Connection, Transaction, VersionedTransaction } from '@solana/web3.js';
+import base58 from 'bs58';
+import { createSendTransaction } from './utils/createSendTransaction';
+
+export interface SolanaTransactionData {
+  fromAddress: string;
+  toAddress: string;
+  amount: number;
+  network?: AppKitNetwork;
+  rpcUrl?: string;
+}
 
 export class SolanaAdapter extends SolanaBaseAdapter {
   private static supportedNamespace: ChainNamespace = 'solana';
@@ -14,7 +25,8 @@ export class SolanaAdapter extends SolanaBaseAdapter {
   constructor(configParams: { projectId: string }) {
     super({
       projectId: configParams.projectId,
-      supportedNamespace: SolanaAdapter.supportedNamespace
+      supportedNamespace: SolanaAdapter.supportedNamespace,
+      adapterType: 'solana'
     });
   }
 
@@ -64,6 +76,144 @@ export class SolanaAdapter extends SolanaBaseAdapter {
     }
   }
 
+  async signTransaction<T extends Transaction | VersionedTransaction>(
+    transaction: T,
+    network?: AppKitNetwork
+  ): Promise<T> {
+    if (!this.connector) {
+      throw new Error('SolanaAdapter:signTransaction - no active connector');
+    }
+
+    if (!network) {
+      throw new Error('SolanaAdapter:signTransaction - network is undefined');
+    }
+
+    const provider = this.connector.getProvider();
+    if (!provider) {
+      throw new Error('SolanaAdapter:signTransaction - provider is undefined');
+    }
+
+    try {
+      // Serialize transaction to base64 (following WalletConnect standard)
+      const serializedTransaction = Buffer.from(
+        new Uint8Array(transaction.serialize({ verifySignatures: false }))
+      ).toString('base64');
+
+      const result = (await provider.request(
+        {
+          method: 'solana_signTransaction',
+          params: {
+            transaction: serializedTransaction,
+            pubkey: this.getAccounts()?.[0]?.split(':')[2] || ''
+          }
+        },
+        network.caipNetworkId
+      )) as { signature?: string; transaction?: string };
+
+      // Handle different response formats
+      if ('signature' in result && result.signature) {
+        // Old RPC response format - add signature to transaction
+        const decoded = base58.decode(result.signature);
+        if (transaction instanceof Transaction && transaction.feePayer) {
+          transaction.addSignature(
+            transaction.feePayer,
+            Buffer.from(decoded) as Buffer & Uint8Array
+          );
+        }
+
+        return transaction;
+      }
+
+      if ('transaction' in result && result.transaction) {
+        // New response format - deserialize the signed transaction
+        const decodedTransaction = Buffer.from(result.transaction, 'base64');
+
+        if (transaction instanceof VersionedTransaction) {
+          return VersionedTransaction.deserialize(new Uint8Array(decodedTransaction)) as T;
+        }
+
+        return Transaction.from(decodedTransaction) as T;
+      }
+
+      throw new Error('SolanaAdapter:signTransaction - invalid response format');
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`SolanaAdapter:signTransaction - ${error.message}`);
+      }
+      throw new Error('SolanaAdapter:signTransaction - unknown error occurred');
+    }
+  }
+
+  async sendTransaction(data: SolanaTransactionData): Promise<string | null> {
+    const { fromAddress, toAddress, amount, network, rpcUrl } = data;
+
+    if (!this.connector) {
+      throw new Error('SolanaAdapter:sendTransaction - no active connector');
+    }
+
+    const provider = this.connector.getProvider();
+    if (!provider) {
+      throw new Error('SolanaAdapter:sendTransaction - provider is undefined');
+    }
+
+    if (!network) {
+      throw new Error('SolanaAdapter:sendTransaction - network is undefined');
+    }
+
+    if (!fromAddress) {
+      throw new Error('SolanaAdapter:sendTransaction - fromAddress is undefined');
+    }
+
+    if (!toAddress) {
+      throw new Error('SolanaAdapter:sendTransaction - toAddress is undefined');
+    }
+
+    if (!amount || amount <= 0) {
+      throw new Error('SolanaAdapter:sendTransaction - amount must be greater than 0');
+    }
+
+    try {
+      // Determine RPC URL
+      let connectionRpcUrl = rpcUrl;
+      if (!connectionRpcUrl && network) {
+        connectionRpcUrl = network.rpcUrls?.default?.http?.[0];
+      }
+      if (!connectionRpcUrl) {
+        throw new Error('SolanaAdapter:sendTransaction - no RPC URL available');
+      }
+
+      // Create connection
+      const connection = new Connection(connectionRpcUrl, 'confirmed');
+
+      const transaction = await createSendTransaction({
+        connection,
+        fromAddress,
+        toAddress,
+        value: amount
+      });
+
+      // Sign the transaction
+      const signedTransaction = await this.signTransaction(transaction, network);
+
+      // Send the signed transaction
+      const signature = await connection.sendRawTransaction(signedTransaction.serialize(), {
+        skipPreflight: false,
+        preflightCommitment: 'confirmed'
+      });
+
+      if (!signature) {
+        throw new Error('SolanaAdapter:sendTransaction - no signature returned');
+      }
+
+      return signature;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`SolanaAdapter:sendTransaction - ${error.message}`);
+      }
+      throw new Error('SolanaAdapter:sendTransaction - unknown error occurred');
+    }
+  }
+
   async switchNetwork(network: AppKitNetwork): Promise<void> {
     if (!this.connector) throw new Error('No active connector');
 

package/src/connectors/PhantomConnector.ts

@@ -11,7 +11,9 @@ import {
   type Storage,
   solana,
   solanaDevnet,
-  solanaTestnet
+  solanaTestnet,
+  type ConnectionProperties,
+  ConstantsUtil
 } from '@reown/appkit-common-react-native';
 import nacl from 'tweetnacl';
 import bs58 from 'bs58';
@@ -51,10 +53,10 @@ export class PhantomConnector extends WalletConnector {
     this.storage = ops.storage;
     await this.initializeKeyPair();
 
-    const appScheme = ops.metadata.redirect?.universal;
+    const appScheme = ops.metadata.redirect?.universal ?? ops.metadata.redirect?.native;
     if (!appScheme) {
       throw new Error(
-        'Phantom Connector: No universal link found in metadata. Please add redirect.universal to the metadata.'
+        'Phantom Connector: No redirect link found in metadata. Please add redirect.universal or redirect.native to the metadata.'
       );
     }
 
@@ -119,10 +121,7 @@ export class PhantomConnector extends WalletConnector {
       }
       this.currentCaipNetworkId = `solana:${solanaChainIdPart}` as CaipNetworkId;
 
-      this.wallet = {
-        name: 'Phantom Wallet',
-        id: 'phantom-wallet'
-      };
+      this.wallet = ConstantsUtil.PHANTOM_CUSTOM_WALLET;
 
       const userPublicKey = this.getProvider().getUserPublicKey();
       if (!userPublicKey) {
@@ -149,11 +148,10 @@ export class PhantomConnector extends WalletConnector {
   }
 
   override async disconnect(): Promise<void> {
-    if (!this.isConnected()) {
-      return Promise.resolve();
-    }
     try {
-      await this.getProvider().disconnect();
+      if (this.isConnected()) {
+        await super.disconnect();
+      }
     } catch (error: any) {
       // console.warn(`PhantomConnector: Error during provider disconnect: ${error.message}. Proceeding with local clear.`);
     }
@@ -199,6 +197,10 @@ export class PhantomConnector extends WalletConnector {
     return undefined;
   }
 
+  override getProperties(): ConnectionProperties | undefined {
+    return this.properties;
+  }
+
   override getWalletInfo(): WalletInfo | undefined {
     if (!this.isConnected()) {
       return undefined;
@@ -234,9 +236,7 @@ export class PhantomConnector extends WalletConnector {
       return Promise.resolve();
     }
 
-    // For deeplink wallets, switching network effectively means re-connecting to the new cluster.
-    // We can try to disconnect the current session and then initiate a new connection.
-    // console.log(`Attempting to switch network to: ${targetClusterName}`);
+    // Phantom doesn't provide a way to switch network, so we need to disconnect and reconnect.
     await this.disconnect(); // Clear current session
 
     // Create a temporary options object to guide the new connection
@@ -247,6 +247,7 @@ export class PhantomConnector extends WalletConnector {
     // Attempt to connect to the new cluster
     // The connect method will use the defaultChain from opts to determine the cluster.
     await this.connect(tempConnectOpts);
+    this.getProvider().emit('chainChanged', network.id);
 
     // Verify if the connection was successful and to the correct new network
     if (
@@ -260,7 +261,7 @@ export class PhantomConnector extends WalletConnector {
   }
 
   // Orchestrates session restoration
-  public async restoreSession(): Promise<boolean> {
+  override async restoreSession(): Promise<boolean> {
     try {
       const providerSession = await this.getProvider().restoreSession();
       if (!providerSession) {

package/src/index.ts

@@ -1,8 +1,8 @@
-// Connectors
-export { PhantomConnector } from './connectors/PhantomConnector';
+// Adapter
+export { SolanaAdapter } from './adapter';
 
 // Types
 export type { PhantomConnectorConfig } from './types';
 
-// Adapter
-export { SolanaAdapter } from './adapter';
+// Connectors
+export { PhantomConnector } from './connectors/PhantomConnector';

package/src/providers/PhantomProvider.ts

@@ -172,7 +172,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);
     }
@@ -271,6 +271,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 +285,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
     }

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;
+}