📝Bot configurations

This is an example config.toml file.

[routing]
[[routing.mint_config_list]]
mint = "34HDZNbUkTyTrgYKy2ox43yp2f8PJ5hoM7xsrfNApump"
pump_pool_list = [
  "7USDHmdsFsJGsrvuYWvYHKejJBneCLVk8hdMWVvb7VqA",
]

# This is the Raydium V4 AMM Pools
raydium_pool_list = []

# This is the Raydium CPMM Pools
raydium_cp_pool_list = []

# This is the Raydium CLMM(Centralized Liquidity) Pools
raydium_clmm_pool_list = []

whirlpool_pool_list = []

# Meteora DLMM
meteora_dlmm_pool_list = [
  "7h93PJheNPgaVAztMqeFszzkaP1pEdsZyE4n6H9KRVE9",
  "3aRvsnLDyDevu9BvpiauGGQpwszXXqW6zLgxjMG57g2N",
  "CX2SFVBn6kAWm7utL3ccW3F6B9q9sHLmPTikPfPG9oSS",
]
# Meteora Dynamic Pool
meteora_damm_pool_list = []
# Meteora Dynamic Pool V2
meteora_dammv2_pool_list = []

# Vertigo Pool
vertigo_pool_list = []

# Heaven Dex Pool
heaven_pool_list = []

humidifi_list = []
pancakeswap_pool_list = []
byreal_pool_list = []
futarchy_pool_list = []

lookup_table_accounts = [
  "AnrSWuNc4L4oj54W7g95YEaXfTS58FsSknZdynDqpUJd",
  "q52amtQzHcXs2PA3c4Xqv1LRRZCbFMzd4CGHu1tHdp1"
]
process_delay = 400

# bundle_group = 1 # Optional, only available for jito

[rpc]
url = "xxx"

[spam]
enabled = true
enabled_bundle_groups = [1, 2, 3, 4, 5]
sending_rpc_urls = [
  "RPC_URL_1",
  "RPC_URL_2"
]
compute_unit_price = { strategy = "Random", from = 100, to = 100, count = 1 }
max_retries = 10 # Optional
enable_simple_send = false # You should only set this to true if your sending rpc doesn't work with the default config.

[jito]
enabled = true
enabled_bundle_groups = [1, 2, 3, 4, 5]
block_engine_urls = [
  "https://ny.mainnet.block-engine.jito.wtf/api/v1",
  "https://tokyo.mainnet.block-engine.jito.wtf/api/v1",
  "https://slc.mainnet.block-engine.jito.wtf/api/v1",
  "https://amsterdam.mainnet.block-engine.jito.wtf/api/v1",
  "https://frankfurt.mainnet.block-engine.jito.wtf/api/v1",
  "https://singapore.mainnet.block-engine.jito.wtf/api/v1",
  "https://london.mainnet.block-engine.jito.wtf/api/v1",
]
uuid = "" # Optional
ip_addresses = [] # Optional. You should only set this when you have multiple IPs. Support single IP or CIDR format like "192.168.1.0/24"
use_min_profit = true # Optional.
min_profit = 10_000 # Optional.
use_separate_tip_account = false # Optional
no_failure_mode = false # Optional. DO NOT ENABLE THIS IF YOU DON'T KNOW WHAT THIS IS.
block_engine_strategy = "OneByOne" # "OneByOne" or "AllAtOnce"

[[sending_venders.sending_vender]]
enabled = false
tip_amount = { strategy = "Random", from = 1_000_000, to = 1_000_000, count = 1 }
compute_unit_price = { strategy = "Random", from = 1031, to = 2055, count = 1 }
urls = [
    "https://fast.circular.fi/transactions",
]
auth_header = "x-api-key"
auth_value = "xxx"
tip_accounts = [
  "FAST3dMFZvESiEipBvLSiXq3QCV51o3xuoHScqRU6cB6",
  "FASTHPW6akdGh9PFSdhMTbCuGkCSX7LsUjjnaB2RTQ4v",
  "FASTYKWXRfAoty7SQCM1mGVrmPUyyNcF4tc3DUkLDAu9",
  "FASTPB76TxKPMZ7Q29m8v4zJn8gUjbWyvTEQaaxhwN7M",
  "FASTs6ctgbsuZegMzUs4DPUYhRSZUPCjgCVnttHbpQAp",
  "FASTYmSidNfLwdwiQEhCTtzghxEtaipeNSDSwh9xDPs3",
  "FASTCKnwwY6iL3CknRgg3Zqir7jeagDDhxSnBQQy5a1C",
  "FASTKL1AamNKrwnvbKwo4PU8434BBdqVrTtugM6oDU71"
]
no_failure_mode = false
sending_strategy = "AllAtOnce"  # AllAtOnce or OneByOne


