@reown/appkit-solana-react-native 0.0.0-accounts-canary.1-20251023174733

package/src/types.ts

@@ -0,0 +1,132 @@
+import type {
+  CaipNetworkId,
+  Namespaces,
+  Storage,
+  WalletInfo
+} from '@reown/appkit-common-react-native';
+import type nacl from 'tweetnacl';
+import type { Connection } from '@solana/web3.js';
+
+// --- From helpers ---
+
+export interface TokenInfo {
+  address: string;
+  symbol: string;
+  name: string;
+  decimals: number;
+  logoURI?: string;
+}
+
+export type SPLTokenTransactionArgs = {
+  connection: Connection;
+  fromAddress: string;
+  toAddress: string;
+  amount: number;
+  tokenMint: string;
+};
+
+// --- From PhantomProvider ---
+
+export type Cluster = 'mainnet-beta' | 'testnet' | 'devnet';
+
+export type DeeplinkConnectResult = DeeplinkSession;
+
+export interface DeeplinkSession {
+  sessionToken: string;
+  userPublicKey: string;
+  walletEncryptionPublicKeyBs58: string;
+  cluster: Cluster;
+}
+
+export interface SignTransactionRequestParams {
+  transaction: string;
+}
+export interface SignMessageRequestParams {
+  message: Uint8Array | string;
+  display?: 'utf8' | 'hex';
+}
+export interface SignAllTransactionsRequestParams {
+  transactions: string[];
+}
+
+export interface DeeplinkResponse {
+  wallet_encryption_public_key?: string;
+  nonce: string;
+  data: string;
+}
+
+export interface DecryptedConnectData {
+  public_key: string;
+  session: string;
+}
+
+export interface DeeplinkProviderConfig {
+  appScheme: string;
+  dappUrl: string;
+  storage: Storage;
+  cluster?: Cluster;
+  dappEncryptionKeyPair: nacl.BoxKeyPair;
+  type: 'phantom' | 'solflare';
+  baseUrl: string;
+  encryptionKeyFieldName: string;
+}
+
+// Actual method names used in deeplink URLs
+export type DeeplinkRpcMethod =
+  | 'connect'
+  | 'disconnect'
+  | 'signTransaction'
+  | 'signAndSendTransaction'
+  | 'signAllTransactions'
+  | 'signMessage';
+
+export interface DeeplinkSignTransactionParams {
+  dapp_encryption_public_key: string;
+  redirect_link: string;
+  payload: string; // Encrypted JSON: { session: string, transaction: string }
+  nonce: string;
+  cluster?: Cluster;
+}
+
+export interface DeeplinkSignAllTransactionsParams {
+  dapp_encryption_public_key: string;
+  redirect_link: string;
+  payload: string; // Encrypted JSON: { session: string, transactions: string[] }
+  nonce: string;
+  cluster?: Cluster;
+}
+
+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 DeeplinkConnectParams {
+  app_url: string;
+  dapp_encryption_public_key: string;
+  redirect_link: string;
+  cluster?: Cluster;
+}
+
+export interface DeeplinkDisconnectParams {
+  dapp_encryption_public_key: string;
+  redirect_link: string;
+  payload: string; // Encrypted { session: string }
+  nonce: string;
+}
+
+export interface DeeplinkConnectorConfig {
+  type: 'phantom' | 'solflare';
+  cluster?: Cluster;
+}
+
+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;
+}