BAMBAM Builder

Triggered when a transaction is being scheduled. Allows custom ordering logic. (BAM Client Only)

Check if the transaction is signed by this validator's identity key (Dynamic).

Check if the transaction is signed by a specific Admin Pubkey.

Check if this validator is currently producing the block (Leader).

Check if the transaction interacts with the validator's vote account.

Log the current Slot, Epoch, and Validator Identity.

Closes the most recent condition block.

Check if a specific account has a balance within a range (in Lamports).

Check if a specific account is owned by a specific program.

Check if account data contains a specific pattern (Hex string) at a specific offset.

Check if the Fee Payer holds a specific SPL Token or Legacy NFT.

Check if the transaction includes a proof verification against a specific Merkle Tree (cNFT Collection).

Check if the Fee Payer owns a specific asset using Helius DAS API. WARNING: Adds network latency!

Send a POST request to an external webhook with transaction details.

Check an external API (GET) to see if the Fee Payer is allowed.

Change the priority of the transaction by buffering and re-sorting.

Delay the execution of the transaction by blocking the thread.

Buffer the transaction for later execution (requires flush).

Flush buffered transactions sorted by priority fee.

Application Controlled Execution: Only allow transactions with a specific byte sequence in instruction data.

Execute logic if the transaction writes to a specific 'Hot' account (e.g. liquidity pool).

Assign priority based on time elapsed in the slot (Time-based Auction). Earlier = Higher Cost/Lower Priority or vice versa.

Check if the transaction payer is in the fast lane list (comma-separated).

Check if the transaction interacts with a specific Program ID.

Execute logic only on every Nth slot (e.g., every 100 blocks).

Check if the transaction compute budget is below a threshold.

Artificially boost the priority of the transaction.

Buffer low cost transactions to be scheduled during gaps.

Flush buffered low cost transactions.

Check if the transaction interacts with a specific Program ID.

Immediately drop the transaction and stop processing.

Verify transaction signature inside TEE enclave (Requires external TEE lib).

Adjust transaction priority dynamically based on a multiplier.

Throttle transactions targeting hot accounts.

Limit transactions from a sender (requires state).

Only allow transactions from whitelisted senders.

Count total transactions processed.

Decrypt a confidential transaction inside the TEE.

Detect potential sandwich attacks by analyzing swap patterns.

Identify and handle Jito-style atomic bundles via Tip Program.

Adjust priority fees based on network congestion (Transaction Count).

Check the current epoch from the Bank.

Check if the transaction interacts with a specific program (ACE).

Adjust priority based on sender's stake weight (ACE).

Strict First-Come-First-Served ordering.

Heuristic check for sandwich attacks (High Fee + DeFi Interaction).

Route transaction to a private execution lane (MEV Protection).

Reject transaction if fee is below dynamic threshold.

Order transactions based on an auction bid in instruction data.

Check if the transaction is signed by a VIP key.

Check if the transaction interacts with a specific Oracle program.

Artificially boost the priority score of a transaction.

Check if the transaction touches a hot account.

Triggered for every transaction processed by the validator.

Triggered when an account is updated.

Triggered when a slot status changes.

Triggered when block metadata is available.

Triggered when an entry is executed.

Triggered when block metadata (V4) is available, including rewards and entry counts.

Check if block height is greater than X.

Check if block has more than X executed transactions.

Check if block contains any reward > X lamports.

Check if transaction is Versioned (V0).

Check if the transaction is a vote.

Check if the slot status is Confirmed.

Check if the update is happening during startup.

Only process transactions involving a specific program.

Filter accounts by data size.

Check if the account is owned by a specific program.

Check if transaction used more than X compute units.

Check if the transaction failed.

Check if a specific account is involved in the transaction.

Check if instruction data starts with specific bytes (hex).

Log a message to the validator logs.

Emit a custom metric to InfluxDB/Prometheus.

Stream event to a gRPC endpoint.

Post a message to a Slack webhook (Blocking).

Publish event to a Kafka topic.

Send a POST request to a webhook URL (Blocking).

Publish event to a Redis channel.

Check if account balance is greater than X lamports.

Check if the account is executable.

Append a line to a local file.

Send a generic HTTP POST request (Blocking).

Send events to this BAM Forge instance for debugging.

Check for transfers > 1000 SOL.

Log potential sandwich attacks.

Log a suggestion to bump fee.

Prioritize transactions with high priority fees.

Block transactions from a specific sender.

Buffer transactions in a priority queue (BinaryHeap).

Decrypt transaction in TEE and verify signature.

Check if the slot is fresh (less than X ms old).

Check if we are in Block Production or Verification mode.

Check if the transaction writes to a specific account (Hot Account detection).

Randomly shuffle the transaction buffer before flushing.

Bump priority if transaction writes to a known Oracle.

Check if the transaction interacts with a specific program (e.g. Jupiter, Raydium).

Boost priority if a transfer to a specific tip account is detected.

Check if the signer is a valid session key (for gaming/casinos).

Drop transaction if a similar one was seen recently.

Check if transaction requests less than X compute units.

Check if the fee payer is a known validator (Vote Account).

Check if transaction avoids a list of 'Hot Accounts'.

Check if transaction has many instructions (Flash Loan detection).

Assign a priority bucket based on the compute unit price.

Check if the transaction conflicts with currently scheduled tasks.

Delay execution until a specific condition is met (simulated).

Add to a mutable score variable for the transaction.

Check if the transaction interacts with a specific Program ID (Application Controlled Execution).

Detect and prevent sandwich attacks by checking for suspicious surrounding transactions.

Hold the transaction for a micro-auction (BAM specific).

Adjust priority based on Compute Unit Price.

Only allow transactions from a specific list of signers.

Inject arbitrary Rust code (Advanced Users Only).

Check if a specific account has specific data (requires deserialization logic).

Auction off the top spot in the block to the highest bidder.

Check specific account state to authorize execution (ACE).

Analyze a window of transactions for MEV patterns (Sandwiching).

Multiply required fee based on block congestion.

Schedule transactions based on sender's validator stake.

Check if transaction targets accounts modified by recent high-value transactions.

Randomly shuffle the execution order within a small window.

Order transactions based on a decaying price curve.

Track fees for later redistribution to specific accounts.

Prioritize transactions that use less compute units (efficient code).

Silently drop the transaction. It will not be scheduled for execution.

Log a message for testing/simulation purposes without affecting execution.