[jito.tip_config]
strategy = "Random" # Random/Linear/Exponential/File
from = 10000
to = 100000
count = 3 # This configs how many different tips to generate. All the tx will be send out together.

[flashloan]
enabled = true

[bot]
compute_unit_limit = 600_000 # Recommand at least 300_000 if you have dlmm, at least 450_000 if you have orca/raydium clmm.
merge_mints = false # Send all the mints in the same tx
skip_ata_creation = false # either try to create ata on bot start
# memo = "some note" # Optional

[wallet]
private_key = "xxx"

Routing

In routing, you define which mint(X), a raydium pool that is SOL/X, a meteora dlmm pool that is SOL/X. The bot's onchain program will check if there's a profitable route between the two onchain, and find the optimal trade size, and execute the trades if there's any.

Currently the bot only support one raydium pool and one meteora dlmm pool for each list, you can define multiple different ones for the same mint/raydium pool and different meteora dlmm pool. A later version will alow using multiple meteora dlmm pool together.

markets

The easiest way is to just put in the market address, bot will automatically derive the mint and create proper tx for it.

[routing.markets]
markets = [
  "FYDmYvJ3gynXGGFnAbTwN8CRR3LrrNdhztbkuybvYtj2", 
  "ToLi6ihgfv4HLPE8GujTxKAexRxopDyk31NVpNgyxuY"
]
lookup_table_accounts = []
process_delay = 400

mint_config_list

You can define multiple mint and pools. The bot will send out a tx, wait for process_delay ms, then send again and repeat for every mint you define.

You can also define more than 1 meteora dlmm pool. If you use more than 2 you likely need to add an address lookup table for it as well, otherwise the tx will be too big.

[[routing.mint_config_list]]
mint = "34HDZNbUkTyTrgYKy2ox43yp2f8PJ5hoM7xsrfNApump"
pump_pool_list = [
  "7USDHmdsFsJGsrvuYWvYHKejJBneCLVk8hdMWVvb7VqA",
]
meteora_dlmm_pool_list = [
  "7h93PJheNPgaVAztMqeFszzkaP1pEdsZyE4n6H9KRVE9",
  "3aRvsnLDyDevu9BvpiauGGQpwszXXqW6zLgxjMG57g2N",
  "CX2SFVBn6kAWm7utL3ccW3F6B9q9sHLmPTikPfPG9oSS",
]
meteora_damm_pool_list = []
meteora_dammv2_pool_list = []
raydium_pool_list = []
raydium_cp_pool_list = []
raydium_clmm_pool_list = []
whirlpool_pool_list = []
vertigo_pool_list = []
heaven_pool_list = []
humidifi_list = []
pancakeswap_pool_list = []
byreal_pool_list = []
futarchy_pool_list = []
lookup_table_accounts = [
  "AnrSWuNc4L4oj54W7g95YEaXfTS58FsSknZdynDqpUJd",
  "q52amtQzHcXs2PA3c4Xqv1LRRZCbFMzd4CGHu1tHdp1"
]
process_delay = 400

Define multiple mints

You can define multiple mints by simply copy the [[routing.mint_config_list]] config.

Example:

[[routing.mint_config_list]]
mint = "34HDZNbUkTyTrgYKy2ox43yp2f8PJ5hoM7xsrfNApump"
pump_pool_list = [
  "7USDHmdsFsJGsrvuYWvYHKejJBneCLVk8hdMWVvb7VqA",
]
meteora_dlmm_pool_list = [
  "7h93PJheNPgaVAztMqeFszzkaP1pEdsZyE4n6H9KRVE9",
]
lookup_table_accounts = []
process_delay = 400

