pull upstream

Author: Nagaprasadvr

Cargo.lock

@@ -25,7 +25,7 @@ packx = { version = "0.2.5", features = ["solana"] }
 bytemuck = "1.14.3"
 bytemuck_derive = "1.7.0"
 num_enum = "0.7.2"
-brine-tree = { version = "0.5.4", features = ["solana"] }
+brine-tree = { version = "0.6.2", features = ["solana"] }
 array-const-fn-init = "0.1.1"
 const-crypto = "0.3.0"
 
@@ -48,7 +48,7 @@ spl-associated-token-account = { version = "^6", features = [ "no-entrypoint" ]
 # client-specific
 anyhow = "1.0"
 flate2 = "1.0"
-sha3 = "0.10.8"
+blake3 = "1.8.2"
 bincode = "1.3"
 base64 = "0.13"
 serde = { version = "1.0", features = ["derive"] }

Cargo.toml

@@ -45,12 +45,13 @@ pub const TAPE_PROOF_LEN: usize = TAPE_TREE_HEIGHT;
 // ====================================================================
 /// Segment size in bytes
 pub const SEGMENT_SIZE: usize = 128;
+/// Packed Segment size in bytes
+pub const PACKED_SEGMENT_SIZE: usize = 152; // packx::SOLUTION_SIZE
+
 /// Maximum number of segments in a tape
 pub const MAX_SEGMENTS_PER_TAPE: usize = 1 << SEGMENT_TREE_HEIGHT - 1;
 /// Maximum number of tapes in a spool
 pub const MAX_TAPES_PER_SPOOL: usize = 1 << TAPE_TREE_HEIGHT - 1;
-/// Packed Segment size in bytes
-pub const PACKED_SEGMENT_SIZE: usize = packx::SOLUTION_SIZE;
 
 // ====================================================================
 // Token Economics
@@ -154,3 +155,13 @@ pub const TREASURY_ATA: Pubkey = Pubkey::new_from_array(
     .0,
 );
 
+pub const TREASURY_ATA_BUMP: u8 = 
+    ed25519::derive_program_address(
+        &[
+            unsafe { &*(&TREASURY_ADDRESS as *const Pubkey as *const [u8; 32]) },
+            unsafe { &*(&spl_token::id() as *const Pubkey as *const [u8; 32]) },
+            unsafe { &*(&MINT_ADDRESS as *const Pubkey as *const [u8; 32]) },
+        ],
+        unsafe { &*(&spl_associated_token_account::id() as *const Pubkey as *const [u8; 32]) },
+    )
+    .1;

api/src/consts.rs

@@ -1,7 +1,8 @@
 use steel::*;
 use crate::{
     consts::*,
-    pda::*
+    pda::*,
+    types::*,
 };
 
 #[repr(u8)]
@@ -48,7 +49,7 @@ pub struct Unpack {
 #[derive(Clone, Copy, Debug, Pod, Zeroable)]
 pub struct Commit {
     pub index: [u8; 8],
-    pub proof: [[u8; 32]; SEGMENT_PROOF_LEN],
+    pub proof: ProofPath,
     pub value: [u8; 32],
 }
 
@@ -139,7 +140,7 @@ pub fn build_commit_ix(
     miner_address: Pubkey, 
     spool_address: Pubkey,
     index: u64,                           // index of the value to commit
-    proof: [[u8; 32]; SEGMENT_PROOF_LEN], // proof of the value
+    proof: ProofPath,                     // proof of the value
     value: [u8; 32],                      // value to commit
 ) -> Instruction {
     Instruction {

api/src/instruction/spool.rs

@@ -2,6 +2,7 @@ use steel::*;
 use crate::{
     consts::*,
     pda::*,
+    types::*,
     utils,
 };
 
@@ -41,7 +42,7 @@ pub struct Update {
     pub segment_number: [u8; 8],
     pub old_data: [u8; SEGMENT_SIZE],
     pub new_data: [u8; SEGMENT_SIZE],
-    pub proof: [[u8; 32]; SEGMENT_PROOF_LEN],
+    pub proof: ProofPath,
 }
 
 #[repr(C)]
@@ -130,7 +131,7 @@ pub fn build_update_ix(
     segment_number: u64,
     old_data: [u8; SEGMENT_SIZE],
     new_data: [u8; SEGMENT_SIZE],
-    proof: [[u8;32]; SEGMENT_PROOF_LEN],
+    proof: ProofPath,
 ) -> Instruction {
 
     let segment_number = segment_number.to_le_bytes();

api/src/instruction/tape.rs

@@ -5,7 +5,6 @@ use std::mem::MaybeUninit;
 use steel::*;
 use crate::consts::*;
 
-
 pub fn pda_derive_address<const N: usize>(
     seeds: &[&[u8]; N],
     bump: Option<u8>,
@@ -71,43 +70,41 @@ pub fn pda_derive_address<const N: usize>(
     unreachable!("deriving a pda is only available on target `solana`");
 }
 
+
+#[inline(always)]
 pub fn archive_pda() -> (Pubkey, u8) {
     (ARCHIVE_ADDRESS, ARCHIVE_BUMP)
 }
 
+#[inline(always)]
 pub fn epoch_pda() -> (Pubkey, u8) {
     (EPOCH_ADDRESS, EPOCH_BUMP)
 }
 
+#[inline(always)]
 pub fn block_pda() -> (Pubkey, u8) {
     (BLOCK_ADDRESS, BLOCK_BUMP)
 }
 
+#[inline(always)]
 pub fn treasury_pda() -> (Pubkey, u8) {
     (TREASURY_ADDRESS, TREASURY_BUMP)
 }
 
+#[inline(always)]
 pub fn treasury_ata() -> (Pubkey, u8) {
-    let (treasury_pda,_bump) = treasury_pda();
-    let (mint_pda, _bump) = mint_pda();
-
-    Pubkey::find_program_address(
-        &[
-            treasury_pda.as_ref(), 
-            spl_token::ID.as_ref(),
-            mint_pda.as_ref()
-        ],
-        &spl_associated_token_account::ID,
-    )
+    (TREASURY_ATA, TREASURY_ATA_BUMP)
 }
 
+
+#[inline(always)]
 pub fn mint_pda() -> (Pubkey, u8) {
     (MINT_ADDRESS, MINT_BUMP)
 }
 
 pub fn metadata_find_pda(mint: Pubkey) -> (Pubkey, u8) {
     Pubkey::find_program_address(
-        &[METADATA, mpl_token_metadata::ID.as_ref(), mint.as_ref() ],
+        &[METADATA, mpl_token_metadata::ID.as_ref(), mint.as_ref()],
         &mpl_token_metadata::ID,
     )
 }
@@ -147,7 +144,8 @@ pub fn miner_derive_pda(authority: Pubkey, name: &[u8; NAME_LEN], bump: u8) -> P
 
 pub fn spool_find_pda(miner: Pubkey, number: u64) -> (Pubkey, u8) {
     Pubkey::find_program_address(
-        &[SPOOL, miner.as_ref(), number.to_le_bytes().as_ref()], &crate::id()
+        &[SPOOL, miner.as_ref(), number.to_le_bytes().as_ref()],
+        &crate::id(),
     )
 }
 
@@ -157,4 +155,73 @@ pub fn spool_derive_pda(miner: Pubkey, number: u64, bump: u8) -> Pubkey {
         Some(bump),
         &crate::id(),
     )
-}
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    pub fn archive_pda() -> (Pubkey, u8) {
+        Pubkey::find_program_address(&[ARCHIVE], &crate::id())
+    }
+    pub fn epoch_pda() -> (Pubkey, u8) {
+        Pubkey::find_program_address(&[EPOCH], &crate::id())
+    }
+
+    pub fn block_pda() -> (Pubkey, u8) {
+        Pubkey::find_program_address(&[BLOCK], &crate::id())
+    }
+
+    pub fn treasury_pda() -> (Pubkey, u8) {
+        Pubkey::find_program_address(&[TREASURY], &crate::id())
+    }
+
+    pub fn treasury_ata() -> (Pubkey, u8) {
+        let (treasury_pda, _bump) = treasury_pda();
+        let (mint_pda, _bump) = mint_pda();
+        Pubkey::find_program_address(
+            &[
+                treasury_pda.as_ref(),
+                spl_token::ID.as_ref(),
+                mint_pda.as_ref(),
+            ],
+            &spl_associated_token_account::ID,
+        )
+    }
+
+    pub fn mint_pda() -> (Pubkey, u8) {
+        Pubkey::find_program_address(&[MINT, MINT_SEED], &crate::id())
+    }
+
+    #[test]
+    fn test_pda_against_consts() {
+        // These tests, as nonsensical as they seem, are to ensure that the PDAs generated by the
+        // consts match the ones generated by the official functions. The consts are generated by
+        // external deps, so if we straight up use the consts, we are trusting that the external
+        // deps are working as expected, which is not a good idea. Always be testing.
+
+        let (pda, bump) = archive_pda();
+        assert_eq!(bump, ARCHIVE_BUMP);
+        assert_eq!(pda, ARCHIVE_ADDRESS);
+
+        let (pda, bump) = epoch_pda();
+        assert_eq!(bump, EPOCH_BUMP);
+        assert_eq!(pda, EPOCH_ADDRESS);
+
+        let (pda, bump) = block_pda();
+        assert_eq!(bump, BLOCK_BUMP);
+        assert_eq!(pda, BLOCK_ADDRESS);
+
+        let (pda, bump) = mint_pda();
+        assert_eq!(bump, MINT_BUMP);
+        assert_eq!(pda, MINT_ADDRESS);
+
+        let (pda, bump) = treasury_pda();
+        assert_eq!(bump, TREASURY_BUMP);
+        assert_eq!(pda, TREASURY_ADDRESS);
+
+        let (pda, _bump) = treasury_ata();
+        assert_eq!(pda, TREASURY_ATA);
+    }
+}

api/src/pda.rs

@@ -16,14 +16,12 @@ pub struct Tape {
     pub merkle_root: [u8; 32],
     pub header:      [u8; HEADER_SIZE],
 
-    pub first_slot: u64,
-    pub tail_slot: u64,
+    pub first_slot:      u64,
+    pub tail_slot:       u64,
 
-    pub balance: u64,
+    pub balance:         u64,
     pub last_rent_block: u64,
-
-    pub total_segments: u64,
-
+    pub total_segments:  u64,
     pub pda_bump: u64,
 }
 
@@ -37,3 +35,24 @@ pub enum TapeState {
 }
 
 state!(AccountType, Tape);
+
+//pub fn encode_tape(tape: &Tape, nodes: &[[u8; 32]]) -> Vec<u8> {
+//    let mut out = Vec::with_capacity(core::mem::size_of::<Tape>() + nodes.len() * 32);
+//    out.extend_from_slice(bytemuck::bytes_of(tape));
+//    out.extend_from_slice(bytemuck::cast_slice(nodes));
+//    out
+//}
+//
+//pub fn decode_tape(data: &[u8]) -> Result<(&Tape, &[[u8; 32]]), ProgramError> {
+//    let need = core::mem::size_of::<Tape>();
+//    if data.len() < need {
+//        return Err(ProgramError::AccountDataTooSmall);
+//    }
+//    let (head_bytes, tail) = data.split_at(need);
+//    if tail.len() % 32 != 0 {
+//        return Err(ProgramError::AccountDataTooSmall);
+//    }
+//    let header: &Tape = bytemuck::from_bytes(head_bytes);
+//    let nodes: &[[u8; 32]] = bytemuck::try_cast_slice(tail).expect("len checked");
+//    Ok((header, nodes))
+//}