Skip to main content

​
Overview

The Kit integration utilities allow you to convert legacy wallet adapters into Kit-compatible signers, enabling seamless use of @solana/kit’s modern architecture. DualConnection Support: All functions in this module support both legacy Connection from @solana/web3.js and Kit Rpc. Wallet adapters created with the Hermis wallet standard handle both connection types transparently through their sendTransaction and signAndSendTransaction methods.

​
createKitSignersFromAdapter()

Convert a wallet adapter to Kit-compatible signers. 
import { createKitSignersFromAdapter, getStandardWalletAdapters } from '@hermis/solana-headless-adapter-base';
import { Connection } from '@solana/web3.js';

// Auto-detect wallet-standard compatible wallets
const adapters = getStandardWalletAdapters([]);
const adapter = adapters[0]; // Use first detected wallet
await adapter.connect();

// Network auto-detected from connection endpoint
const connection = new Connection('https://api.devnet.solana.com');
const { address, addressString, messageSigner, transactionSigner } =
  createKitSignersFromAdapter(adapter, connection);

​
Parameters

​
adapter
WalletAdapter | null
required
The wallet adapter instance (must be connected)
​
connection
DualConnection
required
Solana connection (supports both web3.js Connection and Kit Rpc). Network is auto-detected from the endpoint.
​
network
'mainnet' | 'devnet' | 'testnet'
Optional network override. Use this for custom RPC URLs where auto-detection might fail.

​
Returns

​
KitSigners
object
Object containing Kit-compatible signers

​
Usage with Kit

import { createKitSignersFromAdapter, getStandardWalletAdapters } from '@hermis/solana-headless-adapter-base';
import { createSolanaRpc, devnet } from '@solana/kit';
import { getTransferSolInstruction } from '@solana-program/system';
import {
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction
} from '@solana/kit';

// Auto-detect wallet-standard compatible wallets
const adapters = getStandardWalletAdapters([]);
const adapter = adapters[0]; // Use first detected wallet
await adapter.connect();

// Create RPC connection (Kit Rpc)
const rpc = createSolanaRpc(devnet('https://api.devnet.solana.com'));

// Create Kit signers - works with both legacy Connection and Kit Rpc
// Network is auto-detected from RPC endpoint
const { address, transactionSigner } = createKitSignersFromAdapter(adapter, rpc);

if (!address || !transactionSigner) {
  throw new Error('Wallet not ready');
}

// Use with Kit RPC and instructions
const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

const message = pipe(
  createTransactionMessage({ version: 0 }),
  m => setTransactionMessageFeePayerSigner(transactionSigner, m),
  m => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),
  m => appendTransactionMessageInstruction(
    getTransferSolInstruction({
      source: address,
      destination: recipientAddress,
      amount: lamports(1000000n)
    }),
    m
  )
);

​
Helper Functions

​
adapterSupportsMessageSigning()

Check if a wallet adapter supports message signing. 
import { adapterSupportsMessageSigning } from '@hermis/solana-headless-adapter-base';

if (adapterSupportsMessageSigning(adapter)) {
  const signature = await adapter.signMessage(message);
}
​
adapter
WalletAdapter | null
required
The wallet adapter to check
​
return
boolean
true if the adapter supports message signing, false otherwise

​
adapterSupportsTransactionSending()

Check if a wallet adapter supports transaction sending. 
import { adapterSupportsTransactionSending } from '@hermis/solana-headless-adapter-base';

if (adapterSupportsTransactionSending(adapter)) {
  const signature = await adapter.sendTransaction(transaction, connection);
}
​
adapter
WalletAdapter | null
required
The wallet adapter to check
​
return
boolean
true if the adapter supports transaction sending, false otherwise

​
Chain Utilities

​
SOLANA_CHAINS

Constants for Solana chain identifiers following the Wallet Standard format. 
import { SOLANA_CHAINS } from '@hermis/solana-headless-adapter-base';

console.log(SOLANA_CHAINS.mainnet);  // 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'
console.log(SOLANA_CHAINS.devnet);   // 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1'
console.log(SOLANA_CHAINS.testnet);  // 'solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z'

​
getChainId()

Get the Wallet Standard chain identifier for a network. 
import { getChainId } from '@hermis/solana-headless-adapter-base';

const chainId = getChainId('devnet');
// Returns: 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1'
​
network
'mainnet' | 'devnet' | 'testnet'
required
The Solana network name
​
return
`solana:${string}`
The Wallet Standard chain identifier

​
getNetworkFromChainId()

Get the network name from a Wallet Standard chain identifier. 
import { getNetworkFromChainId } from '@hermis/solana-headless-adapter-base';

