Paladin - P3 Runbook

Get started with the Paladin Priority Port (P3), an express lane for extra-high priority Solana transactions.

1. Get whitelisted to the Paladin Github organization.

Access to the Paladin repo is invite-only while Paladin is in beta. You 'll need to be whitelisted to be able to clone the repo below.

Please reach out to @edgarpavlovsky on Telegram for access to the Paladin Github with the following information:

  • Github handles for relevant team members

  • Validator identity public key

2. Download the latest `paladin-solana` release

NOTE: You used to need two repos to run paladin. You now only need one: `paladin-solana`.

To run P3, all you need is paladin-solana , which is a jito-solana validator client with a minimal patch on top.

You run it with your usual validator setup like you 'd run jito-solana — no additional flags are necessary.

`paladin-solana` in-depth

paladin-solana is a slightly modified jito-solana client with a code patch to support adding incoming P3 transactions in the the bundle stage.

paladin-solana is kept up to date with jito-solana as new versions are released. Generally speaking, the recommended version of paladin to run is up to date with the latest recommended jito-solana and agave versions.

The latest version of paladin-solana is v2.0.19-paladin , and up to date with jito-solana v2.0.19.

Example commands:

                                        
                                            
                                                
                                                    $
                                                    
                                                    curl
                                                    
                                                    -L
                                                    
                                                    -o
                                                    
                                                    paladin-solana-v2.0.19.zip
                                                    
                                                    https://github.com/paladin-bladesmith/paladin-solana/archive/refs/tags/v2.0.19-paladin.zip

3. Spin up your node with paladin-solana

Most validators have their own way of running Solana validator clients. If you run jito-solana , you can swap paladin-solana into your standard DevOps process.

Note: paladin-solana does not require any special flags when starting up relative to jito-solana . You should be able to apply the same flags you do in your typical setup.

4. Whitelist the 4818 port

While Paladin is in beta, the P3 port is IP-whitelisted. In production, Paladin 's P3 port is expected to be token-gated by the $PAL token.

For P3 to work properly on your machine, you 'll need to whitelist a set of trusted IPs that are sending healthy, high priority transactions p3 port.

You only need to whitelist for incoming UDP traffic.

Please reach out to @edgarpavlovsky on telegram for the current list of IPs to whiltelist.

Example commands:

To whiltelist on Ubuntu/Debian machines, ufw is a popular choice: 

                                        
                                            
                                                
                                                    # Enable UFW if not already enabled
                                                
                                            
                                            
                                                
                                                    $
                                                    
                                                    sudo
                                                    
                                                    ufw
                                                    
                                                    enable
                                                
                                            
                                            
                                                
                                            
                                            
                                                
                                                    # Allow specific IP address to access port 4818
                                                
                                            
                                            
                                                
                                                    $
                                                    
                                                    sudo
                                                    
                                                    ufw
                                                    
                                                    allow
                                                    
                                                    proto
                                                    
                                                    udp
                                                    
                                                    from
                                                    
                                                    WHITELISTED_ADDRESS
                                                    
                                                    to
                                                    
                                                    any
                                                    
                                                    port
                                                    
                                                    4818
                                                
                                            
                                            
                                                
                                            
                                            
                                                
                                                    # Verify the rules
                                                
                                            
                                            
                                                
                                                    $
                                                    
                                                    sudo
                                                    
                                                    ufw
                                                    
                                                    status

NOTE: You will not see anything listening to Port 4818 until your validator catches up with the chain, at which point you should see 4818 listening for UDP packets.

5. Share your validator IP, P3 port, and identity public key

Once everything is set up, please reach out to @edgarpavlovsky with:

  • The IP where your paladin-solana client is running

  • The validator identity public key where paladin-solana is running

7. How can I check if I 'm receiving P3 transactions?

Paladin P3 logs come in through solana_metrics::metrics logs under the following configuration:

  • datapoint: bundle_stage-stats

  • id=2000i

If you 're seeing logs with num_sanitized_ok >0 , you 're receiving P3 transactions.

NOTE: Your node will only receive P3 transactions when its the leader, so you should only expect to see these logs when you 're the leader.

Example commands:

If you 're running the paladin-solana validator with a systemd process, you can parse through: 

                                        
                                            
                                                
                                                    $
                                                    
                                                    sudo
                                                    
                                                    journalctl
                                                    
                                                    -u
                                                    
                                                    PALADIN_SOLANA_SERVICE_NAME
                                                    
                                                    |
                                                    
                                                    grep
                                                    
                                                    -E
                                                    
                                                    "num_sanitized_ok.*id=2000|id=2000.*num_sanitized_ok "