[[routing.mint_config_list]]
mint = "7swLujtSwxcNxybT167ii9HXCfy5LZFxNwUEvsZgpump"
pump_pool_list = [
  "9iPVQkxUFiL4AQStRqPTcjN2KhZdbqZM7Lmk9vYzgnAT",
]
raydium_cp_pool_list = [
  "HXCjThojPP1f9uXdQYe7YdbKugT2PvVoTUyvapkErgBY",
]
lookup_table_accounts = []
process_delay = 400

bundle_group

bundle_group is a feature you can use to decide which mints and it pools goes into which transaction when you enable merge_mint. By default, when you use merge_mint, all mints with all their pools will be put into one transaction. With bundle_group, you can define which mints go together.

When sending through rpc, all transactions will send out on its own and use the same fee as you defined in your config.

When sending through jito, all transactions generated will be send together in one jito bundle, with only 1 tip in the last transaction. This is can save you some tip when you are running a lot of mints together.

bundle_group can only be used when merge_mint = true , and with jito only when no_failure_mode = true.

You can set a bundle_group number for every routing.mint_config_list. mint_config_list with the same bundle_group number will be put into the same transaction.

You can only set 1,2,3,4,5 for bundle_group value. When use_separate_tip_account is set to true, you can only set 1,2,3,4 for bundle_group value.

The following example will send a bundle with 2 transactions, first transaction with mint 34HDZNbUkTyTrgYKy2ox43yp2f8PJ5hoM7xsrfNApump and 7swLujtSwxcNxybT167ii9HXCfy5LZFxNwUEvsZgpump, second transaction with mint 9Poxe5aDkt8ggFWvcYZ9AX8QBBAAdgW844cgooNCULT.

[[routing.mint_config_list]]
mint = "34HDZNbUkTyTrgYKy2ox43yp2f8PJ5hoM7xsrfNApump"
pump_pool_list = [
  "7USDHmdsFsJGsrvuYWvYHKejJBneCLVk8hdMWVvb7VqA",
]
meteora_dlmm_pool_list = [
  "7h93PJheNPgaVAztMqeFszzkaP1pEdsZyE4n6H9KRVE9",
]
lookup_table_accounts = []
process_delay = 400
bundle_group = 1

[[routing.mint_config_list]]
mint = "7swLujtSwxcNxybT167ii9HXCfy5LZFxNwUEvsZgpump"
pump_pool_list = [
  "9iPVQkxUFiL4AQStRqPTcjN2KhZdbqZM7Lmk9vYzgnAT",
]
raydium_cp_pool_list = [
  "HXCjThojPP1f9uXdQYe7YdbKugT2PvVoTUyvapkErgBY",
]
lookup_table_accounts = []
process_delay = 400
bundle_group = 1

[[routing.mint_config_list]]
mint = '9Poxe5aDkt8ggFWvcYZ9AX8QBBAAdgW844cgooNCULT'
meteora_dlmm_pool_list = [
  'nWrt7PWy7y3mcEPi6jWiLnCmb3kwxKPrJjkM7fQqfAY',
  '5xodDMtiRdaZ2GHR93XWYH7Tb3bDgvdZoD9sukhZFoW2',
]
meteora_dammv2_pool_list = ['4MSn6EafnvgBkh22KbUp8Wqd9ALMUjGRxZgbFi3xV1qD']
lookup_table_accounts = [
  '4sKLJ1Qoudh8PJyqBeuKocYdsZvxTcRShUt9aKqwhgvC',
  '8ULJeesxN3jSyPwJbqtPf18jQgKZjfnwH4tNNQWqJhCs',
  '4vM4gXE99wc7PXXumGGCXeqj9hB1KakxgyRcrwR2y6pJ',
]
process_delay = 400
bundle_group = 2

RPC

You just need to put your rpc's url here. This is NOT the rpc you use to send transactions.

[rpc]
url = xxx

Spam

You can set the rpcs you use to send transactions. This can be the same as your reading rpc.

