raydium-sdk-V2 0.0.5

Raydium SDK V2 adaptation
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

pub mod tx_type;

use crate::common::owner::Owner;
use crate::common::tx_tool::tx_type::InstructionType;
use crate::raydium::tpe::MakeInstructionsResult;
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_sdk::address_lookup_table::AddressLookupTableAccount;
use solana_sdk::clock::Slot;
use solana_sdk::hash::Hash;
use solana_sdk::instruction::Instruction;
use solana_sdk::message::{v0, VersionedMessage};
use solana_sdk::pubkey::Pubkey;
use solana_sdk::transaction::VersionedTransaction;
use std::str::FromStr;

pub struct TxBuilder<'a> {
    owner: &'a Owner,
    fee_payer: Pubkey,
    instructions: Vec<Instruction>,
    // end_instructions: ,
    // signers: Vec<>,
    instruction_types: Vec<InstructionType>,
    // end_instruction_types: ,
    lookup_table_address: Vec<String>,
}
impl<'a> TxBuilder<'a> {
    pub fn new(owner: &'a Owner, fee_payer: Pubkey) -> Self {
        Self {
            owner,
            fee_payer,
            instructions: vec![],
            instruction_types: vec![],
            lookup_table_address: vec![],
        }
    }
    pub fn add_instruction(&mut self, mut instruction: MakeInstructionsResult) {
        //@TODO endInstructions, signers, endInstructionTypes
        self.instructions.append(&mut instruction.instructions);
        self.instruction_types
            .append(&mut instruction.instruction_types);
        let def_pub = Pubkey::default().to_string();
        self.lookup_table_address.extend(
            &mut instruction
                .lookup_table_address
                .into_iter()
                .filter(|x| x != &def_pub),
        );
    }
    pub fn build_v0(self, recent_blockhash: Hash) -> VersionedTransaction {
        // @TODO
        let lookup_table: Vec<AddressLookupTableAccount> = vec![];
        VersionedTransaction::try_new(
            VersionedMessage::V0(
                v0::Message::try_compile(
                    &self.fee_payer,
                    &self.instructions,
                    &lookup_table,
                    recent_blockhash,
                )
                .unwrap(),
            ),
            &[self.owner.keypair().unwrap()],
        )
        .unwrap()
    }
}