# `useEmbeddedSolanaWallet`

Manages embedded Solana wallets with creation, activation, and signing capabilities.

:::info
Solana wallets are always EOA (Externally Owned Accounts) and work across all Solana networks (mainnet, devnet, testnet).
:::

**Recovery methods:**

* Automatic recovery (via encryption session)
* Password-based recovery
* Passkey-based recovery (biometric)

## Usage

```tsx
import { useEmbeddedSolanaWallet } from '@openfort/react-native';
import { Transaction } from '@solana/web3.js';

function SolanaWalletManager() {
  const solana = useEmbeddedSolanaWallet({
    onCreateSuccess: (account, provider) => {
      console.log('Solana wallet created:', account.address);
      console.log('Public key:', provider.publicKey);
    },
  });

  if (solana.status === 'connecting' || solana.status === 'creating') {
    return <ActivityIndicator />;
  }

  if (solana.status === 'connected') {
    const signTransaction = async () => {
      const transaction = new Transaction();
      // ... add instructions to transaction
      const signed = await solana.provider.signTransaction(transaction);
      console.log('Signed transaction:', signed);
    };

    const signMessage = async () => {
      const message = 'Hello Solana!';
      const signature = await solana.provider.signMessage(message);
      console.log('Message signature:', signature);
    };

    return (
      <View>
        <Text>Connected: {solana.activeWallet.address}</Text>
        <Button title="Sign Transaction" onPress={signTransaction} />
        <Button title="Sign Message" onPress={signMessage} />
      </View>
    );
  }

  if (solana.wallets.length === 0) {
    return (
      <Button
        title="Create Wallet"
        onPress={() => solana.create({ recoveryPassword: 'optional' })}
      />
    );
  }

  return (
    <Button
      title="Connect"
      onPress={() => solana.setActive({
        address: solana.wallets[0].address,
        recoveryPassword: 'optional'
      })}
    />
  );
}
```

## Return type

Returns a discriminated union based on the `status` field:

```ts
type EmbeddedSolanaWalletState = {
  status: 'disconnected' | 'fetching-wallets' | 'connecting' | 'reconnecting' | 'creating' | 'needs-recovery' | 'connected' | 'error'
  wallets: ConnectedEmbeddedSolanaWallet[]
  activeWallet: ConnectedEmbeddedSolanaWallet | null
  provider?: OpenfortEmbeddedSolanaWalletProvider  // Available when connected
  error?: string  // Available when error
  create: (options?: CreateOptions) => Promise<EmbeddedAccount>
  setActive: (options: SetActiveOptions) => Promise<void>
  exportPrivateKey: () => Promise<string>
}

type ConnectedEmbeddedSolanaWallet = {
  id: string
  address: string
  chainType: 'SVM'
  createdAt?: number
  recoveryMethod?: RecoveryMethod
  recoveryMethodDetails?: RecoveryMethodDetails
  walletIndex: number
  getProvider: () => Promise<OpenfortEmbeddedSolanaWalletProvider>
}

type OpenfortEmbeddedSolanaWalletProvider = {
  publicKey: string
  signTransaction: (transaction: SolanaTransaction) => Promise<SignedSolanaTransaction>
  signAllTransactions: (transactions: SolanaTransaction[]) => Promise<SignedSolanaTransaction[]>
  signMessage: (message: string) => Promise<string>
  request(args: SolanaSignMessageRequest): Promise<{ signature: string }>
  request(args: SolanaSignTransactionRequest): Promise<{ signedTransaction: SignedSolanaTransaction }>
}

type SolanaTransaction =
  | { messageBytes: Uint8Array }  // @solana/kit compiled transaction
  | { serializeMessage(): Uint8Array }  // @solana/web3.js Transaction
  | Uint8Array  // Raw bytes

type SignedSolanaTransaction = {
  signature: string
  publicKey: string
}
```

The provider is compatible with `@solana/web3.js` and `@solana/kit` transaction formats.

## Parameters

### Hook options

Pass these options when initializing the hook:

```ts
type UseEmbeddedSolanaWalletOptions = {
  onCreateSuccess?: (account: EmbeddedAccount, provider: OpenfortEmbeddedSolanaWalletProvider) => void
  onCreateError?: (error: OpenfortError) => void
  onSetActiveSuccess?: (wallet: ConnectedEmbeddedSolanaWallet, provider: OpenfortEmbeddedSolanaWalletProvider) => void
  onSetActiveError?: (error: OpenfortError) => void
}
```

### `create`

Creates a new embedded Solana wallet.

```ts
type CreateOptions = {
  recoveryPassword?: string
  otpCode?: string  // OTP code for Shield verification when using automatic recovery
  createAdditional?: boolean  // Create additional wallet if one already exists
  recoveryMethod?: 'automatic' | 'password' | 'passkey'  // Recovery method to use
  passkeyId?: string  // Passkey credential ID (for passkey recovery)
  onSuccess?: (data: CreateResult) => void
  onError?: (error: OpenfortError) => void
  throwOnError?: boolean
}

type CreateResult = {
  account?: EmbeddedAccount
  provider?: OpenfortEmbeddedSolanaWalletProvider
  error?: OpenfortError
}
```

### `setActive`

Activates an existing wallet and makes it the active wallet.

```ts
type SetActiveOptions = {
  address: string
  recoveryPassword?: string
  otpCode?: string  // OTP code for Shield verification when using automatic recovery
  recoveryMethod?: 'automatic' | 'password' | 'passkey'  // Recovery method to use
  passkeyId?: string  // Passkey credential ID (auto-detected from wallet if not provided)
  onSuccess?: (data: SetActiveResult) => void
  onError?: (error: OpenfortError) => void
  throwOnError?: boolean
}

type SetActiveResult = {
  wallet?: ConnectedEmbeddedSolanaWallet
  provider?: OpenfortEmbeddedSolanaWalletProvider
  error?: OpenfortError
}
```

## Passkey recovery

Passkey recovery uses device biometrics (Face ID, Touch ID, fingerprint) for secure wallet recovery without passwords.

:::info
Passkey support requires native builds and proper domain configuration. See the [Passkey Quickstart](/docs/products/embedded-wallet/react-native/quickstart/passkey) for setup instructions.
:::

### Creating a Solana wallet with passkey

```tsx
import { useEmbeddedSolanaWallet, usePasskeyPrfSupport } from '@openfort/react-native';

function SolanaWalletCreation() {
  const { isSupported: passkeySupported } = usePasskeyPrfSupport();
  const { create, status } = useEmbeddedSolanaWallet();

  const createWithPasskey = async () => {
    await create({
      recoveryMethod: 'passkey',
      onSuccess: ({ account }) => {
        console.log('Solana wallet created with passkey:', account?.address);
      },
      onError: (error) => {
        console.error('Failed:', error.message);
      },
    });
  };

  return (
    <Button
      title="Create Solana Wallet with Passkey"
      onPress={createWithPasskey}
      disabled={!passkeySupported || status === 'creating'}
    />
  );
}
```