antegen-thread-program 5.0.8

Solana program for Antegen - automation and scheduling threads
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use solana_sdk::{pubkey::Pubkey, signature::{Keypair, Signer}, transaction::Transaction};

mod common;
use common::*;

fn create_funded_thread(
    svm: &mut litesvm::LiteSVM,
    authority: &Keypair,
    payer: &Keypair,
    id: &str,
    amount: u64,
) -> Pubkey {
    let thread_id = ThreadId::Bytes(id.as_bytes().to_vec());
    let (thread_pubkey, _) = thread_pda(&authority.pubkey(), id.as_bytes());
    let ix = build_create_thread(
        &authority.pubkey(),
        &payer.pubkey(),
        &thread_pubkey,
        amount,
        thread_id,
        Trigger::Immediate { jitter: 0 },
        None,
        None,
        None,
    );
    let blockhash = svm.latest_blockhash();
    let tx = Transaction::new_signed_with_payer(
        &[ix],
        Some(&payer.pubkey()),
        &[payer, authority],
        blockhash,
    );
    svm.send_transaction(tx).unwrap();
    thread_pubkey
}

fn send_withdraw(
    svm: &mut litesvm::LiteSVM,
    authority: &Keypair,
    pay_to: &Pubkey,
    thread: &Pubkey,
    amount: u64,
) -> Result<(), litesvm::types::FailedTransactionMetadata> {
    let ix = build_withdraw_thread(&authority.pubkey(), pay_to, thread, amount);
    let blockhash = svm.latest_blockhash();
    let tx = Transaction::new_signed_with_payer(
        &[ix],
        Some(&authority.pubkey()),
        &[authority],
        blockhash,
    );
    svm.send_transaction(tx).map(|_| ())
}

#[test]
fn test_thread_withdraw_success() {
    let (mut svm, _admin, payer) = create_test_env();
    let authority = Keypair::new();
    svm.airdrop(&authority.pubkey(), DEFAULT_AIRDROP).unwrap();

    let thread_pubkey =
        create_funded_thread(&mut svm, &authority, &payer, "tw-1", 5_000_000);

    let thread_before = get_balance(&svm, &thread_pubkey);
    let authority_before = get_balance(&svm, &authority.pubkey());

    send_withdraw(&mut svm, &authority, &authority.pubkey(), &thread_pubkey, 1_000_000).unwrap();

    let thread_after = get_balance(&svm, &thread_pubkey);
    let authority_after = get_balance(&svm, &authority.pubkey());

    assert_eq!(thread_before - thread_after, 1_000_000);
    // Authority gains ~1M lamports (minus tx fee)
    assert!(authority_after > authority_before);
}

#[test]
fn test_thread_withdraw_authority_only() {
    let (mut svm, _admin, payer) = create_test_env();
    let authority = Keypair::new();
    let bad_authority = Keypair::new();
    svm.airdrop(&authority.pubkey(), DEFAULT_AIRDROP).unwrap();
    svm.airdrop(&bad_authority.pubkey(), DEFAULT_AIRDROP).unwrap();

    let thread_pubkey =
        create_funded_thread(&mut svm, &authority, &payer, "tw-auth", 5_000_000);

    let result = send_withdraw(&mut svm, &bad_authority, &bad_authority.pubkey(), &thread_pubkey, 1_000_000);
    assert!(result.is_err());
}

#[test]
fn test_thread_withdraw_too_large() {
    let (mut svm, _admin, payer) = create_test_env();
    let authority = Keypair::new();
    svm.airdrop(&authority.pubkey(), DEFAULT_AIRDROP).unwrap();

    let thread_pubkey =
        create_funded_thread(&mut svm, &authority, &payer, "tw-large", 1_000_000);

    let thread_balance = get_balance(&svm, &thread_pubkey);
    // Try to withdraw everything (would go below rent)
    let result = send_withdraw(
        &mut svm,
        &authority,
        &authority.pubkey(),
        &thread_pubkey,
        thread_balance,
    );
    assert!(result.is_err());
}

#[test]
fn test_thread_withdraw_exact_to_rent() {
    let (mut svm, _admin, payer) = create_test_env();
    let authority = Keypair::new();
    svm.airdrop(&authority.pubkey(), DEFAULT_AIRDROP).unwrap();

    let thread_pubkey =
        create_funded_thread(&mut svm, &authority, &payer, "tw-rent", 5_000_000);

    // Withdraw a small amount that leaves well above rent
    send_withdraw(&mut svm, &authority, &authority.pubkey(), &thread_pubkey, 100_000).unwrap();
}

#[test]
fn test_thread_withdraw_to_different_account() {
    let (mut svm, _admin, payer) = create_test_env();
    let authority = Keypair::new();
    let recipient = Keypair::new();
    svm.airdrop(&authority.pubkey(), DEFAULT_AIRDROP).unwrap();
    svm.airdrop(&recipient.pubkey(), 1_000_000).unwrap();

    let thread_pubkey =
        create_funded_thread(&mut svm, &authority, &payer, "tw-diff", 5_000_000);

    let recipient_before = get_balance(&svm, &recipient.pubkey());
    send_withdraw(&mut svm, &authority, &recipient.pubkey(), &thread_pubkey, 1_000_000).unwrap();
    let recipient_after = get_balance(&svm, &recipient.pubkey());

    assert_eq!(recipient_after - recipient_before, 1_000_000);
}

#[test]
fn test_thread_withdraw_zero_amount() {
    let (mut svm, _admin, payer) = create_test_env();
    let authority = Keypair::new();
    svm.airdrop(&authority.pubkey(), DEFAULT_AIRDROP).unwrap();

    let thread_pubkey =
        create_funded_thread(&mut svm, &authority, &payer, "tw-zero", 5_000_000);

    send_withdraw(&mut svm, &authority, &authority.pubkey(), &thread_pubkey, 0).unwrap();
}