kora-lib 2.0.5

Core library for Kora gasless relayer
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

use solana_message::VersionedMessage;

use crate::error::KoraError;
use base64::{engine::general_purpose::STANDARD, Engine as _};

pub trait VersionedMessageExt {
    fn encode_b64_message(&self) -> Result<String, KoraError>;
}

impl VersionedMessageExt for VersionedMessage {
    fn encode_b64_message(&self) -> Result<String, KoraError> {
        let serialized = self.serialize();
        Ok(STANDARD.encode(serialized))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use solana_message::{compiled_instruction::CompiledInstruction, v0, Message};
    use solana_sdk::{
        hash::Hash,
        instruction::{AccountMeta, Instruction},
        pubkey::Pubkey,
        signature::Keypair,
        signer::Signer as _,
    };

    #[test]
    fn test_encode_b64_message_legacy() {
        let keypair = Keypair::new();
        let program_id = Pubkey::new_unique();
        let instruction = Instruction::new_with_bytes(
            program_id,
            &[1, 2, 3, 4, 5],
            vec![AccountMeta::new(keypair.pubkey(), true)],
        );

        let message =
            VersionedMessage::Legacy(Message::new(&[instruction], Some(&keypair.pubkey())));

        let encoded = message.encode_b64_message().unwrap();

        // Verify we can decode the base64 back to bytes
        let decoded_bytes = STANDARD.decode(&encoded).unwrap();
        assert!(!decoded_bytes.is_empty());

        // Verify it matches the original serialized message
        let original_bytes = message.serialize();
        assert_eq!(decoded_bytes, original_bytes);
    }

    #[test]
    fn test_encode_b64_message_v0() {
        let keypair = Keypair::new();
        let program_id = Pubkey::new_unique();
        let recipient = Pubkey::new_unique();

        let v0_message = v0::Message {
            header: solana_message::MessageHeader {
                num_required_signatures: 1,
                num_readonly_signed_accounts: 0,
                num_readonly_unsigned_accounts: 2,
            },
            account_keys: vec![keypair.pubkey(), recipient, program_id],
            recent_blockhash: Hash::new_unique(),
            instructions: vec![CompiledInstruction {
                program_id_index: 2,
                accounts: vec![0, 1],
                data: vec![1, 2, 3],
            }],
            address_table_lookups: vec![],
        };

        let message = VersionedMessage::V0(v0_message);

        let encoded = message.encode_b64_message().unwrap();

        // Verify we can decode the base64 back to bytes
        let decoded_bytes = STANDARD.decode(&encoded).unwrap();
        assert!(!decoded_bytes.is_empty());

        // Verify it matches the original serialized message
        let original_bytes = message.serialize();
        assert_eq!(decoded_bytes, original_bytes);
    }

    #[test]
    fn test_encode_b64_message_v0_with_lookup_tables() {
        let keypair = Keypair::new();
        let program_id = Pubkey::new_unique();
        let lookup_table_account = Pubkey::new_unique();

        let v0_message = v0::Message {
            header: solana_message::MessageHeader {
                num_required_signatures: 1,
                num_readonly_signed_accounts: 0,
                num_readonly_unsigned_accounts: 1,
            },
            account_keys: vec![keypair.pubkey(), program_id],
            recent_blockhash: Hash::new_unique(),
            instructions: vec![CompiledInstruction {
                program_id_index: 1,
                accounts: vec![0, 2], // Account at index 2 will come from lookup table
                data: vec![42, 0, 1, 2],
            }],
            address_table_lookups: vec![solana_message::v0::MessageAddressTableLookup {
                account_key: lookup_table_account,
                writable_indexes: vec![0],
                readonly_indexes: vec![],
            }],
        };

        let message = VersionedMessage::V0(v0_message);

        let encoded = message.encode_b64_message().unwrap();

        // Verify we can decode the base64 back to bytes
        let decoded_bytes = STANDARD.decode(&encoded).unwrap();
        assert!(!decoded_bytes.is_empty());

        // Verify it matches the original serialized message
        let original_bytes = message.serialize();
        assert_eq!(decoded_bytes, original_bytes);

        // Verify lookup table data is preserved in original message
        match message {
            VersionedMessage::V0(v0_msg) => {
                assert_eq!(v0_msg.address_table_lookups.len(), 1);
                assert_eq!(v0_msg.address_table_lookups[0].account_key, lookup_table_account);
                assert_eq!(v0_msg.address_table_lookups[0].writable_indexes, vec![0]);
                assert_eq!(v0_msg.address_table_lookups[0].readonly_indexes.len(), 0);
            }
            _ => panic!("Expected V0 message"),
        }
    }
}