spi-program 0.0.1-beta.1

Solana program for Solana Progam Interface (SPI) middleware
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

#[cfg(feature = "anchor")]
use anchor_lang::prelude::{AnchorDeserialize, AnchorSerialize};
#[cfg(not(feature = "anchor"))]
use borsh::{BorshDeserialize, BorshSerialize};

/// Bir account için meta bilgi
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct MetaEntry {
    /// Hesabın public key'i
    pub pubkey: solana_program::pubkey::Pubkey,
    /// Hesap imzalayıcı mı
    pub is_signer: bool,
    /// Hesap yazılabilir mi
    pub is_writable: bool,
}

/// Dinamik olarak başka bir programa instruction göndermek için yapı
pub struct DynamicInstruction {
    /// Hedef program id
    pub target_program_id: solana_program::pubkey::Pubkey,
    /// Instruction datası
    pub data: Vec<u8>,
    /// Hedef programa iletilecek hesaplar
    pub account_metas: Vec<MetaEntry>,
}

impl DynamicInstruction {
    pub fn instruction(&self) -> solana_program::instruction::Instruction {
        self.instruction_with_remaining_accounts(&[])
    }

    pub fn instruction_with_remaining_accounts(
        &self,
        remaining_accounts: &[solana_program::instruction::AccountMeta],
    ) -> solana_program::instruction::Instruction {
        let mut accounts = Vec::with_capacity(self.account_metas.len() + remaining_accounts.len());

        for meta in &self.account_metas {
            accounts.push(solana_program::instruction::AccountMeta {
                pubkey: meta.pubkey,
                is_signer: meta.is_signer,
                is_writable: meta.is_writable,
            });
        }

        accounts.extend_from_slice(remaining_accounts);

        solana_program::instruction::Instruction {
            program_id: self.target_program_id,
            accounts,
            data: self.data.clone(),
        }
    }
}

#[cfg_attr(not(feature = "anchor"), derive(BorshSerialize, BorshDeserialize))]
#[cfg_attr(feature = "anchor", derive(AnchorSerialize, AnchorDeserialize))]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct MiddlewareArgs {
    /// Hedef programa gönderilecek instruction datası
    pub instruction_data: Vec<u8>,
}

#[derive(Default)]
pub struct MiddlewareBuilder {
    target_program_id: Option<solana_program::pubkey::Pubkey>,
    data: Option<Vec<u8>>,
    account_metas: Vec<MetaEntry>,
    __remaining_accounts: Vec<solana_program::instruction::AccountMeta>,
}

impl MiddlewareBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    /// Hedef program id'sini ayarla
    pub fn target_program_id(mut self, target_program_id: solana_program::pubkey::Pubkey) -> Self {
        self.target_program_id = Some(target_program_id);
        self
    }

    /// Instruction datasını ayarla
    pub fn data(mut self, data: Vec<u8>) -> Self {
        self.data = Some(data);
        self
    }

    /// Account ekle
    pub fn add_account_meta(
        mut self,
        pubkey: solana_program::pubkey::Pubkey,
        is_signer: bool,
        is_writable: bool,
    ) -> Self {
        self.account_metas.push(MetaEntry {
            pubkey,
            is_signer,
            is_writable,
        });
        self
    }

    /// Ekstra account ekle (opsiyonel)
    pub fn add_remaining_account(
        &mut self,
        account: solana_program::instruction::AccountMeta,
    ) -> &mut Self {
        self.__remaining_accounts.push(account);
        self
    }

    /// Birden fazla ekstra account ekle (opsiyonel)
    pub fn add_remaining_accounts(
        &mut self,
        accounts: &[solana_program::instruction::AccountMeta],
    ) -> &mut Self {
        self.__remaining_accounts.extend_from_slice(accounts);
        self
    }

    /// Instruction oluştur
    pub fn instruction(&self) -> solana_program::instruction::Instruction {
        let dynamic = DynamicInstruction {
            target_program_id: self
                .target_program_id
                .expect("target_program_id is required"),
            data: self.data.clone().expect("data is required"),
            account_metas: self.account_metas.clone(),
        };

        dynamic.instruction_with_remaining_accounts(&self.__remaining_accounts)
    }
}
// Usage example:
// let ix = MiddlewareBuilder::new()
//     .target_program_id(target_program_id)
//     .data(instruction_data)
//     .add_account_meta(account_pubkey, true, true)
//     .add_account_meta(another_pubkey, false, false)
//     .instruction();