Note: If your systemd service is sending logs to a log file, journalctl will not work. You 'll need to run something like: 

                                        
                                            
                                                
                                                    $
                                                    
                                                    grep
                                                    
                                                    -E
                                                    
                                                    "num_sanitized_ok.*id=2000|id=2000.*num_sanitized_ok "
                                                    
                                                    LOG_FILE_PATH

These commands may differ based on your DevOps configuration.

8. How can I monitor my ongoing status running Paladin?

We 're working on an analytics platform that makes it easier for Palidators to monitor their operational status and how much they 're earning. In the meantime, a community member has shared a helpful Python script that can be used as an estimation workaround:

                                        
                                            
                                                
                                                    import
                                                    glob
                                                
                                            
                                            
                                                
                                                    import
                                                    re
                                                
                                            
                                            
                                                
                                                    from
                                                    datetime 
                                                    import
                                                    datetime
                                                
                                            
                                            
                                                
                                                    from
                                                    collections 
                                                    import
                                                    defaultdict
                                                
                                            
                                            
                                                
                                            
                                            
                                                
                                                    log_files 
                                                    =
                                                    glob
                                                    .
                                                    glob
                                                    (
                                                    "log/*.log*"
                                                    )
                                                
                                            
                                            
                                                
                                            
                                            
                                                
                                            
                                            
                                                
                                                    committed_lamports_by_day 
                                                    =
                                                    
                                                    defaultdict
                                                    (
                                                    int
                                                    )
                                                
                                            
                                            
                                                
                                                    correct_pattern 
                                                    =
                                                    re
                                                    .
                                                    compile
                                                    (
                                                
                                            
                                            
                                                
                                                    
                                                    r
                                                    'num_sanitized_ok
                                                    .
                                                    *
                                                    id=2000
                                                    |
                                                    id=2000
                                                    .
                                                    *
                                                    num_sanitized_ok
                                                    .
                                                    *
                                                    committed_lamports=
                                                    (\d
                                                    +
                                                    )
                                                    i '
                                                
                                            
                                            
                                                
                                                    )
                                                
                                            
                                            
                                                
                                            
                                            
                                                
                                                    for
                                                    log_file 
                                                    in
                                                    log_files
                                                    :
                                                
                                            
                                            
                                                
                                                    
                                                    with
                                                    
                                                    open
                                                    (log_file, 
                                                    "r "
                                                    )
                                                    
                                                    as
                                                    f
                                                    :
                                                
                                            
                                            
                                                
                                                    
                                                    for
                                                    line 
                                                    in
                                                    f
                                                    :
                                                
                                            
                                            
                                                
                                                    
                                                    if
                                                    correct_pattern
                                                    .
                                                    search
                                                    (line):
                                                
                                            
                                            
                                                
                                                    match 
                                                    =
                                                    re
                                                    .
                                                    search
                                                    (
                                                    r
                                                    "committed_lamports=
                                                    (\d
                                                    +
                                                    )
                                                    i "
                                                    , line)
                                                
                                            
                                            
                                                
                                                    
                                                    if
                                                    match
                                                    :
                                                
                                            
                                            
                                                
                                                    date_match 
                                                    =
                                                    re
                                                    .
                                                    search
                                                    (
                                                    r
                                                    "\[
                                                    (\d
                                                    {4}
                                                    -
                                                    \d
                                                    {2}
                                                    -
                                                    \d
                                                    {2}
                                                    )
                                                    "
                                                    , line)
                                                
                                            
                                            
                                                
                                                    
                                                    if
                                                    date_match
                                                    :
                                                
                                            
                                            
                                                
                                                    date 
                                                    =
                                                    date_match
                                                    .
                                                    group
                                                    (
                                                    1
                                                    )
                                                
                                            
                                            
                                                
                                                    lamports 
                                                    =
                                                    
                                                    int
                                                    (match.
                                                    group
                                                    (
                                                    1
                                                    ))
                                                
                                            
                                            
                                                
                                                    committed_lamports_by_day
                                                    [
                                                    date
                                                    ]
                                                    
                                                    +=
                                                    lamports
                                                
                                            
                                            
                                                
                                            
                                            
                                                
                                                    LAMPORTS_PER_SOL 
                                                    =
                                                    
                                                    1_000_000_000
                                                
                                            
                                            
                                                
                                            
                                            
                                                
                                                    for
                                                    date
                                                    ,
                                                    total_lamports 
                                                    in
                                                    committed_lamports_by_day
                                                    .
                                                    items
                                                    ():
                                                
                                            
                                            
                                                
                                                    total_sol 
                                                    =
                                                    total_lamports 
                                                    /
                                                    LAMPORTS_PER_SOL
                                                
                                            
                                            
                                                
                                                    
                                                    print
                                                    (
                                                    f
                                                    "
                                                    {
                                                    date
                                                    }
                                                    : 
                                                    {
                                                    total_sol
                                                    :.9f
                                                    }
                                                    SOL "
                                                    )

Last updated