trezoa-system-interface 3.1.1

Trezoa system-interface crate
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

# Trezoa System Interface

This crate contains instructions and constructors for interacting with the [System program](https://trezoa.xyz/docs/core/programs#core-programs).

The System program can be used to create new accounts, allocate account data, assign accounts to owning programs, transfer lamports from System Program owned accounts and pay transaction fees.

## Getting Started

From your project folder:

```bash
cargo add trezoa-system-interface --features bincode
```

This will add the `trezoa-system-interface` dependency with the `bincode` feature enabled to your `Cargo.toml` file. The `bincode` feature contains the instruction constructors to create instructions for the System program.

## Examples

Creating an account:

```rust
use trezoa_rpc_client::rpc_client::RpcClient;
use trezoa_sdk::{
    signature::{Keypair, Signer},
    transaction::Transaction,
};
use trezoa_system_interface::instruction;
use anyhow::Result;

fn create_account(
    client: &RpcClient,
    payer: &Keypair,
    new_account: &Keypair,
    owning_program: &Pubkey,
    space: u64,
) -> Result<()> {
    let rent = client.get_minimum_balance_for_rent_exemption(space.try_into()?)?;
    let instr = instruction::create_account(
        &payer.pubkey(),
        &new_account.pubkey(),
        rent,
        space,
        owning_program,
    );

    let blockhash = client.get_latest_blockhash()?;
    let tx = Transaction::new_signed_with_payer(
        &[instr],
        Some(&payer.pubkey()),
        &[payer, new_account],
        blockhash,
    );

    let _sig = client.send_and_confirm_transaction(&tx)?;

    Ok(())
}
```

Transfer lamports between accounts:

```rust
use trezoa_rpc_client::rpc_client::RpcClient;
use trezoa_pubkey::Pubkey;
use trezoa_sdk::{
    signature::{Keypair, Signer},
    transaction::Transaction,
};
use trezoa_system_interface::instruction;
use anyhow::Result;

fn transfer(
    client: &RpcClient,
    from: &Keypair,
    recipient: &Pubkey,
    lamports: u64,
) -> Result<()> {
    let instr = instruction::transfer(
        &from.pubkey(),
        recipient,
        lamports,
    );

    let blockhash = client.get_latest_blockhash()?;
    let tx = Transaction::new_signed_with_payer(
        &[instr],
        Some(&from.pubkey()),
        &[from],
        blockhash,
    );

    let _sig = client.send_and_confirm_transaction(&tx)?;

    Ok(())
}
```

More examples can be found on the crate [documentation](https://docs.rs/trezoa-system-interface/latest/trezoa-system-interface/).