[spam]
enabled = true
enabled_bundle_groups = [1, 2, 3, 4, 5] # Optional
sending_rpc_urls = [
  "RPC_URL_1",
  "RPC_URL_2"
]
compute_unit_price = { strategy = "Random", from = 100, to = 100, count = 1 }
max_retries = 10 # Optional
no_failure_mode = true # Optional
enable_simple_send = false # You should only set this to true if your sending rpc doesn't work with the default config.

enabled_bundle_groups

This is which group you want to send using spam. When not set all groups will be enabled if spam is enabled.

compute_unit_price

You need to config compute unit price when enable spam.

You can set from equals to to value and use any strategy to get a fixed tip amount for all your tx.

Note: the transaction generated from this will be send out together.

You can define it in two format. Define it under [spam] directly

[spam]
compute_unit_price = { strategy = "Random", from = 10000, to = 100000, count = 1 }

or define it in its own section

[spam.compute_unit_price]
strategy = "Random" # Random/Linear/Exponential/ExponentialRandom/File
from = 10000
to = 100000
count = 3 # This configs how many different compute unit price to generate. All the tx will be send out together.

Or you can load from a file using file strategy

[spam.compute_unit_price]
strategy = "File" # Random/Linear/Exponential/ExponentialRandom/File
file_path = "cu.txt"

Your file should have one number on each line, example with 2 compute_unit_price:

10000
20000

Jito

You can also enable sending through jito. Though the success rate of using jito is much lower due to the tip auction and how jito works, but the up side about it is you won't have any failed transactions.

Note: If you use multiple ip with jito, make sure you don't have ip rotation setup locally, instead you should use the bot's build in support for it. You can just set all the ips you want to use within the config, you can use either single ip or CIDR format like "192.168.1.0/24"

[jito]
enabled = true
enabled_bundle_groups = [1, 2, 3, 4, 5] # Optional
block_engine_urls = [
  "https://ny.mainnet.block-engine.jito.wtf/api/v1",
  "https://tokyo.mainnet.block-engine.jito.wtf/api/v1",
  "https://slc.mainnet.block-engine.jito.wtf/api/v1",
  "https://amsterdam.mainnet.block-engine.jito.wtf/api/v1",
  "https://frankfurt.mainnet.block-engine.jito.wtf/api/v1",
]
tip_config = { strategy = "Random", from = 10000, to = 100000, count = 1 }
uuid = "" # Optional
use_min_profit = true # Optional, defalt to true.
no_failure_mode = false # Optional
use_separate_tip_account = false # Optional
ip_addresses = [] # Optional. You should only set this when you have multiple IPs. Support single IP or CIDR format like "192.168.1.0/24"
block_engine_strategy = "OneByOne" # "OneByOne" or "AllAtOnce"

enabled_bundle_groups

This is which group you want to send using jito. When not set all groups will be enabled if jito is enabled.

enable_single_transaction_bundle

When using bundle groups for jito, the bot's default behavior is to bundle all groups tx into one bundle, and only pay one tip in the last transaction.

enable_single_transaction_bundle will change this behavior to send every tx as it's own bundle, and pay its own tip.

use_min_profit

Default to true.

YOU MAY LOSE MONEY WHEN YOU SET THIS TO FALSE.

When this is set to true, the onchain program will use the tip amount as min profit so you never lose money. Though this will make it very hard to land.

When this is set to false, the onchain program will NOT use the tip amount as min profit, so it will land as long as there's profit(without considering your tip amount). Make sure you understand what this does before setting this to false. The recommended way to use this is to use a very small tip amount + a lot of ips, basically using jito as a way to land your transactions and consider the tip as gas fee.

min_profit

Default: 0

This is the number you want to set in addition to your tip amount. For example if you don't want to lose money with jito, you should set this to 10000 if you use separate tip accounts and 5000 if not to cover the basic transaction fee.

use_separate_tip_account

Default: false

You need to set this to true if you are using ip to get around the jito rate limit.

no_failure_mode

Default: false

YOU MAY LOSE MONEY WHEN YOU SET THIS TO TRUE.

When this is enabled, transaction without profit will NOT fail. This means all your tx sending to jito will succeed, pass all simulations, and landed on chain. So you will pay ALL the transaction's tip even if there's no profit.

