> ## Documentation Index
> Fetch the complete documentation index at: https://docs.hermis.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Wallet Connection Manager

> Manage wallet connections in vanilla TypeScript

## createWalletConnectionManager()

Factory function that creates a wallet connection manager for vanilla TypeScript applications.

```typescript theme={null}
import { createWalletConnectionManager } from '@hermis/solana-headless-adapter-base';
import { getStandardWalletAdapters } from '@hermis/wallet-standard-base';
import { WalletAdapterNetwork } from '@hermis/solana-headless-core';

// Auto-detect wallet-standard compatible wallets
const wallets = []; // Add custom wallet adapters here if needed
const adapters = await getStandardWalletAdapters(wallets, undefined, WalletAdapterNetwork.Mainnet);

const manager = createWalletConnectionManager(
  adapters,
  WalletAdapterNetwork.Mainnet,
  'wallet-name-storage-key',
  'https://api.devnet.solana.com'  // Optional: for wallet detection
);
```

### Parameters

<ParamField path="adapters" type="Adapter[]" required>
  Array of wallet adapters to manage
</ParamField>

<ParamField path="network" type="WalletAdapterNetwork" required>
  Active Solana network. Required so wallet adapters can set their chain hint
  explicitly — previous versions inferred this from the RPC URL which was
  unsafe (untrusted URLs containing "mainnet" would be misclassified).
</ParamField>

<ParamField path="localStorageKey" type="string" default="walletName">
  Key to store the selected wallet name in localStorage
</ParamField>

<ParamField path="endpoint" type="string">
  Optional RPC endpoint for automatic wallet detection
</ParamField>

## WalletConnectionManager Interface

The returned manager object provides the following methods:

### getAdapter()

Get the currently selected wallet adapter.

```typescript theme={null}
const adapter = manager.getAdapter();
if (adapter) {
  console.log('Selected:', adapter.name);
}
```

<ResponseField name="return" type="Adapter | null">
  The currently selected adapter, or null if none selected
</ResponseField>

### selectWallet()

Select a wallet by name.

```typescript theme={null}
const adapter = manager.selectWallet('Phantom');
```

<ParamField path="walletName" type="WalletName | null" required>
  Name of the wallet to select, or null to deselect
</ParamField>

<ResponseField name="return" type="Adapter | null">
  The selected adapter, or null
</ResponseField>

### connect()

Connect to the selected wallet.

```typescript theme={null}
try {
  const adapter = await manager.connect();
  console.log('Connected:', adapter?.publicKey?.toBase58());
} catch (error) {
  console.error('Connection failed:', error);
}
```

<ResponseField name="return" type="Promise<Adapter | null>">
  Promise resolving to the connected adapter
</ResponseField>

### disconnect()

Disconnect from the current wallet.

```typescript theme={null}
await manager.disconnect();
```

<ResponseField name="return" type="Promise<void>">
  Promise that resolves when disconnected
</ResponseField>

### autoConnect()

Automatically reconnect to the previously selected wallet on page load.

```typescript theme={null}
// On app startup
const adapter = await manager.autoConnect();
if (adapter) {
  console.log('Auto-reconnected to:', adapter.name);
}
```

<ResponseField name="return" type="Promise<Adapter | null>">
  Promise resolving to the reconnected adapter, or null
</ResponseField>

## Transaction Methods

The manager supports dual architecture (web3.js and Kit) for all transaction operations:

### signTransaction()

Sign a single transaction.

```typescript theme={null}
import { Transaction } from '@solana/web3.js';

const signedTx = await manager.signTransaction(transaction);
```

<ParamField path="transaction" type="DualTransaction" required>
  Transaction to sign (Transaction, VersionedTransaction, or TransactionMessage)
</ParamField>

<ParamField path="options" type="DualArchitectureOptions">
  Optional architecture-specific options
</ParamField>

### signAllTransactions()

Sign multiple transactions.

```typescript theme={null}
const signedTxs = await manager.signAllTransactions([tx1, tx2, tx3]);
```

### sendTransaction()

Send a transaction to the network.

```typescript theme={null}
const signature = await manager.sendTransaction(
  connection,
  transaction
);
```

<ParamField path="connection" type="DualConnection" required>
  Solana connection (web3.js Connection or Kit Rpc)
</ParamField>

<ParamField path="transaction" type="DualTransaction" required>
  Transaction to send
</ParamField>

### signAndSendTransaction()

Sign and send a transaction in one operation.

```typescript theme={null}
const signature = await manager.signAndSendTransaction(
  connection,
  transaction
);
```

## Adapter Management

### getAdapters()

Get all available wallet adapters (including dynamically detected ones).

```typescript theme={null}
const allAdapters = manager.getAdapters();
console.log('Available wallets:', allAdapters.map(a => a.name));
```

<ResponseField name="return" type="Adapter[]">
  Array of all detected wallet adapters
</ResponseField>

### onAdaptersChange()

Subscribe to adapter list changes (e.g., when new wallets are dynamically registered).

```typescript theme={null}
const unsubscribe = manager.onAdaptersChange((adapters) => {
  console.log('Adapters updated:', adapters.length);
});

// Later: unsubscribe when no longer needed
unsubscribe();
```

<ParamField path="callback" type="(adapters: Adapter[]) => void" required>
  Function called when adapter list changes
</ParamField>

<ResponseField name="return" type="() => void">
  Unsubscribe function to stop listening for changes
</ResponseField>

## Complete Example

```typescript theme={null}
import { createWalletConnectionManager } from '@hermis/solana-headless-adapter-base';
import { getStandardWalletAdapters } from '@hermis/wallet-standard-base';
import { WalletAdapterNetwork } from '@hermis/solana-headless-core';
import { Connection, Transaction, SystemProgram, LAMPORTS_PER_SOL } from '@solana/web3.js';

// Auto-detect wallet-standard compatible wallets
const wallets = []; // Add custom wallet adapters here if needed
const adapters = await getStandardWalletAdapters(wallets, undefined, WalletAdapterNetwork.Mainnet);

// Create manager
const manager = createWalletConnectionManager(
  adapters,
  'my-app-wallet',
  'https://api.devnet.solana.com'
);

// Listen for adapter changes
manager.onAdaptersChange((adapters) => {
  console.log('Available wallets:', adapters.map(a => a.name));
});

// Connect to wallet
manager.selectWallet('Phantom');
const adapter = await manager.connect();

if (!adapter) {
  throw new Error('Failed to connect');
}

// Send a transaction
const connection = new Connection('https://api.devnet.solana.com');
const transaction = new Transaction().add(
  SystemProgram.transfer({
    fromPubkey: adapter.publicKey!,
    toPubkey: recipientPublicKey,
    lamports: 0.001 * LAMPORTS_PER_SOL
  })
);

const signature = await manager.signAndSendTransaction(connection, transaction);
console.log('Transaction signature:', signature);

// Disconnect when done
await manager.disconnect();
```