Skip to main content

​
createWalletConnectionManager()

Factory function that creates a wallet connection manager for vanilla TypeScript applications. 
import { createWalletConnectionManager, getStandardWalletAdapters } from '@hermis/solana-headless-adapter-base';

// Auto-detect wallet-standard compatible wallets
const wallets = []; // Add custom wallet adapters here if needed
const adapters = getStandardWalletAdapters(wallets);

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

​
Parameters

​
adapters
Adapter[]
required
Array of wallet adapters to manage
​
localStorageKey
string
default:"walletName"
Key to store the selected wallet name in localStorage
​
endpoint
string
Optional RPC endpoint for automatic wallet detection

​
WalletConnectionManager Interface

The returned manager object provides the following methods:

​
getAdapter()

Get the currently selected wallet adapter. 
const adapter = manager.getAdapter();
if (adapter) {
  console.log('Selected:', adapter.name);
}
​
return
Adapter | null
The currently selected adapter, or null if none selected

​
selectWallet()

Select a wallet by name. 
const adapter = manager.selectWallet('Phantom');
​
walletName
WalletName | null
required
Name of the wallet to select, or null to deselect
​
return
Adapter | null
The selected adapter, or null

​
connect()

Connect to the selected wallet. 
try {
  const adapter = await manager.connect();
  console.log('Connected:', adapter?.publicKey?.toBase58());
} catch (error) {
  console.error('Connection failed:', error);
}
​
return
Promise<Adapter | null>
Promise resolving to the connected adapter

​
disconnect()

Disconnect from the current wallet. 
await manager.disconnect();
​
return
Promise<void>
Promise that resolves when disconnected

​
autoConnect()

Automatically reconnect to the previously selected wallet on page load. 
// On app startup
const adapter = await manager.autoConnect();
if (adapter) {
  console.log('Auto-reconnected to:', adapter.name);
}
​
return
Promise<Adapter | null>
Promise resolving to the reconnected adapter, or null

​
Transaction Methods

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

​
signTransaction()

Sign a single transaction. 
import { Transaction } from '@solana/web3.js';

const signedTx = await manager.signTransaction(transaction);
​
transaction
DualTransaction
required
Transaction to sign (Transaction, VersionedTransaction, or TransactionMessage)
​
options
DualArchitectureOptions
Optional architecture-specific options

​
signAllTransactions()

Sign multiple transactions. 
const signedTxs = await manager.signAllTransactions([tx1, tx2, tx3]);

​
sendTransaction()

Send a transaction to the network. 
const signature = await manager.sendTransaction(
  connection,
  transaction
);
​
connection
DualConnection
required
Solana connection (web3.js Connection or Kit Rpc)
​
transaction
DualTransaction
required
Transaction to send

​
signAndSendTransaction()

Sign and send a transaction in one operation. 
const signature = await manager.signAndSendTransaction(
  connection,
  transaction
);

​
Adapter Management

​
getAdapters()

Get all available wallet adapters (including dynamically detected ones). 
const allAdapters = manager.getAdapters();
console.log('Available wallets:', allAdapters.map(a => a.name));
​
return
Adapter[]
Array of all detected wallet adapters

​
onAdaptersChange()

Subscribe to adapter list changes (e.g., when new wallets are dynamically registered). 
const unsubscribe = manager.onAdaptersChange((adapters) => {
  console.log('Adapters updated:', adapters.length);
});

// Later: unsubscribe when no longer needed
unsubscribe();
​
callback
(adapters: Adapter[]) => void
required
Function called when adapter list changes
​
return
() => void
Unsubscribe function to stop listening for changes

​
Complete Example

import { createWalletConnectionManager, getStandardWalletAdapters } from '@hermis/solana-headless-adapter-base';
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 = getStandardWalletAdapters(wallets);

// 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();