Bookie simulates every transaction before presenting it for approval, preventing failures and unexpected outcomes.
How Simulation Works
Before you see a transaction in your wallet, Bookie runs it through Solana’s simulation engine:
Build Transaction
Construct transaction with all instructions and accounts
Simulate Execution
Run transaction against current blockchain state
Analyze Results
Check for errors, compute usage, and balance changes
Present to User
Only show transaction if simulation succeeds
What Simulation Catches
Insufficient Balance
Not enough tokens or SOL for transaction
Slippage Exceeded
Price moved beyond acceptable range
Account Errors
Missing or invalid token accounts
Program Failures
Smart contract execution errors
Simulation API
Bookie uses Solana’s simulateTransaction RPC method:
const simulation = await connection.simulateTransaction(
transaction,
{
commitment: 'confirmed',
sigVerify: false
}
);
if (simulation.value.err) {
throw new Error(`Simulation failed: ${simulation.value.err}`);
}
console.log('Compute units used:', simulation.value.unitsConsumed);
console.log('Logs:', simulation.value.logs);
Simulation Response
A successful simulation returns:
| Field | Description |
|---|
err | Error object (null if successful) |
logs | Program execution logs |
unitsConsumed | Compute units used |
accounts | Post-transaction account states |
Error Types
Common simulation errors and their meanings:
Insufficient Funds
Error: Attempt to debit an account but found no record of a prior credit
Slippage Tolerance Exceeded
Error: Slippage tolerance exceeded
Account Not Found
Cause: Token account doesn’t exist
Solution: Bookie automatically creates account (adds ~0.002 SOL to cost)
Blockhash Expired
Error: Blockhash not found
Compute Budget Optimization
Simulation reveals exact compute units needed:
const simulation = await connection.simulateTransaction(transaction);
const computeUnits = simulation.value.unitsConsumed;
// Add 20% buffer for safety
const computeLimit = Math.ceil(computeUnits * 1.2);
transaction.add(
ComputeBudgetProgram.setComputeUnitLimit({
units: computeLimit
})
);
- Prevents out-of-compute errors
- Optimizes transaction fees
- Improves success rate
Balance Change Preview
Simulation shows expected balance changes:
Before Simulation:
Simulated Swap: 1 SOL → USDC
After Simulation:
- SOL: 9.499995 (1 SOL + 0.000005 fee)
- USDC: 250.43 (received from swap)
Actual execution may differ slightly from simulation due to price movements between simulation and execution.
Simulation Limitations
Simulation cannot predict:
- Price Changes: Market moves between simulation and execution
- Network Congestion: Transaction may fail due to congestion
- MEV Attacks: Sandwich attacks happen after simulation
- Concurrent Transactions: Other transactions affecting same accounts
Simulation success does not guarantee execution success. Always monitor transactions after submission.
| Metric | Value |
|---|
| Simulation Time (p50) | 12ms |
| Simulation Time (p99) | 28ms |
| Success Rate | 99.7% |
| False Positives | 0.3% |
Advanced Features
Preflight Commitment
Bookie uses confirmed commitment for simulation:
const simulation = await connection.simulateTransaction(
transaction,
{ commitment: 'confirmed' }
);
processed: Fastest, least reliableconfirmed: Balanced (default)finalized: Slowest, most reliable
Signature Verification
Disabled during simulation for speed:
const simulation = await connection.simulateTransaction(
transaction,
{ sigVerify: false }
);
Debugging Failed Simulations
If simulation fails, Bookie provides detailed logs:
Program log: Instruction: Swap
Program log: Input: 5000000000 lamports
Program log: Error: Slippage tolerance exceeded
Program log: Expected minimum: 750000000
Program log: Actual output: 745000000
Solana RPC Methods
Learn more about simulateTransaction RPC method
