Struct SignatureBytes

Source

pub struct SignatureBytes(/* private fields */);

Expand description

A 64-byte signature

Implementations§

Source §

impl SignatureBytes

Source

pub fn new(bytes: [u8; 64]) -> Self

Create a new signature from bytes

Source

pub fn from_base58(s: &str) -> Result<Self>

Create a signature from a base58 string

Source

pub fn to_base58(&self) -> String

Convert the signature to a base58 string

Examples found in repository ?

examples/decode_tx.rs (line 38)

29fn print_versioned_transaction(tx: &VersionedTransaction) {
30    match tx {
31        VersionedTransaction::Legacy {
32            signatures,
33            message,
34        } => {
35            println!("Transaction Type: Legacy");
36            println!("Number of signatures: {}", signatures.len());
37            for (i, sig) in signatures.iter().enumerate() {
38                println!("Signature {}: {}", i + 1, sig.to_base58());
39            }
40
41            println!("\nMessage header:");
42            println!(
43                "  Required signatures: {}",
44                message.header.num_required_signatures
45            );
46            println!(
47                "  Readonly signed accounts: {}",
48                message.header.num_readonly_signed_accounts
49            );
50            println!(
51                "  Readonly unsigned accounts: {}",
52                message.header.num_readonly_unsigned_accounts
53            );
54
55            println!("\nAccount keys: {}", message.account_keys.len());
56            for (i, key) in message.account_keys.iter().enumerate() {
57                println!("  Account {}: {}", i, key.to_base58());
58            }
59
60            println!(
61                "\nRecent blockhash: {}",
62                bs58::encode(&message.recent_blockhash).into_string()
63            );
64
65            println!("\nInstructions: {}", message.instructions.len());
66            for (i, instruction) in message.instructions.iter().enumerate() {
67                println!("\nInstruction {}:", i + 1);
68                println!("  Program ID Index: {}", instruction.program_id_index);
69                println!("  Account Indices: {:?}", instruction.accounts);
70                println!(
71                    "  Data (bs58): {}",
72                    bs58::encode(&instruction.data).into_string()
73                );
74                println!(
75                    "  Data (utf8): {}",
76                    String::from_utf8_lossy(&instruction.data)
77                );
78            }
79        }
80        VersionedTransaction::V0 {
81            signatures,
82            message,
83        } => {
84            println!("Transaction Type: V0");
85            println!("Number of signatures: {}", signatures.len());
86            for (i, sig) in signatures.iter().enumerate() {
87                println!("Signature {}: {}", i + 1, sig.to_base58());
88            }
89
90            println!("\nMessage header:");
91            println!(
92                "  Required signatures: {}",
93                message.header.num_required_signatures
94            );
95            println!(
96                "  Readonly signed accounts: {}",
97                message.header.num_readonly_signed_accounts
98            );
99            println!(
100                "  Readonly unsigned accounts: {}",
101                message.header.num_readonly_unsigned_accounts
102            );
103
104            println!("\nAccount keys: {}", message.account_keys.len());
105            for (i, key) in message.account_keys.iter().enumerate() {
106                println!("  Account {}: {}", i, key.to_base58());
107            }
108
109            println!(
110                "\nRecent blockhash: {}",
111                bs58::encode(&message.recent_blockhash).into_string()
112            );
113
114            println!("\nInstructions: {}", message.instructions.len());
115            for (i, instruction) in message.instructions.iter().enumerate() {
116                println!("\nInstruction {}:", i + 1);
117                println!("  Program ID Index: {}", instruction.program_id_index);
118                println!("  Account Indices: {:?}", instruction.accounts);
119                println!(
120                    "  Data (bs58): {}",
121                    bs58::encode(&instruction.data).into_string()
122                );
123                println!(
124                    "  Data (utf8): {}",
125                    String::from_utf8_lossy(&instruction.data)
126                );
127            }
128
129            if !message.address_table_lookups.is_empty() {
130                println!(
131                    "\nAddress Table Lookups: {}",
132                    message.address_table_lookups.len()
133                );
134                for (i, lookup) in message.address_table_lookups.iter().enumerate() {
135                    println!("\nLookup Table {}:", i + 1);
136                    println!("  Table Key: {}", lookup.account_key.to_base58());
137                    println!("  Writable Indexes: {:?}", lookup.writable_indexes);
138                    println!("  Readonly Indexes: {:?}", lookup.readonly_indexes);
139                }
140            }
141        }
142    }
143}

Source

pub fn as_bytes(&self) -> &[u8; 64]

Get the bytes of the signature

Examples found in repository ?

examples/basic.rs (line 69)

