@reown/appkit-solana-react-native 2.0.0 → 2.0.1

package/src/types.ts

@@ -5,6 +5,7 @@ import type {
   WalletInfo
 } from '@reown/appkit-common-react-native';
 import type nacl from 'tweetnacl';
+import type { Connection } from '@solana/web3.js';
 
 // --- From helpers ---
 
@@ -16,24 +17,25 @@ export interface TokenInfo {
   logoURI?: string;
 }
 
-// --- From PhantomProvider ---
+export type SPLTokenTransactionArgs = {
+  connection: Connection;
+  fromAddress: string;
+  toAddress: string;
+  amount: number;
+  tokenMint: string;
+};
 
-export type PhantomCluster = 'mainnet-beta' | 'testnet' | 'devnet';
+// --- From PhantomProvider ---
 
-export interface PhantomProviderConfig {
-  appScheme: string;
-  dappUrl: string;
-  storage: Storage;
-  dappEncryptionKeyPair: nacl.BoxKeyPair;
-}
+export type Cluster = 'mainnet-beta' | 'testnet' | 'devnet';
 
-export type PhantomConnectResult = PhantomSession;
+export type DeeplinkConnectResult = DeeplinkSession;
 
-export interface PhantomSession {
+export interface DeeplinkSession {
   sessionToken: string;
   userPublicKey: string;
-  phantomEncryptionPublicKeyBs58: string;
-  cluster: PhantomCluster;
+  walletEncryptionPublicKeyBs58: string;
+  cluster: Cluster;
 }
 
 export interface SignTransactionRequestParams {
@@ -47,8 +49,8 @@ export interface SignAllTransactionsRequestParams {
   transactions: string[];
 }
 
-export interface PhantomDeeplinkResponse {
-  phantom_encryption_public_key?: string;
+export interface DeeplinkResponse {
+  wallet_encryption_public_key?: string;
   nonce: string;
   data: string;
 }
@@ -58,22 +60,19 @@ export interface DecryptedConnectData {
   session: string;
 }
 
-export interface PhantomProviderConfig {
+export interface DeeplinkProviderConfig {
   appScheme: string;
   dappUrl: string;
   storage: Storage;
+  cluster?: Cluster;
   dappEncryptionKeyPair: nacl.BoxKeyPair;
+  type: 'phantom' | 'solflare';
+  baseUrl: string;
+  encryptionKeyFieldName: string;
 }
 
-export interface PhantomSession {
-  sessionToken: string;
-  userPublicKey: string;
-  phantomEncryptionPublicKeyBs58: string;
-  cluster: PhantomCluster;
-}
-
-// Actual method names used in Phantom deeplink URLs
-export type PhantomRpcMethod =
+// Actual method names used in deeplink URLs
+export type DeeplinkRpcMethod =
   | 'connect'
   | 'disconnect'
   | 'signTransaction'
@@ -81,51 +80,53 @@ export type PhantomRpcMethod =
   | 'signAllTransactions'
   | 'signMessage';
 
-export interface PhantomSignTransactionParams {
+export interface DeeplinkSignTransactionParams {
   dapp_encryption_public_key: string;
   redirect_link: string;
   payload: string; // Encrypted JSON: { session: string, transaction: string }
   nonce: string;
-  cluster?: PhantomCluster;
+  cluster?: Cluster;
 }
 
-export interface PhantomSignAllTransactionsParams {
+export interface DeeplinkSignAllTransactionsParams {
   dapp_encryption_public_key: string;
   redirect_link: string;
   payload: string; // Encrypted JSON: { session: string, transactions: string[] }
   nonce: string;
-  cluster?: PhantomCluster;
+  cluster?: Cluster;
 }
 
-export interface PhantomSignMessageParams {
+export interface DeeplinkSignMessageParams {
   dapp_encryption_public_key: string;
   redirect_link: string;
   payload: string; // Encrypted JSON string: { message: string, session: string, display: 'utf8'|'hex' }
   nonce: string;
 }
 
-export interface PhantomConnectParams {
+export interface DeeplinkConnectParams {
   app_url: string;
   dapp_encryption_public_key: string;
   redirect_link: string;
-  cluster?: PhantomCluster;
+  cluster?: Cluster;
 }
 
-export interface PhantomDisconnectParams {
+export interface DeeplinkDisconnectParams {
   dapp_encryption_public_key: string;
   redirect_link: string;
   payload: string; // Encrypted { session: string }
   nonce: string;
 }
 
-// --- From PhantomConnector ---
-
-export interface PhantomConnectorConfig {
-  cluster?: PhantomCluster;
+export interface DeeplinkConnectorConfig {
+  type: 'phantom' | 'solflare';
+  cluster?: Cluster;
 }
 
-export interface PhantomConnectorSessionData {
+export interface DeeplinkConnectorSessionData {
   namespaces: Namespaces;
   wallet: WalletInfo;
   currentCaipNetworkId: CaipNetworkId;
 }
+
+export type PhantomConnectorConfig = Pick<DeeplinkConnectorConfig, 'cluster'>;
+export type SolflareConnectorConfig = Pick<DeeplinkConnectorConfig, 'cluster'>;

package/src/utils/createSPLTokenTransaction.ts

@@ -0,0 +1,152 @@
+import {
+  TOKEN_2022_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  TokenAccountNotFoundError,
+  createAssociatedTokenAccountInstruction,
+  createTransferCheckedInstruction,
+  getAccount,
+  getAssociatedTokenAddressSync,
+  getMint
+} from '@solana/spl-token';
+import {
+  ComputeBudgetProgram,
+  Connection,
+  PublicKey,
+  Transaction,
+  type TransactionInstruction
+} from '@solana/web3.js';
+import type { SPLTokenTransactionArgs } from '../types';
+
+const SPL_COMPUTE_BUDGET_CONSTANTS = {
+  UNIT_PRICE_MICRO_LAMPORTS: 1000000,
+  UNIT_LIMIT_WITH_ATA_CREATION: 400000
+} as const;
+
+async function getMintOwnerProgramId(connection: Connection, mint: PublicKey) {
+  const info = await connection.getAccountInfo(mint);
+
+  if (!info) {
+    throw new Error('Mint account not found');
+  }
+
+  if (info.owner.equals(TOKEN_PROGRAM_ID)) {
+    return TOKEN_PROGRAM_ID;
+  }
+
+  if (info.owner.equals(TOKEN_2022_PROGRAM_ID)) {
+    return TOKEN_2022_PROGRAM_ID;
+  }
+
+  throw new Error('Unknown mint owner program');
+}
+
+export async function createSPLTokenTransaction({
+  fromAddress,
+  toAddress,
+  amount,
+  tokenMint,
+  connection
+}: SPLTokenTransactionArgs): Promise<Transaction> {
+  if (!fromAddress) {
+    throw new Error('No public key found');
+  }
+  if (amount <= 0) {
+    throw new Error('Amount must be greater than 0');
+  }
+  try {
+    const fromPubkey = new PublicKey(fromAddress);
+    const toPubkey = new PublicKey(toAddress);
+    const mintPubkey = new PublicKey(tokenMint);
+
+    const programId = await getMintOwnerProgramId(connection, mintPubkey);
+
+    const mintInfo = await getMint(connection, mintPubkey, undefined, programId);
+    const decimals = mintInfo.decimals;
+    if (decimals < 0) {
+      throw new Error('Invalid token decimals');
+    }
+
+    const tokenAmount = Math.floor(amount * 10 ** decimals);
+
+    const fromTokenAccount = getAssociatedTokenAddressSync(
+      mintPubkey,
+      fromPubkey,
+      false,
+      programId
+    );
+    const toTokenAccount = getAssociatedTokenAddressSync(mintPubkey, toPubkey, false, programId);
+
+    try {
+      const fromAccount = await getAccount(connection, fromTokenAccount, undefined, programId);
+      if (fromAccount.amount < BigInt(tokenAmount)) {
+        throw new Error('Insufficient token balance');
+      }
+    } catch (error) {
+      if (error instanceof TokenAccountNotFoundError) {
+        throw new Error('Sender does not have a token account for this mint');
+      }
+      throw error;
+    }
+
+    let shouldCreateATA = false;
+    try {
+      await getAccount(connection, toTokenAccount, undefined, programId);
+    } catch (error) {
+      if (error instanceof TokenAccountNotFoundError) {
+        shouldCreateATA = true;
+      } else {
+        throw error;
+      }
+    }
+
+    const instructions: TransactionInstruction[] = [];
+
+    if (shouldCreateATA) {
+      instructions.push(
+        ComputeBudgetProgram.setComputeUnitPrice({
+          microLamports: SPL_COMPUTE_BUDGET_CONSTANTS.UNIT_PRICE_MICRO_LAMPORTS
+        }),
+        ComputeBudgetProgram.setComputeUnitLimit({
+          units: SPL_COMPUTE_BUDGET_CONSTANTS.UNIT_LIMIT_WITH_ATA_CREATION
+        })
+      );
+
+      instructions.push(
+        createAssociatedTokenAccountInstruction(
+          fromPubkey,
+          toTokenAccount,
+          toPubkey,
+          mintPubkey,
+          programId
+        )
+      );
+    }
+
+    instructions.push(
+      createTransferCheckedInstruction(
+        fromTokenAccount,
+        mintPubkey,
+        toTokenAccount,
+        fromPubkey,
+        tokenAmount,
+        decimals,
+        [],
+        programId
+      )
+    );
+
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+
+    return new Transaction({
+      feePayer: fromPubkey,
+      blockhash,
+      lastValidBlockHeight
+    }).add(...instructions);
+  } catch (error) {
+    throw new Error(
+      `Failed to create SPL token transaction: ${
+        error instanceof Error ? error.message : 'Unknown error'
+      }`
+    );
+  }
+}

package/src/utils/createSendTransaction.ts

@@ -0,0 +1,41 @@
+import {
+  type Connection,
+  LAMPORTS_PER_SOL,
+  PublicKey,
+  SystemProgram,
+  Transaction
+} from '@solana/web3.js';
+
+type SendTransactionArgs = {
+  connection: Connection;
+  fromAddress: string;
+  toAddress: string;
+  amount: number;
+};
+
+export async function createSendTransaction({
+  fromAddress,
+  toAddress,
+  amount,
+  connection
+}: SendTransactionArgs): Promise<Transaction> {
+  const fromPubkey = new PublicKey(fromAddress);
+  const toPubkey = new PublicKey(toAddress);
+  const lamports = Math.floor(amount * LAMPORTS_PER_SOL);
+
+  const { blockhash } = await connection.getLatestBlockhash();
+
+  const instructions = [
+    SystemProgram.transfer({
+      fromPubkey,
+      toPubkey,
+      lamports
+    })
+  ];
+
+  const transaction = new Transaction().add(...instructions);
+  transaction.feePayer = fromPubkey;
+  transaction.recentBlockhash = blockhash;
+
+  return transaction;
+}