On the other hand, this does help to land tx through jito, especially land successful ones as you by pass all simulations. You are basically using it as a spam rpc in some sense, and all the jito tip you pay is the gas fee.

tip_config

You need to config tip when enable jito.

You can set from equals to to value and use any strategy to get a fixed tip amount for all your tx.

Note: the tx generated from this will be send out together. So make sure you have enough rate limit to handle it.

You can define it in two format. Define it under [jito] directly

[jito]
tip_config = { strategy = "Random", from = 10000, to = 100000, count = 1 }

or define it in its own section

[jito.tip_config]
strategy = "Random" # Random/Linear/Exponential/ExponentialRandom/File
from = 10000
to = 100000
count = 3 # This configs how many different tips to generate. All the tx will be send out together.

Or you can load from a file using file strategy

[jito.tip_config]
strategy = "File" # Random/Linear/Exponential/ExponentialRandom/File
file_path = "tip.txt"

Your file should have one number on each line, example with 2 tips:

10000
20000

block_engine_strategy

Default: "OneByOne"

OneByOne: The bot will send out tx through all the different urls one by one. This way you can have an effective 6/s rate limit with jito as this bot requires sending out a lot of tx.

AllAtOnce: The bot will send out the same tx to all regions together. This will give a higher chance for the tx get through if a few of the regions are rate limited.

sending_venders

Besides sending through RPC and Jito, the bot also support using custom sending venders like Fast/Temporal/0slot/bloxroute etc. The config is almost the same as jito.

You can define multiple sending venders to send together.

For example on how to config for a given vender, check Sending Vender examples

[[sending_venders.sending_vender]]
enabled = true
# enabled_bundle_groups = [1, 2, 3, 4, 5] # Optional
# use_min_profit = true # Optional
# min_profit = 0 # Optional

tip_amount = { strategy = "Random", from = 1_000_000, to = 1_000_000, count = 1 }
compute_unit_price = { strategy = "Random", from = 1031, to = 2055, count = 1 }
urls = [
    "https://fast.circular.fi/transactions",
]
tip_accounts = [
  "FAST3dMFZvESiEipBvLSiXq3QCV51o3xuoHScqRU6cB6",
  "FASTHPW6akdGh9PFSdhMTbCuGkCSX7LsUjjnaB2RTQ4v",
  "FASTYKWXRfAoty7SQCM1mGVrmPUyyNcF4tc3DUkLDAu9",
  "FASTPB76TxKPMZ7Q29m8v4zJn8gUjbWyvTEQaaxhwN7M",
  "FASTs6ctgbsuZegMzUs4DPUYhRSZUPCjgCVnttHbpQAp",
  "FASTYmSidNfLwdwiQEhCTtzghxEtaipeNSDSwh9xDPs3",
  "FASTCKnwwY6iL3CknRgg3Zqir7jeagDDhxSnBQQy5a1C",
  "FASTKL1AamNKrwnvbKwo4PU8434BBdqVrTtugM6oDU71"
]
no_failure_mode = false
sending_strategy = "AllAtOnce"  # AllAtOnce or OneByOne
# auth_header = "x-api-key" # Only add this when needed
# auth_value = "xxx".       # Only add this when needed
# request-params = { skipPreflight = true } # Only add this when needed
# enable_submit_batch = true # Only needed for flashblock

request-params

This is a customize field to fulfill some vender's special requirement. It's a json field so you can put in any valid values in it. Like for Helius they require you to have skipPreflight = true in the request params body and you can set it as in the example above.

flashloan

When enabled, you don't need a lot of WSOL/USDC in your wallet.(You need some to keep your wsol account open).

Currently the flashloan pool has 30 SOL and 5000 USDC.

[flashloan]
enabled = true

Bot

compute_unit_limit is a required param. If you have meteora dlmm in your pool you should set it to be at least 300_000. If you have more than two dlmm pool you should consider adding more compute unit limit here.

When you have dlmm pool, the compute_unit_limit you set will affect how many bins the bot will look at when doing calculation onchain. Roughly each bin lookup will take ~ 5000 compute unit. 300_000 will allow the bot to look at ~10-30 bins onchain depends on what pool is on the other side.