6fn main() -> Result<(), Box<dyn std::error::Error>> {
7    println!("🚀 Solana Primitives - Transaction Signing Example");
8    println!("═══════════════════════════════════════════════════");
9
10    // Generate a test private key from base58 string
11    // ⚠️  WARNING: This is for demonstration only!
12    // In production, use proper key generation and secure storage
13    let private_key_base58 = "3KSeAx7jkVrjJ2PXjhzVMnJfV3zsyT4ADWtpnHxks5eD";
14    let private_key = bs58::decode(private_key_base58).into_vec()?;
15
16    // Generate corresponding public key
17    let fee_payer_pubkey_bytes = get_public_key(&private_key)?;
18    let fee_payer = Pubkey::new(fee_payer_pubkey_bytes);
19
20    let recipient = Pubkey::from_base58("4fYNw3dojWmQ4dXtSGE9epjRGy9uFrCRgbvGgQBNZCQF")?;
21
22    // Use a dummy blockhash for this example (in production, get from RPC)
23    let recent_blockhash = [1u8; 32]; // Use non-zero for visual distinction
24
25    println!("\n📝 Building Transaction:");
26    println!("   - Fee payer: {}", fee_payer.to_base58());
27    println!("   - Recipient: {}", recipient.to_base58());
28
29    // Create a simple SOL transfer instruction
30    let transfer_instruction = transfer(&fee_payer, &recipient, 1_000_000); // 0.001 SOL
31
32    // Build transaction
33    let mut tx_builder = TransactionBuilder::new(fee_payer, recent_blockhash);
34    tx_builder.add_instruction(transfer_instruction);
35
36    let mut transaction = tx_builder.build()?;
37
38    println!("✅ Unsigned transaction created:");
39    println!(
40        "   - Instructions: {}",
41        transaction.message.instructions.len()
42    );
43    println!(
44        "   - Account keys: {}",
45        transaction.message.account_keys.len()
46    );
47    println!(
48        "   - Required signatures: {}",
49        transaction.message.header.num_required_signatures
50    );
51    println!("   - Is signed: {}", transaction.is_signed());
52
53    // Validate transaction size
54    transaction.validate_size()?;
55    println!("✅ Transaction size validation passed");
56
57    println!("\n🔐 Signing Transaction:");
58
59    // Method 1: Sign the entire transaction at once
60    let private_keys = [private_key.as_ref()]; // References to private keys
61    transaction.sign(&private_keys)?;
62
63    println!("✅ Transaction signed successfully!");
64    println!("   - Is signed: {}", transaction.is_signed());
65    println!("   - Signature count: {}", transaction.signatures.len());
66
67    // Display the signature (first 16 bytes for brevity)
68    if let Some(first_signature) = transaction.signatures.first() {
69        let sig_bytes = first_signature.as_bytes();
70        println!("   - First signature: {}...", hex::encode(&sig_bytes[..16]));
71    }
72
73    println!("\n📦 Final Transaction:");
74    // Serialize the complete signed transaction
75    let transaction_bytes = borsh::to_vec(&transaction)?;
76    println!("   - Serialized size: {} bytes", transaction_bytes.len());
77    println!(
78        "   - Base64 encoded: {}",
79        base64::prelude::BASE64_STANDARD.encode(&transaction_bytes)
80    );
81
82    // Demonstrate partial signing (useful for multi-sig scenarios)
83    println!("\n🔄 Demonstrating Partial Signing:");
84
85    // Create a new transaction builder for partial signing demo
86    let mut partial_tx_builder = TransactionBuilder::new(fee_payer, recent_blockhash);
87    partial_tx_builder.add_instruction(transfer(&fee_payer, &recipient, 1_000_000));
88    let mut partial_tx = partial_tx_builder.build()?;
89    println!(
90        "   - Before partial sign - Is signed: {}",
91        partial_tx.is_signed()
92    );
93
94    // Partial sign with specific keys and their corresponding public keys
95    let private_keys_for_partial = [private_key.as_ref()];
96    let public_keys_for_partial = [fee_payer];
97    partial_tx.partial_sign(&private_keys_for_partial, &public_keys_for_partial)?;
98
99    println!("✅ Partial signing completed!");
100    println!(
101        "   - After partial sign - Is signed: {}",
102        partial_tx.is_signed()
103    );
104
105    println!("\n🎯 Summary:");
106    println!("   ✓ Transaction built using InstructionBuilder");
107    println!("   ✓ Transaction validated for size limits");
108    println!("   ✓ Transaction signed with private key");
109    println!("   ✓ Partial signing demonstrated");
110    println!("   ✓ Transaction serialized for network submission");
111
112    println!("\n📡 Next Steps:");
113    println!("   - Submit transaction_bytes to Solana RPC endpoint");
114    println!("   - Monitor transaction status on-chain");
115    println!("   - Handle success/failure responses");
116
117    Ok(())
118}