const network = getNetworkFromChainId('solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1');
// Returns: 'devnet'

const unknown = getNetworkFromChainId('solana:unknown');
// Returns: null
​
chain
string
required
The Wallet Standard chain identifier
​
return
'mainnet' | 'devnet' | 'testnet' | null
The network name, or null if unknown

​
isSolanaChain()

Check if a chain identifier is a Solana chain. 
import { isSolanaChain } from '@hermis/solana-headless-adapter-base';

if (isSolanaChain(chainId)) {
  // TypeScript knows chainId is `solana:${string}`
  console.log('This is a Solana chain');
}
​
chain
string
required
The chain identifier to check
​
return
boolean
true if the chain is a Solana chain, false otherwise

​
Transaction Helpers

​
createKitTransaction()

Create a Kit transaction message with automatic blockhash handling. Simplifies the process of building @solana/kit transactions. 
import { createKitTransaction } from '@hermis/solana-headless-adapter-base';
import { createSolanaRpc, devnet } from '@solana/kit';
import { getTransferSolInstruction } from '@solana-program/system';
import { lamports } from '@solana/kit';

// Works with both Connection and Kit Rpc
const rpc = createSolanaRpc(devnet('https://api.devnet.solana.com'));

// Create transaction with instructions
const transaction = await createKitTransaction(
  rpc,
  senderAddress,
  [
    getTransferSolInstruction({
      source: senderAddress,
      destination: recipientAddress,
      amount: lamports(1000000n)
    })
  ]
);
​
connection
DualConnection
required
Solana connection for fetching latest blockhash (supports both web3.js Connection and Kit Rpc)
​
feePayer
Address<string>
required
Address of the transaction fee payer
​
instructions
Instruction[]
Array of Kit instructions to include in the transaction. Defaults to empty array.
​
return
Promise<TransactionMessage>
A Kit TransactionMessage ready for signing, with blockhash and lifetime automatically set

​
Usage with Legacy Connection

import { Connection } from '@solana/web3.js';
import { createKitTransaction } from '@hermis/solana-headless-adapter-base';

const connection = new Connection('https://api.devnet.solana.com');

const transaction = await createKitTransaction(
  connection,
  feePayerAddress,
  instructions
);

​
Usage with Kit Rpc

import { createSolanaRpc, devnet } from '@solana/kit';
import { createKitTransaction } from '@hermis/solana-headless-adapter-base';

const rpc = createSolanaRpc(devnet('https://api.devnet.solana.com'));

const transaction = await createKitTransaction(
  rpc,
  feePayerAddress,
  instructions
);

​
Complete Example

import {
  createKitSignersFromAdapter,
  createKitTransaction,
  adapterSupportsMessageSigning,
  adapterSupportsTransactionSending,
  getStandardWalletAdapters
} from '@hermis/solana-headless-adapter-base';
import { createSolanaRpc, devnet } from '@solana/kit';
import { getTransferSolInstruction } from '@solana-program/system';
import { lamports } from '@solana/kit';

// Auto-detect wallet-standard compatible wallets
const adapters = getStandardWalletAdapters([]);
const adapter = adapters[0]; // Use first detected wallet
await adapter.connect();

// Check capabilities
console.log('Supports message signing:', adapterSupportsMessageSigning(adapter));
console.log('Supports transaction sending:', adapterSupportsTransactionSending(adapter));

// Create RPC connection (network auto-detected from endpoint)
const rpc = createSolanaRpc(devnet('https://api.devnet.solana.com'));

// Create Kit signers
const { address, addressString, messageSigner, transactionSigner } =
  createKitSignersFromAdapter(adapter, rpc);

if (!address || !transactionSigner) {
  throw new Error('Wallet not ready');
}

console.log('Connected address:', addressString);

// Create transaction using helper
const transaction = await createKitTransaction(
  rpc,
  address,
  [
    getTransferSolInstruction({
      source: address,
      destination: recipientAddress,
      amount: lamports(1000000n)
    })
  ]
);

​
Type Definitions

interface KitSigners {
  /** Kit Address type (null if wallet not connected) */
  address: Address<string> | null;

  /** Plain address string (null if wallet not connected) */
  addressString: string | null;

  /** Message signer (null if wallet doesn't support signing or not connected) */
  messageSigner: MessageModifyingSigner<string> | null;

  /** Transaction sending signer (null if wallet doesn't support or not connected) */
  transactionSigner: TransactionSendingSigner<string> | null;
}

type SolanaNetwork = 'mainnet' | 'devnet' | 'testnet';