compute_unit_price_for_ata_creation the compute unit price you pay for creating ata transaction. Default is 1_000_000 if not set.

compute_unit_limit = 300_000
merge_mint = false
auto_merge = false
compute_unit_price_for_ata_creation = 1_000_000 # Optional. Default 1_000_000
skip_ata_creation = true
# usdc_sol_pool = "51FQwjrvo8J8zXUaKyAznJ5NYpoiTCuqAqCu3HAMB9NZ" # Use bisonfi's pool for sol/usdc
# memo = "some note" # Optional

merge_mint

The merge_mint config allows you to find opportunities for different mints and pools within one transaction. This sounds good but has it's own limitation.

The tx is usually harder to land as you add more mints and pools. This is likely due to the transaction is locking too many accounts and the validator is impossible to find a slot to fit it in. You may also need to use higher fees when the market is hot.

You also need higher compute unit limit as the bot's program need to look at more pools onchain with this.

Note: Bot current support merge up to 3 mints, and 7 pools in total. If you try really hard and have the proper lookup table you can go up to 4 mints and 8 pools.

auto_merge

Default: false

This only take effect when merge_mint = true.

When this is enabled, bot will automatically merge all the mints/pool into one tx, with best effort.

NOTE: If for one mint it has too many pools that couldn't fit into one tx, some pools will be discarded until it can fit into one tx.

skip_ata_creation

Default: false

When set, the bot will skip the ata creation on bot start. Instead it will create the ata on first successful arb for the token. This will require some additional CU for the first successful tx for the token, in exchange for faster bot start speed.

trade_size

When set, the bot will always use this trade size instead of calculaing dynamically. this can be helpful if you want to avoid heavy calculation onchain and just spam. Note this doesn't work with no failure mode.

usdc_sol_pool

When set to 51FQwjrvo8J8zXUaKyAznJ5NYpoiTCuqAqCu3HAMB9NZ, it will use the bisonfi's sol/usdc pool as the bridge pool for 3hop swap. which has better price and lower cu cost. But prop amm may shut down randomly during high volatile times.

When not set, bot will use the default raydium sol/usdc pool.

memo

Will add an additional memo instruction to all your tx. This is useful if you run multiple bots/strategies on the same wallet and trying to understand which one performs better.

Wallet

private key can be in any format.

[wallet]
private_key = "xxx"
# If set, the bot loads directly from this path instead of searching for ENCRYPTED_PRIVATE_KEY
# encrypted_key_path = "~/keys/ENCRYPTED_PRIVATE_KEY

Nonce

To understand what is nonce read here: https://solana.com/developers/guides/advanced/introduction-to-durable-nonces

Enable nonce will make sure only ONE tx will land for each loop, for all the tx sent through rpc/jito/sending venders for one round, only the one that land fastest will land onchain, all other tx will never land.

The down side of using this is slightly increased tx size, so in some cases you may need to remove a pool when using this.

You can create nonce accounts using the cli. here's example of creating 50 nonce accounts:

./smb-onchain create-nonce-accounts config.toml 50 nonce.json

Note you cannot share nonce accounts between different wallet. each wallet has to use its own nonce accounts.

It's recommended to use at least 20 nonce accounts per tx with a 500ms delay. You can adjust accordingly.

[nonce]
# Durable nonce support; when enabled, all swap variants for a mint share one nonce.
enabled = true
# JSON file with [{"pubkey":"..."}] entries produced by create-nonce-accounts.
nonces_file = "nonce.json"
# Required when enabled = true
grpc_url = "xxx"
grpc_x_token = "xxx"

Log

You can now hide the sending spam logs and just see a summary of it.

[log]
enable_sending_log_summary = true
summary_interval_seconds = 10

Auto rebalance

You can now config auto rebalance for the bot. The auto rebalance check will run every 1 minute. If your sol balance drop below the min_sol_balance config, it will send out a tx to unwrap all your wsol, and wrap only min_wsol_balance amount back to wsol.

[auto_rebalance]
min_sol_balance = 1_000_000_000 # 1 SOL
min_wsol_balance = 1            # 0.000000001 SOL
compute_unit_price = 100_000    # How much fee you pay for the rebalance tx