clockwork_plugin 1.4.2

Clockwork plugin for Solana validators
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use std::sync::Arc;

use clockwork_client::{
    network::state::{Pool, Registry, Snapshot, SnapshotFrame, Worker},
    Client as ClockworkClient,
};
use log::info;
use solana_sdk::transaction::Transaction;

use crate::pool_position::PoolPosition;

pub fn build_pool_rotation_tx<'a>(
    client: Arc<ClockworkClient>,
    pool_position: PoolPosition,
    registry: Registry,
    snapshot: Snapshot,
    snapshot_frame: SnapshotFrame,
    worker_id: u64,
) -> Option<Transaction> {
    info!("nonce: {:?} total_stake: {:?} current_position: {:?} stake_offset: {:?} stake_amount: {:?}",
        registry.nonce.checked_rem(snapshot.total_stake),
        snapshot.total_stake,
        pool_position.current_position,
        snapshot_frame.stake_offset,
        snapshot_frame.stake_amount,
    );

    // Exit early if the rotator is not intialized
    if registry.nonce == 0 {
        return None;
    }

    // Exit early the snapshot has no stake
    if snapshot.total_stake == 0 {
        return None;
    }

    // Exit early if the worker is already in the pool.
    if pool_position.current_position.is_some() {
        return None;
    }

    // Exit early if the snapshot frame is none or the worker has no delegated stake.
    if snapshot_frame.stake_amount.eq(&0) {
        return None;
    }

    // Check if the rotation window is open for this worker.
    let is_rotation_window_open = match registry.nonce.checked_rem(snapshot.total_stake) {
        None => false,
        Some(sample) => {
            sample >= snapshot_frame.stake_offset
                && sample
                    < snapshot_frame
                        .stake_offset
                        .checked_add(snapshot_frame.stake_amount)
                        .unwrap()
        }
    };
    if !is_rotation_window_open {
        return None;
    }

    // Build rotation instruction to rotate the worker into pool 0.
    let snapshot_pubkey = Snapshot::pubkey(snapshot.id);
    let ix = clockwork_client::network::instruction::pool_rotate(
        Pool::pubkey(0),
        client.payer_pubkey(),
        snapshot_pubkey,
        SnapshotFrame::pubkey(snapshot_pubkey, worker_id),
        Worker::pubkey(worker_id),
    );

    // Build and sign tx.
    let mut tx = Transaction::new_with_payer(&[ix.clone()], Some(&client.payer_pubkey()));
    tx.sign(&[client.payer()], client.get_latest_blockhash().unwrap());

    return Some(tx);
}