@reown/appkit-solana-react-native 0.0.0-canary-20251008180350

package/src/adapter.ts

@@ -0,0 +1,315 @@
+import {
+  SolanaBaseAdapter,
+  type AppKitNetwork,
+  type CaipAddress,
+  type ChainNamespace,
+  type GetBalanceParams,
+  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';
+import { createSPLTokenTransaction } from './utils/createSPLTokenTransaction';
+
+export interface SolanaTransactionData {
+  fromAddress: string;
+  toAddress: string;
+  amount: number;
+  network?: AppKitNetwork;
+  rpcUrl?: string;
+  tokenMint?: string;
+}
+
+export class SolanaAdapter extends SolanaBaseAdapter {
+  private static supportedNamespace: ChainNamespace = 'solana';
+
+  constructor() {
+    super({
+      supportedNamespace: SolanaAdapter.supportedNamespace,
+      adapterType: 'solana'
+    });
+  }
+
+  async getBalance(params: GetBalanceParams): Promise<GetBalanceResponse> {
+    const { network, address, tokens } = params;
+
+    if (!this.connector) throw new Error('No active connector');
+    if (!network) throw new Error('No network provided');
+
+    const balanceAddress =
+      address || this.getAccounts()?.find(account => account.includes(network.id.toString()));
+
+    if (!balanceAddress) {
+      return { amount: '0.00', symbol: 'SOL' };
+    }
+
+    try {
+      const rpcUrl = network.rpcUrls?.default?.http?.[0];
+      if (!rpcUrl) throw new Error('No RPC URL available');
+
+      const base58Address = balanceAddress.split(':')[2];
+
+      if (!base58Address) throw new Error('Invalid balance address');
+
+      const token = network?.caipNetworkId && tokens?.[network.caipNetworkId]?.address;
+      let balance;
+
+      if (token) {
+        const { amount, symbol } = await getSolanaTokenBalance(rpcUrl, base58Address, token);
+        balance = {
+          amount,
+          symbol
+        };
+      } else {
+        const amount = await getSolanaNativeBalance(rpcUrl, base58Address);
+        balance = {
+          amount: amount.toString(),
+          symbol: 'SOL'
+        };
+      }
+
+      this.emit('balanceChanged', { address: balanceAddress, balance });
+
+      return balance;
+    } catch (error) {
+      return { amount: '0.00', symbol: 'SOL' };
+    }
+  }
+
+  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('solana');
+    if (!provider) {
+      throw new Error('SolanaAdapter:signTransaction - provider is undefined');
+    }
+
+    try {
+      // Check if this is a deeplink provider (Phantom/Solflare)
+      const isDeeplinkProvider =
+        this.connector.type === 'phantom' || this.connector.type === 'solflare';
+
+      // Serialize transaction based on provider type
+      let serializedTransaction: string;
+      if (isDeeplinkProvider) {
+        // Deeplink providers (Phantom/Solflare) expect base58
+        const transactionBytes = new Uint8Array(transaction.serialize({ verifySignatures: false }));
+        serializedTransaction = base58.encode(transactionBytes);
+      } else {
+        // WalletConnect providers expect base64 (following WalletConnect standard)
+        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
+        let decodedTransaction: Buffer;
+
+        if (isDeeplinkProvider) {
+          // Deeplink providers return base58 encoded transactions
+          try {
+            const decodedBytes = base58.decode(result.transaction);
+            decodedTransaction = Buffer.from(decodedBytes);
+          } catch (error) {
+            throw new Error('Failed to decode base58 transaction from deeplink provider');
+          }
+        } else {
+          // WalletConnect providers return base64 encoded transactions
+          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, tokenMint } = data;
+
+    if (!this.connector) {
+      throw new Error('SolanaAdapter:sendTransaction - no active connector');
+    }
+
+    const provider = this.connector.getProvider('solana');
+    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 = tokenMint
+        ? await createSPLTokenTransaction({
+            connection,
+            fromAddress,
+            toAddress,
+            amount,
+            tokenMint
+          })
+        : await createSendTransaction({
+            connection,
+            fromAddress,
+            toAddress,
+            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');
+    }
+  }
+
+  override async signMessage(address: string, message: string, chainId?: string): Promise<string> {
+    try {
+      if (!this.connector) {
+        throw new Error('SolanaAdapter:signMessage - no active connector');
+      }
+
+      const provider = this.connector.getProvider('solana');
+      if (!provider) {
+        throw new Error('SolanaAdapter:signMessage - provider is undefined');
+      }
+
+      const chain = chainId ? `${this.getSupportedNamespace()}:${chainId}` : undefined;
+
+      const encodedMessage = new TextEncoder().encode(message);
+      const params = {
+        message: base58.encode(encodedMessage),
+        pubkey: address
+        // For Phantom, pubkey is not part of signMessage params directly with session
+        // For other wallets, it might be needed if they don't infer from session
+      };
+      const { signature } = (await provider.request(
+        { method: 'solana_signMessage', params },
+        chain
+      )) as {
+        signature: string;
+      };
+
+      return signature;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async switchNetwork(network: AppKitNetwork): Promise<void> {
+    if (!this.connector) throw new Error('No active connector');
+
+    const provider = this.connector.getProvider('solana');
+    if (!provider) throw new Error('No active provider');
+
+    try {
+      await this.connector.switchNetwork(network);
+
+      return;
+    } catch (switchError: any) {
+      throw switchError;
+    }
+  }
+
+  getAccounts(): CaipAddress[] | undefined {
+    if (!this.connector) throw new Error('No active connector');
+    const namespaces = this.connector.getNamespaces();
+
+    return namespaces[this.getSupportedNamespace()]?.accounts;
+  }
+
+  disconnect(): Promise<void> {
+    if (!this.connector) throw new Error('No active connector');
+
+    return this.connector.disconnect();
+  }
+
+  getSupportedNamespace(): ChainNamespace {
+    return SolanaAdapter.supportedNamespace;
+  }
+}

package/src/connectors/DeeplinkConnector.ts

@@ -0,0 +1,353 @@
+import {
+  WalletConnector,
+  type AppKitNetwork,
+  type CaipNetworkId,
+  type ChainNamespace,
+  type ConnectOptions,
+  type Namespaces,
+  type CaipAddress,
+  type ConnectorInitOptions,
+  type Storage,
+  solana,
+  solanaDevnet,
+  solanaTestnet,
+  type ConnectionProperties
+} from '@reown/appkit-common-react-native';
+import nacl from 'tweetnacl';
+import bs58 from 'bs58';
+
+import { DeeplinkProvider, SOLANA_SIGNING_METHODS } from '../providers/DeeplinkProvider';
+import type {
+  Cluster,
+  DeeplinkConnectorConfig,
+  DeeplinkConnectorSessionData,
+  DeeplinkProviderConfig
+} from '../types';
+
+const SOLANA_CLUSTER_TO_NETWORK: Record<Cluster, AppKitNetwork> = {
+  'mainnet-beta': solana,
+  'testnet': solanaTestnet,
+  'devnet': solanaDevnet
+};
+
+export abstract class DeeplinkConnector extends WalletConnector {
+  private readonly config: DeeplinkConnectorConfig;
+  private currentCaipNetworkId: CaipNetworkId | null = null;
+  private dappEncryptionKeyPair?: nacl.BoxKeyPair;
+
+  private static readonly SUPPORTED_NAMESPACE: ChainNamespace = 'solana';
+
+  constructor(config: DeeplinkConnectorConfig) {
+    super({ type: config.type });
+    this.config = config;
+  }
+
+  // Abstract methods that wallet-specific connectors must implement
+  protected abstract getBaseUrl(): string;
+  protected abstract getStorageKey(): string;
+  protected abstract getDappKeypairStorageKey(): string;
+  protected abstract getEncryptionKeyFieldName(): string;
+
+  override async init(ops: ConnectorInitOptions) {
+    super.init(ops);
+    this.storage = ops.storage;
+    await this.initializeKeyPair();
+
+    const appScheme = ops.metadata.redirect?.universal ?? ops.metadata.redirect?.native;
+    if (!appScheme) {
+      throw new Error(
+        `${this.type} connector: No redirect link found in metadata. Please add redirect.universal or redirect.native to the metadata.`
+      );
+    }
+
+    const providerConfig: DeeplinkProviderConfig = {
+      appScheme,
+      dappUrl: ops.metadata.url,
+      storage: ops.storage,
+      type: this.type as 'phantom' | 'solflare',
+      cluster: this.config?.cluster ?? 'mainnet-beta',
+      dappEncryptionKeyPair: this.dappEncryptionKeyPair!,
+      baseUrl: this.getBaseUrl(),
+      encryptionKeyFieldName: this.getEncryptionKeyFieldName()
+    };
+
+    this.provider = new DeeplinkProvider(providerConfig);
+    await this.restoreSession();
+  }
+
+  private async initializeKeyPair(): Promise<void> {
+    try {
+      const secretKeyB58 = await this.getStorage().getItem(this.getDappKeypairStorageKey());
+      if (secretKeyB58) {
+        const secretKey = bs58.decode(secretKeyB58);
+        this.dappEncryptionKeyPair = nacl.box.keyPair.fromSecretKey(secretKey);
+      } else {
+        const newKeyPair = nacl.box.keyPair();
+        this.dappEncryptionKeyPair = newKeyPair;
+        await this.getStorage().setItem(
+          this.getDappKeypairStorageKey(),
+          bs58.encode(newKeyPair.secretKey)
+        );
+      }
+    } catch (error) {
+      // disconnect and clear session
+      await this.disconnect();
+      throw error;
+    }
+  }
+
+  override async connect(opts?: ConnectOptions): Promise<Namespaces | undefined> {
+    if (this.isConnected() && this.namespaces) {
+      return this.namespaces;
+    }
+
+    const defaultNetworkId: CaipNetworkId | undefined =
+      opts?.defaultNetwork?.caipNetworkId?.split(':')?.[0] === 'solana'
+        ? opts?.defaultNetwork?.caipNetworkId
+        : opts?.namespaces?.['solana']?.chains?.[0];
+
+    const requestedCluster =
+      this.config?.cluster ??
+      (Object.keys(SOLANA_CLUSTER_TO_NETWORK).find(
+        key => SOLANA_CLUSTER_TO_NETWORK[key as Cluster]?.caipNetworkId === defaultNetworkId
+      ) as Cluster | undefined);
+
+    try {
+      const connectResult = await this.getProvider().connect({ cluster: requestedCluster });
+
+      const solanaChainId = SOLANA_CLUSTER_TO_NETWORK[connectResult.cluster]?.caipNetworkId;
+      if (!solanaChainId) {
+        throw new Error(
+          `${this.type} Connect: Internal - Unknown cluster mapping for ${connectResult.cluster}`
+        );
+      }
+      this.currentCaipNetworkId = solanaChainId;
+
+      this.wallet = {
+        name: this.getWalletInfo()?.name
+      };
+
+      const userPublicKey = this.getProvider().getUserPublicKey();
+      if (!userPublicKey) {
+        throw new Error(`${this.type} Connect: Provider failed to return a user public key.`);
+      }
+
+      const caipAddress = `${this.currentCaipNetworkId}:${userPublicKey}` as CaipAddress;
+      this.namespaces = {
+        [DeeplinkConnector.SUPPORTED_NAMESPACE]: {
+          accounts: [caipAddress],
+          methods: Object.values(SOLANA_SIGNING_METHODS),
+          events: [],
+          chains: [this.currentCaipNetworkId]
+        }
+      };
+
+      await this.saveSession(); // Save connector-specific session on successful connect
+
+      return this.namespaces;
+    } catch (error: any) {
+      this.clearSession();
+      throw error;
+    }
+  }
+
+  override async disconnect(): Promise<void> {
+    try {
+      if (this.isConnected()) {
+        await super.disconnect();
+      }
+    } catch (error: any) {
+      console.warn(
+        `${this.type} Connector: Error during provider disconnect: ${error.message}. Proceeding with local clear.`
+      );
+    }
+
+    // Cleanup provider resources
+    if (this.provider) {
+      (this.provider as DeeplinkProvider).destroy();
+    }
+
+    await this.clearSession();
+  }
+
+  private async clearSession(): Promise<void> {
+    this.namespaces = undefined;
+    this.wallet = undefined;
+    this.currentCaipNetworkId = null;
+    await this.clearSessionStorage();
+  }
+
+  override getProvider(): DeeplinkProvider {
+    if (!this.provider) {
+      throw new Error(`${this.type} Connector: Provider not initialized. Call init() first.`);
+    }
+
+    return this.provider as DeeplinkProvider;
+  }
+
+  private getStorage(): Storage {
+    if (!this.storage) {
+      throw new Error(`${this.type} Connector: Storage not initialized. Call init() first.`);
+    }
+
+    return this.storage;
+  }
+
+  override getNamespaces(): Namespaces {
+    if (!this.namespaces) {
+      throw new Error(`${this.type} Connector: Not connected. Call connect() first.`);
+    }
+
+    return this.namespaces;
+  }
+
+  override getChainId(namespace: ChainNamespace): CaipNetworkId | undefined {
+    if (namespace === DeeplinkConnector.SUPPORTED_NAMESPACE) {
+      return this.currentCaipNetworkId ?? undefined;
+    }
+
+    return undefined;
+  }
+
+  override getProperties(): ConnectionProperties | undefined {
+    return this.properties;
+  }
+
+  isConnected(): boolean {
+    // Rely solely on the provider as the source of truth for connection status.
+    const provider = this.getProvider();
+
+    return provider.isConnected() && !!provider.getUserPublicKey();
+  }
+
+  override async switchNetwork(network: AppKitNetwork): Promise<void> {
+    const targetClusterName = Object.keys(SOLANA_CLUSTER_TO_NETWORK).find(
+      key => SOLANA_CLUSTER_TO_NETWORK[key as Cluster]?.caipNetworkId === network.caipNetworkId
+    ) as Cluster | undefined;
+
+    if (!targetClusterName) {
+      throw new Error(
+        `${this.type} Connector: Cannot switch to unsupported network ID: ${network.id}`
+      );
+    }
+
+    const currentClusterName = Object.keys(SOLANA_CLUSTER_TO_NETWORK).find(
+      key => SOLANA_CLUSTER_TO_NETWORK[key as Cluster]?.caipNetworkId === this.currentCaipNetworkId
+    ) as Cluster | undefined;
+
+    if (targetClusterName === currentClusterName && this.isConnected()) {
+      return Promise.resolve();
+    }
+
+    // Phantom/Solflare don'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
+    const tempConnectOpts: ConnectOptions = {
+      defaultNetwork: SOLANA_CLUSTER_TO_NETWORK[targetClusterName]
+    };
+
+    // Attempt to connect to the new cluster
+    // The connect method will use the defaultNetwork 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 (
+      !this.isConnected() ||
+      this.getChainId(DeeplinkConnector.SUPPORTED_NAMESPACE) !==
+        tempConnectOpts.defaultNetwork?.caipNetworkId
+    ) {
+      throw new Error(
+        `${this.type} Connector: Failed to switch network to ${targetClusterName}. Please try connecting manually.`
+      );
+    }
+  }
+
+  // Orchestrates session restoration
+  override async restoreSession(): Promise<boolean> {
+    try {
+      const providerSession = await this.getProvider().restoreSession();
+      if (!providerSession) {
+        return false;
+      }
+
+      // If provider session is restored, try to restore connector data
+      const connectorData = await this.getStorage().getItem<DeeplinkConnectorSessionData>(
+        this.getStorageKey()
+      );
+      if (!connectorData) {
+        // Self-heal: reconstruct connector state from provider session
+        const userPublicKey = this.getProvider().getUserPublicKey();
+        const cluster = this.getProvider().getCurrentCluster();
+        const caipNetworkId = SOLANA_CLUSTER_TO_NETWORK[cluster]?.caipNetworkId;
+        if (userPublicKey && caipNetworkId) {
+          this.currentCaipNetworkId = caipNetworkId;
+          this.wallet = { name: this.getWalletInfo()?.name };
+          const caipAddress = `${caipNetworkId}:${userPublicKey}` as CaipAddress;
+          this.namespaces = {
+            [DeeplinkConnector.SUPPORTED_NAMESPACE]: {
+              accounts: [caipAddress],
+              methods: Object.values(SOLANA_SIGNING_METHODS),
+              events: [],
+              chains: [caipNetworkId]
+            }
+          };
+          await this.saveSession();
+        } else {
+          // Provider looks connected but we can't reconstruct state → clear everything
+          await this.disconnect();
+
+          return false;
+        }
+      } else {
+        this.namespaces = connectorData.namespaces;
+        this.wallet = connectorData.wallet;
+        this.currentCaipNetworkId = connectorData.currentCaipNetworkId;
+      }
+
+      // Final validation
+      if (this.isConnected()) {
+        return true;
+      }
+
+      // If validation fails, something is out of sync. Clear everything.
+      await this.disconnect();
+
+      return false;
+    } catch (error) {
+      // On any error, disconnect to ensure a clean state
+      await this.disconnect();
+
+      return false;
+    }
+  }
+
+  // Saves only connector-specific data
+  private async saveSession(): Promise<void> {
+    if (!this.namespaces || !this.wallet || !this.currentCaipNetworkId) {
+      return;
+    }
+
+    const connectorData: DeeplinkConnectorSessionData = {
+      namespaces: this.namespaces,
+      wallet: this.wallet,
+      currentCaipNetworkId: this.currentCaipNetworkId
+    };
+
+    try {
+      await this.getStorage().setItem(this.getStorageKey(), connectorData);
+    } catch (error) {
+      // console.error(`${this.type} Connector: Failed to save session.`, error);
+    }
+  }
+
+  // Clears only connector-specific data from storage
+  private async clearSessionStorage(): Promise<void> {
+    try {
+      await this.getStorage().removeItem(this.getStorageKey());
+    } catch (error) {
+      // console.error(`${this.type} Connector: Failed to clear session from storage.`, error);
+    }
+  }
+}

package/src/connectors/PhantomConnector.ts

@@ -0,0 +1,36 @@
+import { ConstantsUtil, type WalletInfo } from '@reown/appkit-common-react-native';
+import { DeeplinkConnector } from './DeeplinkConnector';
+import type { PhantomConnectorConfig } from '../types';
+
+const PHANTOM_BASE_URL = 'https://phantom.app/ul/v1';
+const PHANTOM_CONNECTOR_STORAGE_KEY = '@appkit/phantom-connector-data';
+const PHANTOM_DAPP_KEYPAIR_STORAGE_KEY = '@appkit/phantom-dapp-secret-key';
+
+export class PhantomConnector extends DeeplinkConnector {
+  constructor(config?: PhantomConnectorConfig) {
+    super({ type: 'phantom', cluster: config?.cluster });
+  }
+
+  override getWalletInfo(): WalletInfo {
+    return {
+      name: ConstantsUtil.PHANTOM_CUSTOM_WALLET.name,
+      type: 'external'
+    };
+  }
+
+  protected getBaseUrl(): string {
+    return PHANTOM_BASE_URL;
+  }
+
+  protected getStorageKey(): string {
+    return PHANTOM_CONNECTOR_STORAGE_KEY;
+  }
+
+  protected getDappKeypairStorageKey(): string {
+    return PHANTOM_DAPP_KEYPAIR_STORAGE_KEY;
+  }
+
+  protected getEncryptionKeyFieldName(): string {
+    return 'phantom_encryption_public_key';
+  }
+}