Merge pull request solana-labs#116 from jarry-xiao/more-bgum-parsing

adds more validation to bgum and parses redeem and cancel redeem

contracts/programs/bubblegum/src/error.rs

@@ -6,4 +6,8 @@ pub enum BubblegumError {
     AssetOwnerMismatch,
     #[msg("PublicKeyMismatch")]
     PublicKeyMismatch,
+    #[msg("Hashing Mismatch Within Leaf Schema")]
+    HashingMismatch,
+    #[msg("Unsupported Schema Version")]
+    UnsupportedSchemaVersion,
 }

contracts/programs/bubblegum/src/lib.rs

@@ -10,12 +10,17 @@ use {
         Nonce, Voucher,
         metaplex_adapter::{MetadataArgs, TokenProgramVersion},
         NewNFTEvent,
+        NFTDecompressionEvent
     },
     gummyroll::{program::Gummyroll, Node},
+    crate::error::BubblegumError,
     crate::utils::{append_leaf,
                    insert_or_append_leaf,
                    replace_leaf,
                    get_asset_id,
+                   cmp_bytes,
+                   cmp_pubkeys,
+                   assert_pubkey_equal,
     },
     anchor_lang::{
         prelude::*,
@@ -321,8 +326,6 @@ pub fn get_instruction_type(full_bytes: &[u8]) -> InstructionName {
 
 #[program]
 pub mod bubblegum {
-    use crate::error::BubblegumError;
-    use crate::utils::assert_pubkey_equal;
     use super::*;
 
     pub fn create_tree(
@@ -582,8 +585,29 @@ pub mod bubblegum {
 
     pub fn decompress_v1(ctx: Context<DecompressV1>, metadata: MetadataArgs) -> Result<()> {
         // Allocate and create mint
-        let data_hash = hash_metadata(&metadata)?;
-        assert_eq!(ctx.accounts.voucher.leaf_schema.data_hash(), data_hash);
+        let incoming_data_hash = hash_metadata(&metadata)?;
+        let event = match ctx.accounts.voucher.leaf_schema {
+            LeafSchema::V1 {
+                owner,
+                data_hash,
+                nonce,
+                ..
+            } => {
+                if !cmp_bytes(&data_hash, &incoming_data_hash, 32) {
+                    return Err(BubblegumError::HashingMismatch.into());
+                }
+                if !cmp_pubkeys(&owner, ctx.accounts.owner.key) {
+                    return Err(BubblegumError::AssetOwnerMismatch.into());
+                }
+                Ok(NFTDecompressionEvent {
+                    version: Version::V1,
+                    tree_id: ctx.accounts.voucher.merkle_slab.key(),
+                    id: get_asset_id(&ctx.accounts.voucher.merkle_slab.key(), nonce),
+                    nonce: nonce
+                })
+            }
+            _ => Err(BubblegumError::UnsupportedSchemaVersion)
+        }?;
         let voucher = &ctx.accounts.voucher;
         match metadata.token_program_version {
             TokenProgramVersion::Original => {
@@ -740,6 +764,7 @@ pub mod bubblegum {
                 &[ctx.bumps["mint_authority"]],
             ]],
         )?;
+        emit!(event);
         Ok(())
     }
 

contracts/programs/bubblegum/src/state/leaf_schema.rs

@@ -95,6 +95,7 @@ impl LeafSchema {
             LeafSchema::V1 { data_hash, .. } => *data_hash,
         }
     }
+
 
     pub fn to_event(&self) -> LeafSchemaEvent {
         LeafSchemaEvent {

contracts/programs/bubblegum/src/state/mod.rs

@@ -35,9 +35,18 @@ impl Voucher {
         }
     }
 }
+
 #[event]
 pub struct NewNFTEvent {
     pub version: Version,
     pub metadata: MetadataArgs,
     pub nonce: u64,
 }
+
+#[event]
+pub struct NFTDecompressionEvent {
+    pub version: Version,
+    pub id: Pubkey,
+    pub tree_id: Pubkey,
+    pub nonce: u64,
+}

contracts/programs/bubblegum/src/utils.rs

@@ -87,6 +87,10 @@ pub fn cmp_pubkeys(a: &Pubkey, b: &Pubkey) -> bool {
     sol_memcmp(a.as_ref(), b.as_ref(), PUBKEY_BYTES) == 0
 }
 
+pub fn cmp_bytes(a: &[u8], b: &[u8], size: usize) -> bool {
+    sol_memcmp(a.as_ref(), b.as_ref(), size) == 0
+}
+
 pub fn assert_pubkey_equal(a: &Pubkey, b: &Pubkey, error: Option<anchor_lang::error::Error>) -> Result<()>  {
     if !cmp_pubkeys(a, b) {
         if error.is_some() {