pub mod spl_token {
pub const IX_INITIALIZE_ACCOUNT2: u8 = 16;
pub const IX_INITIALIZE_ACCOUNT3: u8 = 18;
pub const IX_TRANSFER: u8 = 3;
pub const IX_APPROVE: u8 = 4;
pub const IX_REVOKE: u8 = 5;
pub const IX_SET_AUTHORITY: u8 = 6;
pub const IX_MINT_TO: u8 = 7;
pub const IX_BURN: u8 = 8;
pub const IX_CLOSE_ACCOUNT: u8 = 9;
pub const IX_FREEZE_ACCOUNT: u8 = 10;
pub const IX_THAW_ACCOUNT: u8 = 11;
pub const IX_TRANSFER_CHECKED: u8 = 12;
pub const IX_APPROVE_CHECKED: u8 = 13;
pub const IX_MINT_TO_CHECKED: u8 = 14;
pub const IX_BURN_CHECKED: u8 = 15;
pub const IX_SYNC_NATIVE: u8 = 17;
#[inline(always)]
fn amount_ix(disc: u8, amount: u64) -> [u8; 9] {
let mut data = [0u8; 9];
data[0] = disc;
data[1..9].copy_from_slice(&amount.to_le_bytes());
data
}
#[inline(always)]
fn amount_checked_ix(disc: u8, amount: u64, decimals: u8) -> [u8; 10] {
let mut data = [0u8; 10];
data[0] = disc;
data[1..9].copy_from_slice(&amount.to_le_bytes());
data[9] = decimals;
data
}
#[inline(always)]
pub fn encode_transfer(amount: u64) -> [u8; 9] {
amount_ix(IX_TRANSFER, amount)
}
#[inline(always)]
pub fn encode_approve(amount: u64) -> [u8; 9] {
amount_ix(IX_APPROVE, amount)
}
#[inline(always)]
pub fn encode_mint_to(amount: u64) -> [u8; 9] {
amount_ix(IX_MINT_TO, amount)
}
#[inline(always)]
pub fn encode_burn(amount: u64) -> [u8; 9] {
amount_ix(IX_BURN, amount)
}
#[inline(always)]
pub fn encode_transfer_checked(amount: u64, decimals: u8) -> [u8; 10] {
amount_checked_ix(IX_TRANSFER_CHECKED, amount, decimals)
}
#[inline(always)]
pub fn encode_approve_checked(amount: u64, decimals: u8) -> [u8; 10] {
amount_checked_ix(IX_APPROVE_CHECKED, amount, decimals)
}
#[inline(always)]
pub fn encode_mint_to_checked(amount: u64, decimals: u8) -> [u8; 10] {
amount_checked_ix(IX_MINT_TO_CHECKED, amount, decimals)
}
#[inline(always)]
pub fn encode_burn_checked(amount: u64, decimals: u8) -> [u8; 10] {
amount_checked_ix(IX_BURN_CHECKED, amount, decimals)
}
#[inline(always)]
pub fn encode_revoke() -> [u8; 1] {
[IX_REVOKE]
}
#[inline(always)]
pub fn encode_close_account() -> [u8; 1] {
[IX_CLOSE_ACCOUNT]
}
#[inline(always)]
pub fn encode_freeze_account() -> [u8; 1] {
[IX_FREEZE_ACCOUNT]
}
#[inline(always)]
pub fn encode_thaw_account() -> [u8; 1] {
[IX_THAW_ACCOUNT]
}
#[inline(always)]
pub fn encode_sync_native() -> [u8; 1] {
[IX_SYNC_NATIVE]
}
#[inline(always)]
pub fn encode_initialize_account2(owner: &[u8; 32]) -> [u8; 33] {
let mut data = [0u8; 33];
data[0] = IX_INITIALIZE_ACCOUNT2;
data[1..33].copy_from_slice(owner);
data
}
#[inline(always)]
pub fn encode_initialize_account3(owner: &[u8; 32]) -> [u8; 33] {
let mut data = [0u8; 33];
data[0] = IX_INITIALIZE_ACCOUNT3;
data[1..33].copy_from_slice(owner);
data
}
#[inline(always)]
pub fn encode_set_authority(
authority_type: u8,
new_authority: Option<&[u8; 32]>,
) -> ([u8; 35], usize) {
let mut data = [0u8; 35];
data[0] = IX_SET_AUTHORITY;
data[1] = authority_type;
match new_authority {
Some(key) => {
data[2] = 1;
data[3..35].copy_from_slice(key);
(data, 35)
}
None => {
data[2] = 0;
(data, 3)
}
}
}
}
pub mod system {
pub const IX_CREATE_ACCOUNT: u32 = 0;
pub const IX_ASSIGN: u32 = 1;
pub const IX_TRANSFER: u32 = 2;
pub const IX_ALLOCATE: u32 = 8;
pub const IX_CREATE_ACCOUNT_ALLOW_PREFUND: u32 = 13;
#[inline(always)]
pub fn encode_create_account(lamports: u64, space: u64, owner: &[u8; 32]) -> [u8; 52] {
let mut data = [0u8; 52];
data[0..4].copy_from_slice(&IX_CREATE_ACCOUNT.to_le_bytes());
data[4..12].copy_from_slice(&lamports.to_le_bytes());
data[12..20].copy_from_slice(&space.to_le_bytes());
data[20..52].copy_from_slice(owner);
data
}
#[inline(always)]
pub fn encode_create_account_allow_prefund(
lamports: u64,
space: u64,
owner: &[u8; 32],
) -> [u8; 52] {
let mut data = [0u8; 52];
data[0..4].copy_from_slice(&IX_CREATE_ACCOUNT_ALLOW_PREFUND.to_le_bytes());
data[4..12].copy_from_slice(&lamports.to_le_bytes());
data[12..20].copy_from_slice(&space.to_le_bytes());
data[20..52].copy_from_slice(owner);
data
}
#[inline(always)]
pub fn encode_transfer(lamports: u64) -> [u8; 12] {
let mut data = [0u8; 12];
data[0..4].copy_from_slice(&IX_TRANSFER.to_le_bytes());
data[4..12].copy_from_slice(&lamports.to_le_bytes());
data
}
#[inline(always)]
pub fn encode_assign(owner: &[u8; 32]) -> [u8; 36] {
let mut data = [0u8; 36];
data[0..4].copy_from_slice(&IX_ASSIGN.to_le_bytes());
data[4..36].copy_from_slice(owner);
data
}
#[inline(always)]
pub fn encode_allocate(space: u64) -> [u8; 12] {
let mut data = [0u8; 12];
data[0..4].copy_from_slice(&IX_ALLOCATE.to_le_bytes());
data[4..12].copy_from_slice(&space.to_le_bytes());
data
}
pub const IX_ADVANCE_NONCE: u32 = 4;
pub const IX_WITHDRAW_NONCE: u32 = 5;
pub const IX_INITIALIZE_NONCE: u32 = 6;
pub const IX_AUTHORIZE_NONCE: u32 = 7;
pub const IX_UPGRADE_NONCE: u32 = 12;
#[inline(always)]
pub fn encode_advance_nonce_account() -> [u8; 4] {
IX_ADVANCE_NONCE.to_le_bytes()
}
#[inline(always)]
pub fn encode_withdraw_nonce_account(lamports: u64) -> [u8; 12] {
let mut data = [0u8; 12];
data[0..4].copy_from_slice(&IX_WITHDRAW_NONCE.to_le_bytes());
data[4..12].copy_from_slice(&lamports.to_le_bytes());
data
}
#[inline(always)]
pub fn encode_initialize_nonce_account(authority: &[u8; 32]) -> [u8; 36] {
let mut data = [0u8; 36];
data[0..4].copy_from_slice(&IX_INITIALIZE_NONCE.to_le_bytes());
data[4..36].copy_from_slice(authority);
data
}
#[inline(always)]
pub fn encode_authorize_nonce_account(new_authority: &[u8; 32]) -> [u8; 36] {
let mut data = [0u8; 36];
data[0..4].copy_from_slice(&IX_AUTHORIZE_NONCE.to_le_bytes());
data[4..36].copy_from_slice(new_authority);
data
}
#[inline(always)]
pub fn encode_upgrade_nonce_account() -> [u8; 4] {
IX_UPGRADE_NONCE.to_le_bytes()
}
}
#[cfg(test)]
extern crate std;
#[cfg(test)]
mod tests {
use hopper_runtime::system::encoders as rt_system;
use hopper_runtime::token::encoders as rt_token;
const AMOUNT: u64 = 0x0102_0304_0506_0708;
const AMOUNT_LE: [u8; 8] = [0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01];
const OWNER: [u8; 32] = [
0, 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,
];
#[test]
fn spl_amount_instructions_golden() {
for (bytes, disc) in [
(rt_token::encode_transfer(AMOUNT), 3u8),
(rt_token::encode_approve(AMOUNT), 4),
(rt_token::encode_mint_to(AMOUNT), 7),
(rt_token::encode_burn(AMOUNT), 8),
] {
assert_eq!(bytes[0], disc);
assert_eq!(&bytes[1..9], &AMOUNT_LE);
}
}
#[test]
fn spl_checked_instructions_golden() {
for (bytes, disc) in [
(rt_token::encode_transfer_checked(AMOUNT, 9), 12u8),
(rt_token::encode_approve_checked(AMOUNT, 9), 13),
(rt_token::encode_mint_to_checked(AMOUNT, 9), 14),
(rt_token::encode_burn_checked(AMOUNT, 9), 15),
] {
assert_eq!(bytes[0], disc);
assert_eq!(&bytes[1..9], &AMOUNT_LE);
assert_eq!(bytes[9], 9);
}
}
#[test]
fn spl_single_byte_instructions_golden() {
assert_eq!(rt_token::encode_revoke(), [5]);
assert_eq!(rt_token::encode_close_account(), [9]);
assert_eq!(rt_token::encode_freeze_account(), [10]);
assert_eq!(rt_token::encode_thaw_account(), [11]);
assert_eq!(rt_token::encode_sync_native(), [17]);
assert_eq!(rt_token::encode_initialize_account(), [1]);
}
#[test]
fn spl_initialize_account_golden() {
let a2 = rt_token::encode_initialize_account_with_owner(16, &OWNER);
assert_eq!(a2[0], 16);
assert_eq!(&a2[1..33], &OWNER);
let a3 = rt_token::encode_initialize_account_with_owner(18, &OWNER);
assert_eq!(a3[0], 18);
assert_eq!(&a3[1..33], &OWNER);
}
#[test]
fn spl_set_authority_golden() {
let (some, some_len) = rt_token::encode_set_authority(2, Some(&OWNER));
assert_eq!(some_len, 35);
assert_eq!(some[0], 6);
assert_eq!(some[1], 2);
assert_eq!(some[2], 1);
assert_eq!(&some[3..35], &OWNER);
let (none, none_len) = rt_token::encode_set_authority(3, None);
assert_eq!(none_len, 3);
assert_eq!(none[0], 6);
assert_eq!(none[1], 3);
assert_eq!(none[2], 0);
}
#[test]
fn system_create_account_golden() {
let d = rt_system::encode_create_account(AMOUNT, 165, &OWNER);
assert_eq!(&d[0..4], &[0, 0, 0, 0]);
assert_eq!(&d[4..12], &AMOUNT_LE);
assert_eq!(&d[12..20], &165u64.to_le_bytes());
assert_eq!(&d[20..52], &OWNER);
}
#[test]
fn system_create_account_allow_prefund_golden() {
let d = rt_system::encode_create_account_allow_prefund(AMOUNT, 165, &OWNER);
assert_eq!(&d[0..4], &[13, 0, 0, 0]);
assert_eq!(&d[4..12], &AMOUNT_LE);
assert_eq!(&d[12..20], &165u64.to_le_bytes());
assert_eq!(&d[20..52], &OWNER);
let plain = rt_system::encode_create_account(AMOUNT, 165, &OWNER);
assert_eq!(&d[4..], &plain[4..]);
}
#[test]
fn system_transfer_golden() {
let d = rt_system::encode_transfer(AMOUNT);
assert_eq!(&d[0..4], &[2, 0, 0, 0]);
assert_eq!(&d[4..12], &AMOUNT_LE);
}
#[test]
fn system_assign_golden() {
let d = rt_system::encode_assign(&OWNER);
assert_eq!(&d[0..4], &[1, 0, 0, 0]);
assert_eq!(&d[4..36], &OWNER);
}
#[test]
fn system_allocate_golden() {
let d = rt_system::encode_allocate(AMOUNT);
assert_eq!(&d[0..4], &[8, 0, 0, 0]);
assert_eq!(&d[4..12], &AMOUNT_LE);
}
#[test]
fn system_nonce_family_golden() {
assert_eq!(rt_system::encode_advance_nonce_account(), [4, 0, 0, 0]);
let w = rt_system::encode_withdraw_nonce_account(AMOUNT);
assert_eq!(&w[0..4], &[5, 0, 0, 0]);
assert_eq!(&w[4..12], &AMOUNT_LE);
let init = rt_system::encode_initialize_nonce_account(&OWNER);
assert_eq!(&init[0..4], &[6, 0, 0, 0]);
assert_eq!(&init[4..36], &OWNER);
let auth = rt_system::encode_authorize_nonce_account(&OWNER);
assert_eq!(&auth[0..4], &[7, 0, 0, 0]);
assert_eq!(&auth[4..36], &OWNER);
assert_eq!(rt_system::encode_upgrade_nonce_account(), [12, 0, 0, 0]);
}
#[test]
fn reference_oracle_agrees_with_shipped_at_golden_vectors() {
use super::{spl_token, system};
assert_eq!(
spl_token::encode_transfer(AMOUNT),
rt_token::encode_transfer(AMOUNT)
);
assert_eq!(
spl_token::encode_approve(AMOUNT),
rt_token::encode_approve(AMOUNT)
);
assert_eq!(
spl_token::encode_mint_to(AMOUNT),
rt_token::encode_mint_to(AMOUNT)
);
assert_eq!(
spl_token::encode_burn(AMOUNT),
rt_token::encode_burn(AMOUNT)
);
assert_eq!(
spl_token::encode_transfer_checked(AMOUNT, 9),
rt_token::encode_transfer_checked(AMOUNT, 9)
);
assert_eq!(
spl_token::encode_approve_checked(AMOUNT, 9),
rt_token::encode_approve_checked(AMOUNT, 9)
);
assert_eq!(
spl_token::encode_mint_to_checked(AMOUNT, 9),
rt_token::encode_mint_to_checked(AMOUNT, 9)
);
assert_eq!(
spl_token::encode_burn_checked(AMOUNT, 9),
rt_token::encode_burn_checked(AMOUNT, 9)
);
assert_eq!(spl_token::encode_revoke(), rt_token::encode_revoke());
assert_eq!(
spl_token::encode_close_account(),
rt_token::encode_close_account()
);
assert_eq!(
spl_token::encode_freeze_account(),
rt_token::encode_freeze_account()
);
assert_eq!(
spl_token::encode_thaw_account(),
rt_token::encode_thaw_account()
);
assert_eq!(
spl_token::encode_sync_native(),
rt_token::encode_sync_native()
);
assert_eq!(
spl_token::encode_initialize_account2(&OWNER),
rt_token::encode_initialize_account_with_owner(16, &OWNER)
);
assert_eq!(
spl_token::encode_initialize_account3(&OWNER),
rt_token::encode_initialize_account_with_owner(18, &OWNER)
);
assert_eq!(
spl_token::encode_set_authority(2, Some(&OWNER)),
rt_token::encode_set_authority(2, Some(&OWNER))
);
assert_eq!(
spl_token::encode_set_authority(3, None),
rt_token::encode_set_authority(3, None)
);
assert_eq!(
system::encode_create_account(AMOUNT, 165, &OWNER),
rt_system::encode_create_account(AMOUNT, 165, &OWNER)
);
assert_eq!(
system::encode_create_account_allow_prefund(AMOUNT, 165, &OWNER),
rt_system::encode_create_account_allow_prefund(AMOUNT, 165, &OWNER)
);
assert_eq!(
system::encode_transfer(AMOUNT),
rt_system::encode_transfer(AMOUNT)
);
assert_eq!(
system::encode_assign(&OWNER),
rt_system::encode_assign(&OWNER)
);
assert_eq!(
system::encode_allocate(AMOUNT),
rt_system::encode_allocate(AMOUNT)
);
assert_eq!(
system::encode_advance_nonce_account(),
rt_system::encode_advance_nonce_account()
);
assert_eq!(
system::encode_withdraw_nonce_account(AMOUNT),
rt_system::encode_withdraw_nonce_account(AMOUNT)
);
assert_eq!(
system::encode_initialize_nonce_account(&OWNER),
rt_system::encode_initialize_nonce_account(&OWNER)
);
assert_eq!(
system::encode_authorize_nonce_account(&OWNER),
rt_system::encode_authorize_nonce_account(&OWNER)
);
assert_eq!(
system::encode_upgrade_nonce_account(),
rt_system::encode_upgrade_nonce_account()
);
}
}
#[cfg(kani)]
mod kani_proofs {
use super::{spl_token, system};
use hopper_runtime::system::encoders as rt_system;
use hopper_runtime::token::encoders as rt_token;
#[inline]
fn word_at(d: &[u8], off: usize) -> u64 {
u64::from_le_bytes([
d[off],
d[off + 1],
d[off + 2],
d[off + 3],
d[off + 4],
d[off + 5],
d[off + 6],
d[off + 7],
])
}
#[inline]
fn assert_pubkey_region(d: &[u8], off: usize, owner: &[u8; 32]) {
let i: usize = kani::any();
kani::assume(i < 32);
assert_eq!(d[off + i], owner[i]);
}
#[inline]
fn assert_regions_eq(a: &[u8], b: &[u8], off: usize) {
let i: usize = kani::any();
kani::assume(i < 32);
assert_eq!(a[off + i], b[off + i]);
}
#[kani::proof]
fn spl_transfer_layout() {
let amount: u64 = kani::any();
let d = rt_token::encode_transfer(amount);
assert_eq!(d.len(), 9);
assert_eq!(d[0], 3);
assert_eq!(word_at(&d, 1), amount);
}
#[kani::proof]
fn spl_approve_layout() {
let amount: u64 = kani::any();
let d = rt_token::encode_approve(amount);
assert_eq!(d.len(), 9);
assert_eq!(d[0], 4);
assert_eq!(word_at(&d, 1), amount);
}
#[kani::proof]
fn spl_mint_to_layout() {
let amount: u64 = kani::any();
let d = rt_token::encode_mint_to(amount);
assert_eq!(d.len(), 9);
assert_eq!(d[0], 7);
assert_eq!(word_at(&d, 1), amount);
}
#[kani::proof]
fn spl_burn_layout() {
let amount: u64 = kani::any();
let d = rt_token::encode_burn(amount);
assert_eq!(d.len(), 9);
assert_eq!(d[0], 8);
assert_eq!(word_at(&d, 1), amount);
}
#[kani::proof]
fn spl_transfer_checked_layout() {
let amount: u64 = kani::any();
let decimals: u8 = kani::any();
let d = rt_token::encode_transfer_checked(amount, decimals);
assert_eq!(d.len(), 10);
assert_eq!(d[0], 12);
assert_eq!(word_at(&d, 1), amount);
assert_eq!(d[9], decimals);
}
#[kani::proof]
fn spl_approve_checked_layout() {
let amount: u64 = kani::any();
let decimals: u8 = kani::any();
let d = rt_token::encode_approve_checked(amount, decimals);
assert_eq!(d.len(), 10);
assert_eq!(d[0], 13);
assert_eq!(word_at(&d, 1), amount);
assert_eq!(d[9], decimals);
}
#[kani::proof]
fn spl_mint_to_checked_layout() {
let amount: u64 = kani::any();
let decimals: u8 = kani::any();
let d = rt_token::encode_mint_to_checked(amount, decimals);
assert_eq!(d.len(), 10);
assert_eq!(d[0], 14);
assert_eq!(word_at(&d, 1), amount);
assert_eq!(d[9], decimals);
}
#[kani::proof]
fn spl_burn_checked_layout() {
let amount: u64 = kani::any();
let decimals: u8 = kani::any();
let d = rt_token::encode_burn_checked(amount, decimals);
assert_eq!(d.len(), 10);
assert_eq!(d[0], 15);
assert_eq!(word_at(&d, 1), amount);
assert_eq!(d[9], decimals);
}
#[kani::proof]
fn spl_single_byte_discriminators() {
assert_eq!(rt_token::encode_revoke(), [5]);
assert_eq!(rt_token::encode_close_account(), [9]);
assert_eq!(rt_token::encode_freeze_account(), [10]);
assert_eq!(rt_token::encode_thaw_account(), [11]);
assert_eq!(rt_token::encode_sync_native(), [17]);
assert_eq!(rt_token::encode_initialize_account(), [1]);
}
#[kani::proof]
fn spl_initialize_account2_layout() {
let owner: [u8; 32] = kani::any();
let d = rt_token::encode_initialize_account_with_owner(16, &owner);
assert_eq!(d.len(), 33);
assert_eq!(d[0], 16);
assert_pubkey_region(&d, 1, &owner);
}
#[kani::proof]
fn spl_initialize_account3_layout() {
let owner: [u8; 32] = kani::any();
let d = rt_token::encode_initialize_account_with_owner(18, &owner);
assert_eq!(d.len(), 33);
assert_eq!(d[0], 18);
assert_pubkey_region(&d, 1, &owner);
}
#[kani::proof]
fn spl_set_authority_some_layout() {
let authority_type: u8 = kani::any();
let owner: [u8; 32] = kani::any();
let (d, len) = rt_token::encode_set_authority(authority_type, Some(&owner));
assert_eq!(len, 35);
assert_eq!(d[0], 6);
assert_eq!(d[1], authority_type);
assert_eq!(d[2], 1);
assert_pubkey_region(&d, 3, &owner);
}
#[kani::proof]
fn spl_set_authority_none_layout() {
let authority_type: u8 = kani::any();
let (d, len) = rt_token::encode_set_authority(authority_type, None);
assert_eq!(len, 3);
assert_eq!(d[0], 6);
assert_eq!(d[1], authority_type);
assert_eq!(d[2], 0);
}
#[inline]
fn assert_system_disc(d: &[u8], tag: u8) {
assert_eq!(d[0], tag);
assert_eq!(d[1], 0);
assert_eq!(d[2], 0);
assert_eq!(d[3], 0);
}
#[kani::proof]
fn system_transfer_layout() {
let lamports: u64 = kani::any();
let d = rt_system::encode_transfer(lamports);
assert_eq!(d.len(), 12);
assert_system_disc(&d, 2);
assert_eq!(word_at(&d, 4), lamports);
}
#[kani::proof]
fn system_allocate_layout() {
let space: u64 = kani::any();
let d = rt_system::encode_allocate(space);
assert_eq!(d.len(), 12);
assert_system_disc(&d, 8);
assert_eq!(word_at(&d, 4), space);
}
#[kani::proof]
fn system_assign_layout() {
let owner: [u8; 32] = kani::any();
let d = rt_system::encode_assign(&owner);
assert_eq!(d.len(), 36);
assert_system_disc(&d, 1);
assert_pubkey_region(&d, 4, &owner);
}
#[kani::proof]
fn system_create_account_layout() {
let lamports: u64 = kani::any();
let space: u64 = kani::any();
let owner: [u8; 32] = kani::any();
let d = rt_system::encode_create_account(lamports, space, &owner);
assert_eq!(d.len(), 52);
assert_system_disc(&d, 0);
assert_eq!(word_at(&d, 4), lamports);
assert_eq!(word_at(&d, 12), space);
assert_pubkey_region(&d, 20, &owner);
}
#[kani::proof]
fn system_create_account_allow_prefund_layout() {
let lamports: u64 = kani::any();
let space: u64 = kani::any();
let owner: [u8; 32] = kani::any();
let d = rt_system::encode_create_account_allow_prefund(lamports, space, &owner);
assert_eq!(d.len(), 52);
assert_system_disc(&d, 13);
assert_eq!(word_at(&d, 4), lamports);
assert_eq!(word_at(&d, 12), space);
assert_pubkey_region(&d, 20, &owner);
}
#[kani::proof]
fn system_advance_nonce_account_layout() {
let d = rt_system::encode_advance_nonce_account();
assert_eq!(d.len(), 4);
assert_system_disc(&d, 4);
}
#[kani::proof]
fn system_withdraw_nonce_account_layout() {
let lamports: u64 = kani::any();
let d = rt_system::encode_withdraw_nonce_account(lamports);
assert_eq!(d.len(), 12);
assert_system_disc(&d, 5);
assert_eq!(word_at(&d, 4), lamports);
}
#[kani::proof]
fn system_initialize_nonce_account_layout() {
let authority: [u8; 32] = kani::any();
let d = rt_system::encode_initialize_nonce_account(&authority);
assert_eq!(d.len(), 36);
assert_system_disc(&d, 6);
assert_pubkey_region(&d, 4, &authority);
}
#[kani::proof]
fn system_authorize_nonce_account_layout() {
let new_authority: [u8; 32] = kani::any();
let d = rt_system::encode_authorize_nonce_account(&new_authority);
assert_eq!(d.len(), 36);
assert_system_disc(&d, 7);
assert_pubkey_region(&d, 4, &new_authority);
}
#[kani::proof]
fn system_upgrade_nonce_account_layout() {
let d = rt_system::encode_upgrade_nonce_account();
assert_eq!(d.len(), 4);
assert_system_disc(&d, 12);
}
#[kani::proof]
fn spl_transfer_matches_reference() {
let amount: u64 = kani::any();
let s = rt_token::encode_transfer(amount);
let r = spl_token::encode_transfer(amount);
assert_eq!(s[0], r[0]);
assert_eq!(word_at(&s, 1), word_at(&r, 1));
}
#[kani::proof]
fn spl_approve_matches_reference() {
let amount: u64 = kani::any();
let s = rt_token::encode_approve(amount);
let r = spl_token::encode_approve(amount);
assert_eq!(s[0], r[0]);
assert_eq!(word_at(&s, 1), word_at(&r, 1));
}
#[kani::proof]
fn spl_mint_to_matches_reference() {
let amount: u64 = kani::any();
let s = rt_token::encode_mint_to(amount);
let r = spl_token::encode_mint_to(amount);
assert_eq!(s[0], r[0]);
assert_eq!(word_at(&s, 1), word_at(&r, 1));
}
#[kani::proof]
fn spl_burn_matches_reference() {
let amount: u64 = kani::any();
let s = rt_token::encode_burn(amount);
let r = spl_token::encode_burn(amount);
assert_eq!(s[0], r[0]);
assert_eq!(word_at(&s, 1), word_at(&r, 1));
}
#[kani::proof]
fn spl_transfer_checked_matches_reference() {
let amount: u64 = kani::any();
let decimals: u8 = kani::any();
let s = rt_token::encode_transfer_checked(amount, decimals);
let r = spl_token::encode_transfer_checked(amount, decimals);
assert_eq!(s[0], r[0]);
assert_eq!(word_at(&s, 1), word_at(&r, 1));
assert_eq!(s[9], r[9]);
}
#[kani::proof]
fn spl_approve_checked_matches_reference() {
let amount: u64 = kani::any();
let decimals: u8 = kani::any();
let s = rt_token::encode_approve_checked(amount, decimals);
let r = spl_token::encode_approve_checked(amount, decimals);
assert_eq!(s[0], r[0]);
assert_eq!(word_at(&s, 1), word_at(&r, 1));
assert_eq!(s[9], r[9]);
}
#[kani::proof]
fn spl_mint_to_checked_matches_reference() {
let amount: u64 = kani::any();
let decimals: u8 = kani::any();
let s = rt_token::encode_mint_to_checked(amount, decimals);
let r = spl_token::encode_mint_to_checked(amount, decimals);
assert_eq!(s[0], r[0]);
assert_eq!(word_at(&s, 1), word_at(&r, 1));
assert_eq!(s[9], r[9]);
}
#[kani::proof]
fn spl_burn_checked_matches_reference() {
let amount: u64 = kani::any();
let decimals: u8 = kani::any();
let s = rt_token::encode_burn_checked(amount, decimals);
let r = spl_token::encode_burn_checked(amount, decimals);
assert_eq!(s[0], r[0]);
assert_eq!(word_at(&s, 1), word_at(&r, 1));
assert_eq!(s[9], r[9]);
}
#[kani::proof]
fn spl_single_byte_matches_reference() {
assert_eq!(rt_token::encode_revoke(), spl_token::encode_revoke());
assert_eq!(
rt_token::encode_close_account(),
spl_token::encode_close_account()
);
assert_eq!(
rt_token::encode_freeze_account(),
spl_token::encode_freeze_account()
);
assert_eq!(
rt_token::encode_thaw_account(),
spl_token::encode_thaw_account()
);
assert_eq!(
rt_token::encode_sync_native(),
spl_token::encode_sync_native()
);
}
#[kani::proof]
fn spl_initialize_account2_matches_reference() {
let owner: [u8; 32] = kani::any();
let s = rt_token::encode_initialize_account_with_owner(16, &owner);
let r = spl_token::encode_initialize_account2(&owner);
assert_eq!(s[0], r[0]);
assert_regions_eq(&s, &r, 1);
}
#[kani::proof]
fn spl_initialize_account3_matches_reference() {
let owner: [u8; 32] = kani::any();
let s = rt_token::encode_initialize_account_with_owner(18, &owner);
let r = spl_token::encode_initialize_account3(&owner);
assert_eq!(s[0], r[0]);
assert_regions_eq(&s, &r, 1);
}
#[kani::proof]
fn spl_set_authority_some_matches_reference() {
let authority_type: u8 = kani::any();
let owner: [u8; 32] = kani::any();
let (s, s_len) = rt_token::encode_set_authority(authority_type, Some(&owner));
let (r, r_len) = spl_token::encode_set_authority(authority_type, Some(&owner));
assert_eq!(s_len, r_len);
assert_eq!(s[0], r[0]);
assert_eq!(s[1], r[1]);
assert_eq!(s[2], r[2]);
assert_regions_eq(&s, &r, 3);
}
#[kani::proof]
fn spl_set_authority_none_matches_reference() {
let authority_type: u8 = kani::any();
let (s, s_len) = rt_token::encode_set_authority(authority_type, None);
let (r, r_len) = spl_token::encode_set_authority(authority_type, None);
assert_eq!(s_len, r_len);
assert_eq!(s[0], r[0]);
assert_eq!(s[1], r[1]);
assert_eq!(s[2], r[2]);
}
#[kani::proof]
fn system_transfer_matches_reference() {
let lamports: u64 = kani::any();
let s = rt_system::encode_transfer(lamports);
let r = system::encode_transfer(lamports);
assert_eq!(word_at(&s, 0), word_at(&r, 0));
assert_eq!(word_at(&s, 4), word_at(&r, 4));
}
#[kani::proof]
fn system_allocate_matches_reference() {
let space: u64 = kani::any();
let s = rt_system::encode_allocate(space);
let r = system::encode_allocate(space);
assert_eq!(word_at(&s, 0), word_at(&r, 0));
assert_eq!(word_at(&s, 4), word_at(&r, 4));
}
#[kani::proof]
fn system_assign_matches_reference() {
let owner: [u8; 32] = kani::any();
let s = rt_system::encode_assign(&owner);
let r = system::encode_assign(&owner);
assert_eq!(word_at(&s, 0), word_at(&r, 0));
assert_regions_eq(&s, &r, 4);
}
#[kani::proof]
fn system_create_account_matches_reference() {
let lamports: u64 = kani::any();
let space: u64 = kani::any();
let owner: [u8; 32] = kani::any();
let s = rt_system::encode_create_account(lamports, space, &owner);
let r = system::encode_create_account(lamports, space, &owner);
assert_eq!(word_at(&s, 0), word_at(&r, 0));
assert_eq!(word_at(&s, 4), word_at(&r, 4));
assert_eq!(word_at(&s, 12), word_at(&r, 12));
assert_regions_eq(&s, &r, 20);
}
#[kani::proof]
fn system_advance_nonce_account_matches_reference() {
assert_eq!(
rt_system::encode_advance_nonce_account(),
system::encode_advance_nonce_account()
);
}
#[kani::proof]
fn system_withdraw_nonce_account_matches_reference() {
let lamports: u64 = kani::any();
let s = rt_system::encode_withdraw_nonce_account(lamports);
let r = system::encode_withdraw_nonce_account(lamports);
assert_eq!(word_at(&s, 0), word_at(&r, 0));
assert_eq!(word_at(&s, 4), word_at(&r, 4));
}
#[kani::proof]
fn system_initialize_nonce_account_matches_reference() {
let authority: [u8; 32] = kani::any();
let s = rt_system::encode_initialize_nonce_account(&authority);
let r = system::encode_initialize_nonce_account(&authority);
assert_eq!(word_at(&s, 0), word_at(&r, 0));
assert_regions_eq(&s, &r, 4);
}
#[kani::proof]
fn system_authorize_nonce_account_matches_reference() {
let new_authority: [u8; 32] = kani::any();
let s = rt_system::encode_authorize_nonce_account(&new_authority);
let r = system::encode_authorize_nonce_account(&new_authority);
assert_eq!(word_at(&s, 0), word_at(&r, 0));
assert_regions_eq(&s, &r, 4);
}
#[kani::proof]
fn system_upgrade_nonce_account_matches_reference() {
assert_eq!(
rt_system::encode_upgrade_nonce_account(),
system::encode_upgrade_nonce_account()
);
}
}