pina 0.8.0

a solana and pinocchio smart contract framework
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

use pina::ProgramError;
use pina::create_program_address;
use pina::try_find_program_address;

const SYSTEM_ID: pina::Address = pina::address!("11111111111111111111111111111111");

#[test]
fn try_find_program_address_returns_some_for_valid_seeds() {
	let result = try_find_program_address(&[b"test-seed"], &SYSTEM_ID);
	assert!(result.is_some(), "expected to derive a PDA");
}

#[test]
fn try_find_program_address_deterministic() {
	let (addr1, bump1) =
		try_find_program_address(&[b"hello"], &SYSTEM_ID).unwrap_or_else(|| panic!("no PDA"));
	let (addr2, bump2) =
		try_find_program_address(&[b"hello"], &SYSTEM_ID).unwrap_or_else(|| panic!("no PDA"));

	assert_eq!(addr1, addr2, "PDA derivation should be deterministic");
	assert_eq!(bump1, bump2, "bump should be deterministic");
}

#[test]
fn try_find_program_address_different_seeds_produce_different_addresses() {
	let (addr1, _) =
		try_find_program_address(&[b"seed-a"], &SYSTEM_ID).unwrap_or_else(|| panic!("no PDA"));
	let (addr2, _) =
		try_find_program_address(&[b"seed-b"], &SYSTEM_ID).unwrap_or_else(|| panic!("no PDA"));

	assert_ne!(
		addr1, addr2,
		"different seeds should produce different PDAs"
	);
}

#[test]
fn create_program_address_roundtrip() {
	let (pda, bump) =
		try_find_program_address(&[b"roundtrip"], &SYSTEM_ID).unwrap_or_else(|| panic!("no PDA"));

	let bump_seed = [bump];
	let recreated = create_program_address(&[b"roundtrip", &bump_seed], &SYSTEM_ID)
		.unwrap_or_else(|e| panic!("failed to recreate PDA: {e:?}"));

	assert_eq!(pda, recreated, "roundtrip PDA should match");
}

#[test]
fn create_program_address_wrong_bump_fails() {
	let (_pda, bump) =
		try_find_program_address(&[b"bump-test"], &SYSTEM_ID).unwrap_or_else(|| panic!("no PDA"));

	// Use a different bump — this should either fail or produce a different address.
	let wrong_bump = bump.wrapping_add(1);
	let wrong_bump_seed = [wrong_bump];
	let result = create_program_address(&[b"bump-test", &wrong_bump_seed], &SYSTEM_ID);

	match result {
		Ok(addr) => {
			let correct = try_find_program_address(&[b"bump-test"], &SYSTEM_ID)
				.unwrap_or_else(|| panic!("no PDA"));
			assert_ne!(
				addr, correct.0,
				"wrong bump should produce a different address"
			);
		}
		Err(err) => {
			assert_eq!(err, ProgramError::InvalidSeeds);
		}
	}
}

#[test]
fn try_find_program_address_empty_seeds() {
	let result = try_find_program_address(&[], &SYSTEM_ID);
	assert!(result.is_some(), "empty seeds should still derive a PDA");
}

#[test]
fn try_find_program_address_multiple_seeds() {
	let result = try_find_program_address(&[b"prefix", b"middle", b"suffix"], &SYSTEM_ID);
	assert!(result.is_some(), "multi-seed PDA should derive");
}