diff --git a/Cargo.lock b/Cargo.lock index aa737e996..63db62a10 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -9728,6 +9728,7 @@ dependencies = [ "bitcoin-move", "clap 4.5.17", "coerce", + "csv", "datatest-stable 0.1.3", "ethers", "framework-builder", diff --git a/crates/rooch-framework-tests/Cargo.toml b/crates/rooch-framework-tests/Cargo.toml index 582bc5a55..bba44fefc 100644 --- a/crates/rooch-framework-tests/Cargo.toml +++ b/crates/rooch-framework-tests/Cargo.toml @@ -29,6 +29,7 @@ coerce = { workspace = true } tokio = { workspace = true } clap = { features = ["derive", ], workspace = true } rand = { workspace = true } +csv = { workspace = true } move-core-types = { workspace = true } moveos-types = { workspace = true } diff --git a/crates/rooch-framework-tests/src/bbn_tx_loader.rs b/crates/rooch-framework-tests/src/bbn_tx_loader.rs new file mode 100644 index 000000000..e6eb4b408 --- /dev/null +++ b/crates/rooch-framework-tests/src/bbn_tx_loader.rs @@ -0,0 +1,61 @@ +// Copyright (c) RoochNetwork +// SPDX-License-Identifier: Apache-2.0 + +use std::{path::Path, str::FromStr}; + +use anyhow::Result; +use bitcoin::Txid; + +// Load the babylon staking transactions exported file + +// https://github.com/babylonlabs-io/staking-indexer + +// Transaction Hash,Staking Output Index,Inclusion Height,Staker Public Key,Staking Time,Finality Provider Public Key,Is Overflow,Staking Value +// 8440304144a4585d80b60888ba58944f3c626d5c2a813b8955052b2daac20b00,0,864791,04bd117663e6970dad57769a9105bf72f8f7ec162b8e44bf597f41babe5cf8a3,64000,fc8a5b9930c3383e94bd940890e93cfcf95b2571ad50df8063b7011f120b918a,true,4800000 +// ffaae2983630d3d51fac15180e2f89c1ae237e3648e11c5ec506113e78216e00,0,864791,3f1713f12f5ce2269c3360454fd552c77994f287f006b8f7e4c215b5f57a47ed,64000,db9160428e401753dc1a9952ffd4fa3386c7609cf8411d2b6d79c42323ca9923,true,1345800 +// a1fa47d149457a994d2199ceffc43793eb18287864a6b7314c14ba3649f07000,0,864791,ef548602c263dc77b3c75ebb82edae9f1f57c16b6551c40179e9eb942b454be6,64000,742f1eb3c7fdbd327fa44fcdddf17645d9c6b1287ea97463e046508234fa7537,true,600000 +// 7487946cb0598179b805ce73575bb22f99b2ca49d213bf57047ea864dc2f7800,0,864791,c749e4aa8436dc738373f1ccc9570ce9fe8a1d70bae1c25dac71f8e6e0c699ed,64000,0f5c19935a08f661a1c4dfeb5e51ce7f0cfcf4d2eeb405fe4c7d7bd668fc85e4,true,564500 + +#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] +pub struct BBNStakingTxRecord { + pub transaction_hash: String, + pub staking_output_index: u32, + pub inclusion_height: u64, + pub staker_public_key: String, + pub staking_time: u16, + pub finality_provider_public_key: String, + pub is_overflow: bool, + pub staking_value: u64, +} +impl BBNStakingTxRecord { + pub fn load_bbn_staking_txs>( + file_path: P, + block_height: u64, + ) -> Result> { + let mut rdr = csv::ReaderBuilder::new() + .has_headers(true) + .from_path(file_path.as_ref())?; + + let mut txs = vec![]; + for result in rdr.records() { + let record = result?; + let tx: BBNStakingTxRecord = record.deserialize(None)?; + if tx.inclusion_height == block_height { + txs.push(tx); + } + } + Ok(txs) + } + + pub fn txid(&self) -> Txid { + Txid::from_str(&self.transaction_hash).unwrap() + } + + pub fn staker_public_key(&self) -> Vec { + hex::decode(&self.staker_public_key).unwrap() + } + + pub fn finality_provider_public_key(&self) -> Vec { + hex::decode(&self.finality_provider_public_key).unwrap() + } +} diff --git a/crates/rooch-framework-tests/src/binding_test.rs b/crates/rooch-framework-tests/src/binding_test.rs index ace1ee0cd..e276c0322 100644 --- a/crates/rooch-framework-tests/src/binding_test.rs +++ b/crates/rooch-framework-tests/src/binding_test.rs @@ -4,6 +4,7 @@ use anyhow::{bail, Result}; use metrics::RegistryService; use move_core_types::account_address::AccountAddress; +use move_core_types::u256::U256; use move_core_types::vm_status::KeptVMStatus; use moveos_config::DataDirPath; use moveos_store::MoveOSStore; @@ -11,13 +12,14 @@ use moveos_types::function_return_value::FunctionResult; use moveos_types::h256::H256; use moveos_types::module_binding::MoveFunctionCaller; use moveos_types::moveos_std::event::Event; +use moveos_types::moveos_std::gas_schedule::GasScheduleConfig; use moveos_types::moveos_std::object::ObjectMeta; use moveos_types::moveos_std::tx_context::TxContext; -use moveos_types::state::{FieldKey, ObjectChange, ObjectState, StateChangeSet}; +use moveos_types::state::{FieldKey, MoveStructType, ObjectChange, ObjectState, StateChangeSet}; use moveos_types::state_resolver::{ RootObjectResolver, StateKV, StateReaderExt, StateResolver, StatelessResolver, }; -use moveos_types::transaction::{FunctionCall, VerifiedMoveOSTransaction}; +use moveos_types::transaction::{FunctionCall, MoveAction, VerifiedMoveOSTransaction}; use rooch_config::RoochOpt; use rooch_db::RoochDB; use rooch_executor::actor::reader_executor::ReaderExecutorActor; @@ -25,8 +27,13 @@ use rooch_executor::actor::{executor::ExecutorActor, messages::ExecuteTransactio use rooch_genesis::RoochGenesis; use rooch_types::address::BitcoinAddress; use rooch_types::crypto::RoochKeyPair; +use rooch_types::framework::gas_coin::RGas; +use rooch_types::framework::transfer::TransferModule; use rooch_types::rooch_network::{BuiltinChainID, RoochNetwork}; -use rooch_types::transaction::{L1BlockWithBody, L1Transaction, RoochTransaction}; +use rooch_types::transaction::authenticator::BitcoinAuthenticator; +use rooch_types::transaction::{ + Authenticator, L1BlockWithBody, L1Transaction, RoochTransaction, RoochTransactionData, +}; use std::collections::VecDeque; use std::path::Path; use std::sync::Arc; @@ -47,6 +54,7 @@ pub fn get_data_dir() -> DataDirPath { } pub struct RustBindingTest { + network: RoochNetwork, //we keep the opt to ensure the temp dir is not be deleted before the test end opt: RoochOpt, pub sequencer: AccountAddress, @@ -102,6 +110,7 @@ impl RustBindingTest { None, )?; Ok(Self { + network, opt, root, sequencer: sequencer.to_rooch_address().into(), @@ -139,6 +148,33 @@ impl RustBindingTest { &self.rooch_db } + pub fn get_rgas(&mut self, addr: AccountAddress, amount: U256) -> Result<()> { + // transfer RGas from rooch dao account to addr + let function_call = + TransferModule::create_transfer_coin_action(RGas::struct_tag(), addr, amount); + let sender = self + .network + .genesis_config + .rooch_dao + .multisign_bitcoin_address + .to_rooch_address(); + let sequence_number = self.get_account_sequence_number(sender.into())?; + let tx_data = RoochTransactionData::new( + sender, + sequence_number, + self.network.chain_id.id, + GasScheduleConfig::CLI_DEFAULT_MAX_GAS_AMOUNT, + function_call, + ); + //RoochDao is a multisign account, so we need to sign the tx with the multisign account + //In test env, it is a 1-of-1 multisign account, so we can sign with the only key + let first_signature = BitcoinAuthenticator::sign(&self.kp, &tx_data); + let authenticator = Authenticator::bitcoin_multisign(vec![first_signature])?; + let tx = RoochTransaction::new(tx_data, authenticator); + self.execute(tx)?; + Ok(()) + } + //TODO let the module bundle to execute the function pub fn execute(&mut self, tx: RoochTransaction) -> Result { let execute_result = self.execute_as_result(tx)?; @@ -151,6 +187,24 @@ impl RustBindingTest { Ok(execute_result) } + pub fn execute_function_call_via_sequencer( + &mut self, + function_call: FunctionCall, + ) -> Result { + let action = MoveAction::Function(function_call); + let sequence_number = self.get_account_sequence_number(self.sequencer)?; + let tx_data = RoochTransactionData::new( + self.sequencer.into(), + sequence_number, + self.network.chain_id.id, + GasScheduleConfig::CLI_DEFAULT_MAX_GAS_AMOUNT, + action, + ); + let tx = tx_data.sign(&self.kp); + let result = self.execute_as_result(tx)?; + Ok(result) + } + pub fn execute_l1_block_and_tx( &mut self, l1_block: L1BlockWithBody, diff --git a/crates/rooch-framework-tests/src/bitcoin_block_tester.rs b/crates/rooch-framework-tests/src/bitcoin_block_tester.rs index b305e87da..4bd413a35 100644 --- a/crates/rooch-framework-tests/src/bitcoin_block_tester.rs +++ b/crates/rooch-framework-tests/src/bitcoin_block_tester.rs @@ -1,15 +1,16 @@ // Copyright (c) RoochNetwork // SPDX-License-Identifier: Apache-2.0 -use crate::binding_test::RustBindingTest; +use crate::{bbn_tx_loader::BBNStakingTxRecord, binding_test::RustBindingTest}; use anyhow::{anyhow, bail, ensure, Result}; use bitcoin::{hashes::Hash, Block, OutPoint, TxOut, Txid}; use framework_builder::stdlib_version::StdlibVersion; +use move_core_types::{account_address::AccountAddress, u256::U256, vm_status::KeptVMStatus}; use moveos_types::{ move_std::string::MoveString, moveos_std::{ - module_store::ModuleStore, object::ObjectMeta, simple_multimap::SimpleMultiMap, - timestamp::Timestamp, + event::Event, module_store::ModuleStore, object::ObjectMeta, + simple_multimap::SimpleMultiMap, timestamp::Timestamp, }, state::{MoveState, MoveStructType, MoveType, ObjectChange, ObjectState}, state_resolver::StateResolver, @@ -18,6 +19,10 @@ use rooch_ord::ord_client::Charm; use rooch_relayer::actor::bitcoin_client_proxy::BitcoinClientProxy; use rooch_types::{ bitcoin::{ + bbn::{ + self, BBNModule, BBNParsedV0StakingTx, BBNStakeSeal, BBNStakingEvent, + BBNStakingFailedEvent, + }, inscription_updater::{ InscriptionCreatedEvent, InscriptionTransferredEvent, InscriptionUpdaterEvent, }, @@ -29,7 +34,7 @@ use rooch_types::{ rooch_network::{BuiltinChainID, RoochNetwork}, transaction::L1BlockWithBody, }; -use serde::{Deserialize, Serialize}; +use serde::{de::DeserializeOwned, Deserialize, Serialize}; use std::{ collections::{BTreeSet, HashMap, HashSet}, path::{Path, PathBuf}, @@ -37,12 +42,34 @@ use std::{ }; use tracing::{debug, error, info, trace}; +#[derive(Debug)] +struct ExecutedBlockData { + block_data: BlockData, + events: Vec, +} + +impl ExecutedBlockData { + pub fn filter_events(&self) -> Vec { + self.events + .iter() + .filter_map(|event| { + if event.event_type == T::struct_tag() { + let event = bcs::from_bytes::(&event.event_data).unwrap(); + Some(event) + } else { + None + } + }) + .collect() + } +} + /// Execute Bitcoin block and test base a emulated environment /// We prepare the Block's previous dependencies and execute the block pub struct BitcoinBlockTester { genesis: BitcoinTesterGenesis, binding_test: RustBindingTest, - executed_block: Option, + executed_block: Option, } impl BitcoinBlockTester { @@ -77,6 +104,7 @@ impl BitcoinBlockTester { let mut binding_test = RustBindingTest::new_with_network(network)?; let root_changes = vec![utxo_store_change]; binding_test.apply_changes(root_changes)?; + binding_test.get_rgas(binding_test.sequencer, U256::from(100000000000000u64))?; Ok(Self { genesis, binding_test, @@ -94,6 +122,7 @@ impl BitcoinBlockTester { let l1_block = L1BlockWithBody::new_bitcoin_block(block_data.height, block_data.block.clone()); let results = self.binding_test.execute_l1_block_and_tx(l1_block)?; + let mut events = vec![]; for result in results { for event in result.output.events { if event.event_type == InscriptionCreatedEvent::struct_tag() { @@ -107,6 +136,8 @@ impl BitcoinBlockTester { .events_from_move .push(InscriptionUpdaterEvent::InscriptionTransferred(event)); } + + events.push(event); } } @@ -129,7 +160,7 @@ impl BitcoinBlockTester { block_data.events_from_ord.len(), block_data.expect_inscriptions.len() ); - self.executed_block = Some(block_data); + self.executed_block = Some(ExecutedBlockData { block_data, events }); Ok(()) } @@ -139,8 +170,8 @@ impl BitcoinBlockTester { "No block executed, please execute block first" ); let mut utxo_set = HashMap::::new(); - let block_data = self.executed_block.as_ref().unwrap(); - for tx in block_data.block.txdata.as_slice() { + let executed_block_data = self.executed_block.as_ref().unwrap(); + for tx in executed_block_data.block_data.block.txdata.as_slice() { let txid = tx.compute_txid(); for (index, tx_out) in tx.output.iter().enumerate() { let vout = index as u32; @@ -182,37 +213,38 @@ impl BitcoinBlockTester { utxo_state, tx_out ); + //TODO migrate to verify inscription. //Ensure every utxo's seals are correct let seals = utxo_state.seals; if !seals.is_empty() { - let inscription_obj_ids = seals - .borrow(&MoveString::from( - Inscription::type_tag().to_canonical_string(), - )) - .expect("Inscription seal not found"); - for inscription_obj_id in inscription_obj_ids { - let inscription_obj = self.binding_test.get_object(inscription_obj_id)?; - ensure!( - inscription_obj.is_some(), - "Missing inscription object: {:?}", - inscription_obj_id - ); - let inscription_obj = inscription_obj.unwrap(); - let inscription = inscription_obj.value_as::().map_err(|e| { - error!( - "Parse Inscription Error: {:?}, object meta: {:?}, object value: {}", - e, - inscription_obj.metadata, - hex::encode(&inscription_obj.value) + let inscription_obj_ids = seals.borrow(&MoveString::from( + Inscription::type_tag().to_canonical_string(), + )); + if let Some(inscription_obj_ids) = inscription_obj_ids { + for inscription_obj_id in inscription_obj_ids { + let inscription_obj = self.binding_test.get_object(inscription_obj_id)?; + ensure!( + inscription_obj.is_some(), + "Missing inscription object: {:?}", + inscription_obj_id ); - e - })?; - ensure!( - inscription.location.outpoint == outpoint.into(), - "Inscription location not match: {:?}, {:?}", - inscription, - outpoint - ); + let inscription_obj = inscription_obj.unwrap(); + let inscription = inscription_obj.value_as::().map_err(|e| { + error!( + "Parse Inscription Error: {:?}, object meta: {:?}, object value: {}", + e, + inscription_obj.metadata, + hex::encode(&inscription_obj.value) + ); + e + })?; + ensure!( + inscription.location.outpoint == outpoint.into(), + "Inscription location not match: {:?}, {:?}", + inscription, + outpoint + ); + } } } } @@ -224,7 +256,7 @@ impl BitcoinBlockTester { self.executed_block.is_some(), "No block executed, please execute block first" ); - let block_data = self.executed_block.as_ref().unwrap(); + let block_data = &self.executed_block.as_ref().unwrap().block_data; info!( "verify {} inscriptions in block", block_data.expect_inscriptions.len() @@ -397,6 +429,169 @@ impl BitcoinBlockTester { Ok(()) } + pub fn execute_bbn_process(&mut self) -> Result<()> { + ensure!( + self.executed_block.is_some(), + "No block executed, please execute block first" + ); + let executed_block_data = self.executed_block.as_mut().unwrap(); + + for tx in executed_block_data.block_data.block.txdata.iter() { + let txid = tx.compute_txid(); + if BBNParsedV0StakingTx::is_possible_staking_tx(tx, &bbn::BBN_GLOBAL_PARAM_BBN1.tag) { + let function_call = BBNModule::create_process_bbn_tx_entry_call(txid)?; + let execute_result = self + .binding_test + .execute_function_call_via_sequencer(function_call)?; + debug!("BBN process result: {:?}", execute_result); + if execute_result.transaction_info.status != KeptVMStatus::Executed { + let op_return_data = bbn::try_get_bbn_op_return_ouput(&tx.output); + bail!( + "tx should success, txid: {:?}, status: {:?}, op_return_data from rust: {:?}", + txid, + execute_result.transaction_info.status, + op_return_data + ); + } + for event in execute_result.output.events { + executed_block_data.events.push(event); + } + } + } + + Ok(()) + } + + pub fn verify_bbn_stake(&self) -> Result<()> { + ensure!( + self.executed_block.is_some(), + "No block executed, please execute block first" + ); + + let executed_block_data = self.executed_block.as_ref().unwrap(); + + let bbn_staking_txs = executed_block_data + .block_data + .bbn_staking_records + .iter() + .map(|tx| (tx.txid().into_address(), tx.clone())) + .collect::>(); + + let bbn_staking_failed_events = + executed_block_data.filter_events::(); + let bbn_staking_events = executed_block_data.filter_events::(); + + info!( + "BBN staking txs: {}, staking failed events: {}, staking events: {}, total_events: {}", + bbn_staking_txs.len(), + bbn_staking_failed_events.len(), + bbn_staking_events.len(), + executed_block_data.events.len() + ); + + for event in &bbn_staking_failed_events { + debug!("Staking failed event: {:?}", event); + let txid = event.txid.into_address(); + ensure!( + !bbn_staking_txs.contains_key(&txid), + "Staking failed txid {:?} in event but also in staking txs from bbn indexer", + txid, + ); + } + + for (txid, _tx) in bbn_staking_txs.iter() { + let event = bbn_staking_events.iter().find(|event| event.txid == *txid); + ensure!( + event.is_some(), + "Staking txid {:?} in staking txs from bbn indexer but not in event", + txid, + ); + } + + for event in bbn_staking_events { + let stake_object_id = event.stake_object_id; + let txid = event.txid; + let bbn_staking_tx = bbn_staking_txs.get(&txid); + ensure!( + bbn_staking_tx.is_some(), + "Missing staking tx: {:?} in staking txs from bbn indexer", + txid + ); + + let bbn_staking_tx = bbn_staking_tx.unwrap(); + + let stake_obj = self.binding_test.get_object(&stake_object_id)?; + ensure!( + stake_obj.is_some(), + "Missing stake object: {:?}, staking tx: {:?}", + stake_object_id, + bbn_staking_tx + ); + let bbn_stake = stake_obj.unwrap().value_as::()?; + ensure!( + bbn_stake.staking_output_index == bbn_staking_tx.staking_output_index, + "Seal not match: {:?}, staking tx: {:?}", + bbn_stake, + bbn_staking_tx + ); + ensure!( + bbn_stake.staking_value == bbn_staking_tx.staking_value, + "Staking value not match: {:?}, staking tx: {:?}", + bbn_stake, + bbn_staking_tx + ); + ensure!( + bbn_stake.staking_time == bbn_staking_tx.staking_time, + "Staking time not match: {:?}, staking tx: {:?}", + bbn_stake, + bbn_staking_tx + ); + ensure!( + bbn_stake.staker_pub_key == bbn_staking_tx.staker_public_key(), + "Staker public key not match: {:?}, staking tx: {:?}", + bbn_stake, + bbn_staking_tx + ); + ensure!( + bbn_stake.finality_provider_pub_key + == bbn_staking_tx.finality_provider_public_key(), + "Finality provider public key not match: {:?}, staking tx: {:?}", + bbn_stake, + bbn_staking_tx + ); + + let staking_output_index = bbn_stake.staking_output_index; + let outpoint = rooch_types::bitcoin::types::OutPoint::new(txid, staking_output_index); + let utxo_object_id = utxo::derive_utxo_id(&outpoint); + let utxo_obj = self.binding_test.get_object(&utxo_object_id)?; + ensure!( + utxo_obj.is_some(), + "Missing utxo object: {:?} for staking tx: {:?}", + utxo_object_id, + bbn_staking_tx + ); + let utxo_obj = utxo_obj.unwrap(); + let utxo = utxo_obj.value_as::()?; + let seals = utxo.seals.borrow(&MoveString::from( + BBNStakeSeal::type_tag().to_canonical_string(), + )); + ensure!( + seals.is_some(), + "Missing seals in utxo: {:?}, staking tx: {:?}", + utxo, + bbn_staking_tx + ); + let seals = seals.unwrap(); + ensure!( + seals.contains(&stake_object_id), + "Missing seal object id in utxo: {:?}, staking tx: {:?}", + utxo, + bbn_staking_tx + ); + } + Ok(()) + } + pub fn get_inscription(&self, inscription_id: &InscriptionID) -> Result> { let object_id = inscription_id.object_id(); self.binding_test.get_object(&object_id) @@ -410,6 +605,8 @@ pub struct BlockData { pub expect_inscriptions: BTreeSet, pub events_from_ord: Vec, pub events_from_move: Vec, + #[serde(default)] + pub bbn_staking_records: Vec, } #[derive(Debug, Serialize, Deserialize)] @@ -439,7 +636,8 @@ impl BitcoinTesterGenesis { pub struct TesterGenesisBuilder { bitcoin_client: BitcoinClientProxy, - ord_event_dir: PathBuf, + ord_event_dir: Option, + bbn_staking_tx_csv: Option, blocks: Vec, block_txids: HashSet, utxo_store_change: ObjectChange, @@ -448,11 +646,13 @@ pub struct TesterGenesisBuilder { impl TesterGenesisBuilder { pub fn new>( bitcoin_client: BitcoinClientProxy, - ord_event_dir: P, + ord_event_dir: Option

, + bbn_staking_tx_csv: Option

, ) -> Result { Ok(Self { bitcoin_client, - ord_event_dir: ord_event_dir.as_ref().to_path_buf(), + ord_event_dir: ord_event_dir.map(|p| p.as_ref().to_path_buf()), + bbn_staking_tx_csv: bbn_staking_tx_csv.map(|p| p.as_ref().to_path_buf()), blocks: vec![], block_txids: HashSet::new(), utxo_store_change: ObjectChange::meta(BitcoinUTXOStore::genesis_object().metadata), @@ -476,14 +676,34 @@ impl TesterGenesisBuilder { block_header_result.height ); } - let ord_events = rooch_ord::event::load_events( - self.ord_event_dir.join(format!("{}.blk", block_height)), - )?; - info!( - "Load ord events: {} in block {}", - ord_events.len(), - block_height - ); + let ord_events = match &self.ord_event_dir { + None => vec![], + Some(ord_event_dir) => { + let ord_events = rooch_ord::event::load_events( + ord_event_dir.join(format!("{}.blk", block_height)), + )?; + info!( + "Load ord events: {} in block {}", + ord_events.len(), + block_height + ); + ord_events + } + }; + + let bbn_staking_records = match &self.bbn_staking_tx_csv { + None => vec![], + Some(bbn_staking_tx_csv) => { + let bbn_staking_txs = + BBNStakingTxRecord::load_bbn_staking_txs(bbn_staking_tx_csv, block_height)?; + info!( + "Load bbn staking txs: {} in block {}", + bbn_staking_txs.len(), + block_height + ); + bbn_staking_txs + } + }; for tx in &block.txdata { self.block_txids.insert(tx.compute_txid()); @@ -559,6 +779,7 @@ impl TesterGenesisBuilder { expect_inscriptions: BTreeSet::new(), events_from_ord: ord_events, events_from_move: vec![], + bbn_staking_records, }); Ok(self) } diff --git a/crates/rooch-framework-tests/src/lib.rs b/crates/rooch-framework-tests/src/lib.rs index 4f09aa68a..2cdab8f02 100644 --- a/crates/rooch-framework-tests/src/lib.rs +++ b/crates/rooch-framework-tests/src/lib.rs @@ -1,6 +1,7 @@ // Copyright (c) RoochNetwork // SPDX-License-Identifier: Apache-2.0 +mod bbn_tx_loader; pub mod binding_test; pub mod bitcoin_block_tester; #[cfg(test)] diff --git a/crates/rooch-framework-tests/src/main.rs b/crates/rooch-framework-tests/src/main.rs index 4e3f1df40..fb63c1e19 100644 --- a/crates/rooch-framework-tests/src/main.rs +++ b/crates/rooch-framework-tests/src/main.rs @@ -29,7 +29,12 @@ struct TestBuilderOpts { pub btc_rpc_password: String, #[clap(long, id = "ord-events-dir")] - pub ord_events_dir: PathBuf, + pub ord_events_dir: Option, + + /// The csv file of bbn staking tx + /// Export the csv file via https://github.com/babylonlabs-io/staking-indexer + #[clap(long, id = "bbn-staking-tx-csv")] + pub bbn_staking_tx_csv: Option, /// Block heights to execute #[clap(long, id = "blocks")] @@ -50,7 +55,11 @@ async fn main() -> Result<()> { .into_actor(Some("bitcoin_client_for_rpc_service"), &actor_system) .await?; let bitcoin_client_proxy = BitcoinClientProxy::new(bitcoin_client_actor_ref.into()); - let mut builder = TesterGenesisBuilder::new(bitcoin_client_proxy, opts.ord_events_dir)?; + let mut builder = TesterGenesisBuilder::new( + bitcoin_client_proxy, + opts.ord_events_dir, + opts.bbn_staking_tx_csv, + )?; let mut blocks = opts.blocks; blocks.sort(); for block in blocks { diff --git a/crates/rooch-framework-tests/src/tests/bbn_test.rs b/crates/rooch-framework-tests/src/tests/bbn_test.rs index 8614dfccd..36b461111 100644 --- a/crates/rooch-framework-tests/src/tests/bbn_test.rs +++ b/crates/rooch-framework-tests/src/tests/bbn_test.rs @@ -5,11 +5,15 @@ use crate::{ binding_test, bitcoin_block_tester::BitcoinBlockTester, tests::bitcoin_data::bitcoin_tx_from_hex, }; -use moveos_types::{module_binding::MoveFunctionCaller, state_resolver::StateResolver}; -use rooch_types::bitcoin::bbn::{BBNGlobalParams, BBNStakingInfo}; +use moveos_types::{ + module_binding::MoveFunctionCaller, moveos_std::object::DynamicField, state::FieldKey, + state_resolver::StateResolver, +}; +use rooch_types::bitcoin::bbn::{BBNGlobalParamV1, BBNGlobalParams, BBNStakingInfo}; use tracing::{debug, warn}; // Test Babylon v3 transaction +//cargo run -p rooch-framework-tests -- --btc-rpc-url http://localhost:8332 --btc-rpc-username your_username --btc-rpc-password your_pwd --blocks 864790 --bbn-staking-tx-csv /path/to/bbn_staking_tx.csv #[tokio::test] async fn test_block_864790() { let _ = tracing_subscriber::fmt::try_init(); @@ -21,8 +25,10 @@ async fn test_block_864790() { let mut tester = BitcoinBlockTester::new(864790).unwrap(); tester.execute().unwrap(); + tester.execute_bbn_process().unwrap(); + tester.verify_utxo().unwrap(); - //TODO verify bbn tx + tester.verify_bbn_stake().unwrap(); } #[tokio::test] @@ -43,13 +49,19 @@ async fn test_bbn_tx() { let op_return_output = op_return_output_opt.unwrap(); debug!("op_return_output: {:?}", op_return_output); assert_eq!(op_return_output.op_return_output_idx, 1); - let bbn_global_params = binding_test - .get_object(&BBNGlobalParams::object_id()) + + let field_opt = binding_test + .get_field( + &BBNGlobalParams::object_id(), + &FieldKey::derive(&1u64).unwrap(), + ) + .unwrap(); + assert!(field_opt.is_some()); + let bbn_global_param = field_opt .unwrap() + .value_as::>() .unwrap() - .value_as::() - .unwrap(); - let bbn_global_param = bbn_global_params.get_global_param(1).unwrap(); + .value; let staking_info = BBNStakingInfo::build_staking_info( &op_return_output.op_return_data.staker_pub_key().unwrap(), &[op_return_output diff --git a/crates/rooch-framework-tests/src/tests/bitcoin_tester_test.rs b/crates/rooch-framework-tests/src/tests/bitcoin_tester_test.rs index 04cf1f30c..8e32ec36d 100644 --- a/crates/rooch-framework-tests/src/tests/bitcoin_tester_test.rs +++ b/crates/rooch-framework-tests/src/tests/bitcoin_tester_test.rs @@ -7,6 +7,7 @@ use std::str::FromStr; use tracing::{debug, warn}; // This test for testing BitcoinBlockTester +#[ignore = "the tester genesis need to be updated"] #[tokio::test] async fn test_block_100000() { let _ = tracing_subscriber::fmt::try_init(); @@ -19,11 +20,12 @@ async fn test_block_100000() { // Some testcase in the issue // https://github.com/rooch-network/rooch/issues/1985 -// cargo run -p rooch-framework-tests -- --btc-rpc-url http://localhost:9332 --btc-rpc-username your_username --btc-rpc-password your_pwd --blocks 790964 --blocks 855396 +// cargo run -p rooch-framework-tests -- --btc-rpc-url http://localhost:8332 --btc-rpc-username your_username --btc-rpc-password your_pwd --blocks 790964 --blocks 855396 // This test contains two block: 790964 and 855396 // The inscription 8706753 inscribed in block 790964 and spend as fee in block 855396 // https://ordiscan.com/inscription/8706753 // https://ordinals.com/inscription/8706753 +#[ignore = "the tester genesis need to be updated"] #[tokio::test] async fn test_block_790964() { let _ = tracing_subscriber::fmt::try_init(); @@ -72,6 +74,7 @@ async fn test_block_790964() { ); } +#[ignore = "the tester genesis need to be updated"] #[tokio::test] async fn test_block_781735() { let _ = tracing_subscriber::fmt::try_init(); @@ -104,6 +107,7 @@ async fn test_block_781735() { //Inscription use pointer to set the offset, and mint multi inscription in one input. //https://ordinals.com/tx/6ea3bf728b34c8c01ba4703e00ad688be100599b92fbdac71e6aea6ad8355552 +#[ignore = "the tester genesis need to be updated"] #[tokio::test] async fn test_block_832918() { let _ = tracing_subscriber::fmt::try_init(); @@ -121,6 +125,7 @@ async fn test_block_832918() { // Inscription inscribe and transfer in same tx // https://ordinals.com/tx/207322afdcca902cb36aeb674214dc5f80f9593f12c1de57830ad33adae46a0a +#[ignore = "the tester genesis need to be updated"] #[tokio::test] async fn test_block_794970() { let _ = tracing_subscriber::fmt::try_init(); diff --git a/crates/rooch-framework-tests/tester/864790.tester.genesis b/crates/rooch-framework-tests/tester/864790.tester.genesis index b750dd0c9..435ed368e 100644 Binary files a/crates/rooch-framework-tests/tester/864790.tester.genesis and b/crates/rooch-framework-tests/tester/864790.tester.genesis differ diff --git a/crates/rooch-types/src/bitcoin/bbn.rs b/crates/rooch-types/src/bitcoin/bbn.rs index b0c9b7aab..f58f5faeb 100644 --- a/crates/rooch-types/src/bitcoin/bbn.rs +++ b/crates/rooch-types/src/bitcoin/bbn.rs @@ -30,6 +30,7 @@ use moveos_types::{ }; use once_cell::sync::Lazy; use serde::{Deserialize, Serialize}; +use std::fmt; use std::str::FromStr; pub const MODULE_NAME: &IdentStr = ident_str!("bbn"); @@ -65,10 +66,9 @@ pub const V0_OP_RETURN_DATA_SIZE: usize = 71; // "min_staking_time": 64000, // "confirmation_depth": 10 // } -pub static BBN_GLOBAL_PARAM_BBN1: Lazy = Lazy::new(|| BBNGlobalParam { +pub static BBN_GLOBAL_PARAM_BBN1: Lazy = Lazy::new(|| BBNGlobalParamV1 { version: 1, activation_height: 864790, - staking_cap: 0, cap_height: 864799, tag: hex::decode("62626e31").unwrap(), covenant_pks: vec![ @@ -94,7 +94,7 @@ pub static BBN_GLOBAL_PARAM_BBN1: Lazy = Lazy::new(|| BBNGlobalP #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BBNGlobalParams { - pub bbn_global_param: Vec, + pub max_version: u64, } impl MoveStructType for BBNGlobalParams { @@ -105,29 +105,20 @@ impl MoveStructType for BBNGlobalParams { impl MoveStructState for BBNGlobalParams { fn struct_layout() -> MoveStructLayout { - MoveStructLayout::new(vec![MoveTypeLayout::Vector(Box::new( - BBNGlobalParam::type_layout(), - ))]) + MoveStructLayout::new(vec![MoveTypeLayout::U64]) } } impl BBNGlobalParams { - pub fn get_global_param(&self, version: u64) -> Option<&BBNGlobalParam> { - self.bbn_global_param - .iter() - .find(|param| param.version == version) - } - pub fn object_id() -> ObjectID { object::named_object_id(&Self::struct_tag()) } } #[derive(Debug, Clone, Serialize, Deserialize)] -pub struct BBNGlobalParam { +pub struct BBNGlobalParamV1 { pub version: u64, pub activation_height: u64, - pub staking_cap: u64, pub cap_height: u64, pub tag: Vec, pub covenant_pks: Vec>, @@ -141,13 +132,13 @@ pub struct BBNGlobalParam { pub confirmation_depth: u16, } -impl MoveStructType for BBNGlobalParam { +impl MoveStructType for BBNGlobalParamV1 { const MODULE_NAME: &'static IdentStr = MODULE_NAME; - const STRUCT_NAME: &'static IdentStr = ident_str!("BBNGlobalParam"); + const STRUCT_NAME: &'static IdentStr = ident_str!("BBNGlobalParamV1"); const ADDRESS: AccountAddress = BITCOIN_MOVE_ADDRESS; } -impl MoveStructState for BBNGlobalParam { +impl MoveStructState for BBNGlobalParamV1 { fn struct_layout() -> MoveStructLayout { MoveStructLayout::new(vec![ MoveTypeLayout::U64, @@ -170,7 +161,7 @@ impl MoveStructState for BBNGlobalParam { } } -impl BBNGlobalParam { +impl BBNGlobalParamV1 { pub fn get_covenant_pks(&self) -> Vec { self.covenant_pks .iter() @@ -186,14 +177,14 @@ pub struct BBNStakeSeal { /// The stake transaction hash pub txid: AccountAddress, /// The stake utxo output index - pub vout: u32, + pub staking_output_index: u32, pub tag: Vec, pub staker_pub_key: Vec, pub finality_provider_pub_key: Vec, /// The stake time in block count pub staking_time: u16, - /// The stake amount in satoshi - pub staking_amount: u64, + /// The stake value amount in satoshi + pub staking_value: u64, } impl MoveStructType for BBNStakeSeal { @@ -217,7 +208,7 @@ impl MoveStructState for BBNStakeSeal { } } -#[derive(Debug, Clone, Serialize, Deserialize)] +#[derive(Clone, Serialize, Deserialize)] pub struct BBNV0OpReturnData { pub tag: Vec, pub version: u8, @@ -226,6 +217,21 @@ pub struct BBNV0OpReturnData { pub staking_time: u16, } +impl fmt::Debug for BBNV0OpReturnData { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("BBNV0OpReturnData") + .field("tag", &hex::encode(&self.tag)) + .field("version", &self.version) + .field("staker_pub_key", &hex::encode(&self.staker_pub_key)) + .field( + "finality_provider_pub_key", + &hex::encode(&self.finality_provider_pub_key), + ) + .field("staking_time", &self.staking_time) + .finish() + } +} + impl MoveStructType for BBNV0OpReturnData { const MODULE_NAME: &'static IdentStr = MODULE_NAME; const STRUCT_NAME: &'static IdentStr = ident_str!("BBNV0OpReturnData"); @@ -276,6 +282,53 @@ impl MoveStructState for BBNV0OpReturnOutput { } } +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct BBNStakingEvent { + pub block_height: u64, + pub txid: AccountAddress, + /// BBNStakeSeal object id + pub stake_object_id: ObjectID, +} + +impl MoveStructType for BBNStakingEvent { + const MODULE_NAME: &'static IdentStr = MODULE_NAME; + const STRUCT_NAME: &'static IdentStr = ident_str!("BBNStakingEvent"); + const ADDRESS: AccountAddress = BITCOIN_MOVE_ADDRESS; +} + +impl MoveStructState for BBNStakingEvent { + fn struct_layout() -> MoveStructLayout { + MoveStructLayout::new(vec![ + MoveTypeLayout::U64, + MoveTypeLayout::Address, + ObjectID::type_layout(), + ]) + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct BBNStakingFailedEvent { + pub block_height: u64, + pub txid: AccountAddress, + pub error: String, +} + +impl MoveStructType for BBNStakingFailedEvent { + const MODULE_NAME: &'static IdentStr = MODULE_NAME; + const STRUCT_NAME: &'static IdentStr = ident_str!("BBNStakingFailedEvent"); + const ADDRESS: AccountAddress = BITCOIN_MOVE_ADDRESS; +} + +impl MoveStructState for BBNStakingFailedEvent { + fn struct_layout() -> MoveStructLayout { + MoveStructLayout::new(vec![ + MoveTypeLayout::U64, + MoveTypeLayout::Address, + MoveTypeLayout::Vector(Box::new(MoveTypeLayout::U8)), + ]) + } +} + /// Rust bindings for BitcoinMove bitcoin module pub struct BBNModule<'a> { caller: &'a dyn MoveFunctionCaller, @@ -362,7 +415,7 @@ impl<'a> BBNModule<'a> { Ok(is_bbn_tx) } - pub fn create_process_bbn_tx_entry_call(&self, txid: Txid) -> Result { + pub fn create_process_bbn_tx_entry_call(txid: Txid) -> Result { Ok(Self::create_function_call( Self::PROCESS_BBN_TX_ENTRY_FUNCTION_NAME, vec![], @@ -395,6 +448,7 @@ const UNSPENDABLE_KEY_PATH: &str = static UNSPENDABLE_KEY_PATH_KEY: Lazy = Lazy::new(|| XOnlyPublicKey::from(PublicKey::from_str(UNSPENDABLE_KEY_PATH).unwrap())); +#[derive(Debug, Clone)] pub struct BBNParsedV0StakingTx { pub staking_output: TxOut, pub staking_output_idx: u32, @@ -773,7 +827,7 @@ fn parse_bbn_op_return_data(script: &Script) -> Result { }) } -fn try_get_bbn_op_return_ouput(outputs: &[TxOut]) -> Option { +pub fn try_get_bbn_op_return_ouput(outputs: &[TxOut]) -> Option { let mut result: Option = None; for (vout, output) in outputs.iter().enumerate() { if output.script_pubkey.is_op_return() { @@ -997,4 +1051,20 @@ mod tests { Amount::from_sat(30000400000) ); } + + //https://github.com/babylonlabs-io/staking-indexer/issues/26 + #[test] + fn test_parse_tx2() { + //https://mempool.space/tx/2aeeddb97b138ea622d9194818fa2fa3d8432125032ac1aec32461ae91d80b78 + let tx: Transaction = deserialize(&hex::decode("02000000000101a9f4558e50f0dcac3a624e806f38822bb5b83b02de946c2c2d5dac9b07843b99000000000046ffffff0284344c0000000000225120db09240cf52111e39179e50f5cf6c910a5478659ef94c29d668ebb9f469475450000000000000000496a4762626e3100d3d09d91bab234a9d21bf3c98092e82aec525caf67566edace08918408819689b3a838cbf2e61f2ecadf9f5924710e66dcf8212545884853073fe62c5ff5b949fa00014061a5eada8df8f5f3ce00f4389682530d268917f71631ad412a3d7c651342739033a868d4be039bb4dd0bc7c7ef5dada8c6a47171b07532a416fe2478be34303100000000").unwrap()).unwrap(); + let params = BBN_GLOBAL_PARAM_BBN1.clone(); + let expected_tag = ¶ms.tag; + let covenant_keys = params.get_covenant_pks(); + let covenant_quorum = params.covenant_quorum; + let _parsed_staking_tx = + BBNParsedV0StakingTx::parse_from_tx(&tx, expected_tag, &covenant_keys, covenant_quorum) + .unwrap(); + // println!("tx lock time: {}", tx.lock_time); + // println!("parsed_staking_tx: {:?}", parsed_staking_tx); + } } diff --git a/crates/rooch-types/src/framework/auth_payload.rs b/crates/rooch-types/src/framework/auth_payload.rs index 52cfb282b..bcd9c43c2 100644 --- a/crates/rooch-types/src/framework/auth_payload.rs +++ b/crates/rooch-types/src/framework/auth_payload.rs @@ -224,7 +224,7 @@ pub struct MultisignAuthPayload { impl MultisignAuthPayload { pub fn build_multisig_payload(mut payloads: Vec) -> Result { - ensure!(payloads.len() > 1, "At least two signatures are required"); + ensure!(!payloads.is_empty(), "At least one signatures are required"); let first_payload = payloads.remove(0); let message_prefix = first_payload.message_prefix.clone(); let message_info = first_payload.message_info.clone(); diff --git a/frameworks/bitcoin-move/doc/bbn.md b/frameworks/bitcoin-move/doc/bbn.md index be4be2ec0..806dad7b0 100644 --- a/frameworks/bitcoin-move/doc/bbn.md +++ b/frameworks/bitcoin-move/doc/bbn.md @@ -5,12 +5,15 @@ -- [Struct `BBNGlobalParam`](#0x4_bbn_BBNGlobalParam) +- [Struct `BBNGlobalParamV0`](#0x4_bbn_BBNGlobalParamV0) +- [Struct `BBNGlobalParamV1`](#0x4_bbn_BBNGlobalParamV1) - [Resource `BBNGlobalParams`](#0x4_bbn_BBNGlobalParams) - [Struct `BBNOpReturnOutput`](#0x4_bbn_BBNOpReturnOutput) - [Struct `BBNV0OpReturnData`](#0x4_bbn_BBNV0OpReturnData) - [Resource `BBNStakeSeal`](#0x4_bbn_BBNStakeSeal) - [Struct `BBNScriptPaths`](#0x4_bbn_BBNScriptPaths) +- [Struct `BBNStakingEvent`](#0x4_bbn_BBNStakingEvent) +- [Struct `BBNStakingFailedEvent`](#0x4_bbn_BBNStakingFailedEvent) - [Constants](#@Constants_0) - [Function `genesis_init`](#0x4_bbn_genesis_init) - [Function `init_for_upgrade`](#0x4_bbn_init_for_upgrade) @@ -23,13 +26,13 @@ - [Function `remove_temp_state`](#0x4_bbn_remove_temp_state) - [Function `block_height`](#0x4_bbn_block_height) - [Function `txid`](#0x4_bbn_txid) -- [Function `vout`](#0x4_bbn_vout) +- [Function `staking_output_index`](#0x4_bbn_staking_output_index) - [Function `outpoint`](#0x4_bbn_outpoint) - [Function `tag`](#0x4_bbn_tag) - [Function `staker_pub_key`](#0x4_bbn_staker_pub_key) - [Function `finality_provider_pub_key`](#0x4_bbn_finality_provider_pub_key) - [Function `staking_time`](#0x4_bbn_staking_time) -- [Function `staking_amount`](#0x4_bbn_staking_amount) +- [Function `staking_value`](#0x4_bbn_staking_value) - [Function `is_expired`](#0x4_bbn_is_expired) @@ -37,6 +40,7 @@ use 0x1::string; use 0x1::vector; use 0x2::bcs; +use 0x2::event; use 0x2::object; use 0x2::result; use 0x2::sort; @@ -53,13 +57,24 @@ - + -## Struct `BBNGlobalParam` +## Struct `BBNGlobalParamV0` -

struct BBNGlobalParam has copy, drop, store
+
struct BBNGlobalParamV0 has copy, drop, store
+

+
+
+
+
+
+## Struct `BBNGlobalParamV1`
+
+
+
+
struct BBNGlobalParamV1 has copy, drop, store
 

 
 
@@ -119,6 +134,28 @@
 
 
 
+
+
+## Struct `BBNStakingEvent`
+
+
+
+
struct BBNStakingEvent has copy, drop, store
+

+
+
+
+
+
+## Struct `BBNStakingFailedEvent`
+
+
+
+
struct BBNStakingFailedEvent has copy, drop, store
+

+
+
+
 
 
 ## Constants
@@ -232,6 +269,15 @@
 
 
 
+
+
+
+
+
const ErrorOutBlockRange: u64 = 15;
+

+
+
+
 
 
 
@@ -294,6 +340,8 @@
 
 ## Function `is_possible_bbn_tx`
 
+Check if the transaction is a possible Babylon transaction
+If the transaction contains an OP_RETURN output with the correct tag, it is considered a possible Babylon transaction
 
 
 
public fun is_possible_bbn_tx(txid: address): bool
@@ -392,13 +440,13 @@
 
 
 
-
+
 
-## Function `vout`
+## Function `staking_output_index`
 
 
 
-
public fun vout(stake: &bbn::BBNStakeSeal): u32
+
public fun staking_output_index(stake: &bbn::BBNStakeSeal): u32
 

 
 
@@ -458,13 +506,13 @@
 
 
 
-
+
 
-## Function `staking_amount`
+## Function `staking_value`
 
 
 
-
public fun staking_amount(stake: &bbn::BBNStakeSeal): u64
+
public fun staking_value(stake: &bbn::BBNStakeSeal): u64
 

 
 
diff --git a/frameworks/bitcoin-move/sources/bbn.move b/frameworks/bitcoin-move/sources/bbn.move
index 21ab3889c..db6da82f2 100644
--- a/frameworks/bitcoin-move/sources/bbn.move
+++ b/frameworks/bitcoin-move/sources/bbn.move
@@ -7,11 +7,13 @@ module bitcoin_move::bbn {
     use std::option::{Option, is_none, is_some, none, some};
     use std::vector;
     use std::vector::{length, borrow};
-    use moveos_std::object::{Self, Object};
+    use std::string::String;
+    use moveos_std::object::{Self, Object, ObjectID};
     use moveos_std::type_info;
     use moveos_std::bcs;
-    use moveos_std::result;
+    use moveos_std::result::{Self, Result, err_str, ok, is_err, as_err};
     use moveos_std::sort;
+    use moveos_std::event;
     use bitcoin_move::bitcoin;
     use bitcoin_move::types;
     use bitcoin_move::utxo;
@@ -20,7 +22,6 @@ module bitcoin_move::bbn {
     use bitcoin_move::types::{
         Transaction,
         txout_value,
-        tx_lock_time,
         txout_script_pubkey,
         TxOut
     };
@@ -51,12 +52,28 @@ module bitcoin_move::bbn {
     const ErrorFailedToFinalizeTaproot: u64 = 12;
     const ErrorUTXOAlreadySealed: u64 = 13;
     const ErrorNoBabylonStakingOutput: u64 = 14;
+    const ErrorOutBlockRange: u64 = 15;
 
     //https://github.com/babylonlabs-io/networks/blob/28651b301bb2efa0542b2268793948bcda472a56/parameters/parser/ParamsParser.go#L117
-    struct BBNGlobalParam has copy, drop, store {
+    struct BBNGlobalParamV0 has copy, drop, store {
         version: u64,
         activation_height: u64,
         staking_cap: u64,
+        tag: vector,
+        covenant_pks: vector>,
+        covenant_quorum: u32,
+        unbonding_time: u16,
+        unbonding_fee: u64,
+        max_staking_amount: u64,
+        min_staking_amount: u64,
+        min_staking_time: u16,
+        max_staking_time: u16,
+        confirmation_depth: u16
+    }
+
+    struct BBNGlobalParamV1 has copy, drop, store {
+        version: u64,
+        activation_height: u64,
         cap_height: u64,
         tag: vector,
         covenant_pks: vector>,
@@ -71,7 +88,7 @@ module bitcoin_move::bbn {
     }
 
     struct BBNGlobalParams has key {
-        bbn_global_param: vector
+        max_version: u64,
     }
 
     struct BBNOpReturnOutput has copy, store, drop {
@@ -93,14 +110,14 @@ module bitcoin_move::bbn {
         /// The stake transaction hash
         txid: address,
         /// The stake utxo output index
-        vout: u32,
+        staking_output_index: u32,
         tag: vector,
         staker_pub_key: vector,
         finality_provider_pub_key: vector,
         /// The stake time in block count
         staking_time: u16,
         /// The stake amount in satoshi
-        staking_amount: u64,
+        staking_value: u64,
     }
 
     struct BBNScriptPaths has store, copy, drop {
@@ -109,38 +126,107 @@ module bitcoin_move::bbn {
         slashing_path_script: ScriptBuf,
     }
 
+    struct BBNStakingEvent has store, copy, drop{
+        block_height: u64,
+        txid: address,
+        /// BBNStakeSeal object id
+        stake_object_id: ObjectID,
+    }
+
+    struct BBNStakingFailedEvent has store, copy, drop{
+        block_height: u64,
+        txid: address,
+        error: String,
+    }
+
     //https://github.com/babylonlabs-io/networks/blob/main/bbn-1/parameters/global-params.json
     // {
-    //     "version": 1,
-    //     "activation_height": 864790,
-    //     "cap_height": 864799,
-    //     "tag": "62626e31",
-    //     "covenant_pks": [
-    //         "03d45c70d28f169e1f0c7f4a78e2bc73497afe585b70aa897955989068f3350aaa",
-    //         "034b15848e495a3a62283daaadb3f458a00859fe48e321f0121ebabbdd6698f9fa",
-    //         "0223b29f89b45f4af41588dcaf0ca572ada32872a88224f311373917f1b37d08d1",
-    //         "02d3c79b99ac4d265c2f97ac11e3232c07a598b020cf56c6f055472c893c0967ae",
-    //         "038242640732773249312c47ca7bdb50ca79f15f2ecc32b9c83ceebba44fb74df7",
-    //         "03e36200aaa8dce9453567bba108bdc51f7f1174b97a65e4dc4402fc5de779d41c",
-    //         "03cbdd028cfe32c1c1f2d84bfec71e19f92df509bba7b8ad31ca6c1a134fe09204",
-    //         "03f178fcce82f95c524b53b077e6180bd2d779a9057fdff4255a0af95af918cee0",
-    //         "03de13fc96ea6899acbdc5db3afaa683f62fe35b60ff6eb723dad28a11d2b12f8c"
-    //     ],
-    //     "covenant_quorum": 6,
-    //     "unbonding_time": 1008,
-    //     "unbonding_fee": 32000,
-    //     "max_staking_amount": 50000000000,
-    //     "min_staking_amount": 500000,
-    //     "max_staking_time": 64000,
-    //     "min_staking_time": 64000,
-    //     "confirmation_depth": 10
+    //     "versions": [
+    //         {
+    //             "version": 0,
+    //             "activation_height": 857910,
+    //             "staking_cap": 100000000000,
+    //             "tag": "62626e31",
+    //             "covenant_pks": [
+    //                 "03d45c70d28f169e1f0c7f4a78e2bc73497afe585b70aa897955989068f3350aaa",
+    //                 "034b15848e495a3a62283daaadb3f458a00859fe48e321f0121ebabbdd6698f9fa",
+    //                 "0223b29f89b45f4af41588dcaf0ca572ada32872a88224f311373917f1b37d08d1",
+    //                 "02d3c79b99ac4d265c2f97ac11e3232c07a598b020cf56c6f055472c893c0967ae",
+    //                 "038242640732773249312c47ca7bdb50ca79f15f2ecc32b9c83ceebba44fb74df7",
+    //                 "03e36200aaa8dce9453567bba108bdc51f7f1174b97a65e4dc4402fc5de779d41c",
+    //                 "03cbdd028cfe32c1c1f2d84bfec71e19f92df509bba7b8ad31ca6c1a134fe09204",
+    //                 "03f178fcce82f95c524b53b077e6180bd2d779a9057fdff4255a0af95af918cee0",
+    //                 "03de13fc96ea6899acbdc5db3afaa683f62fe35b60ff6eb723dad28a11d2b12f8c"
+    //             ],
+    //             "covenant_quorum": 6,
+    //             "unbonding_time": 1008,
+    //             "unbonding_fee": 64000,
+    //             "max_staking_amount": 5000000,
+    //             "min_staking_amount": 500000,
+    //             "max_staking_time": 64000,
+    //             "min_staking_time": 64000,
+    //             "confirmation_depth": 10
+    //         },
+    //         {
+    //             "version": 1,
+    //             "activation_height": 864790,
+    //             "cap_height": 864799,
+    //             "tag": "62626e31",
+    //             "covenant_pks": [
+    //                 "03d45c70d28f169e1f0c7f4a78e2bc73497afe585b70aa897955989068f3350aaa",
+    //                 "034b15848e495a3a62283daaadb3f458a00859fe48e321f0121ebabbdd6698f9fa",
+    //                 "0223b29f89b45f4af41588dcaf0ca572ada32872a88224f311373917f1b37d08d1",
+    //                 "02d3c79b99ac4d265c2f97ac11e3232c07a598b020cf56c6f055472c893c0967ae",
+    //                 "038242640732773249312c47ca7bdb50ca79f15f2ecc32b9c83ceebba44fb74df7",
+    //                 "03e36200aaa8dce9453567bba108bdc51f7f1174b97a65e4dc4402fc5de779d41c",
+    //                 "03cbdd028cfe32c1c1f2d84bfec71e19f92df509bba7b8ad31ca6c1a134fe09204",
+    //                 "03f178fcce82f95c524b53b077e6180bd2d779a9057fdff4255a0af95af918cee0",
+    //                 "03de13fc96ea6899acbdc5db3afaa683f62fe35b60ff6eb723dad28a11d2b12f8c"
+    //             ],
+    //             "covenant_quorum": 6,
+    //             "unbonding_time": 1008,
+    //             "unbonding_fee": 32000,
+    //             "max_staking_amount": 50000000000,
+    //             "min_staking_amount": 500000,
+    //             "max_staking_time": 64000,
+    //             "min_staking_time": 64000,
+    //             "confirmation_depth": 10
+    //         }
+    //     ]
     // }
     public(friend) fun genesis_init() {
+        //bbn-1 version 0
+        let bbn_global_param_0 = BBNGlobalParamV0 {
+            version: 0,
+            activation_height: 857910,
+            staking_cap: 100000000000,
+            //bbn1
+            tag: x"62626e31",
+            //we keep the x-only pubkey in the vector
+            covenant_pks: vector[
+                x"03d45c70d28f169e1f0c7f4a78e2bc73497afe585b70aa897955989068f3350aaa",
+                x"034b15848e495a3a62283daaadb3f458a00859fe48e321f0121ebabbdd6698f9fa",
+                x"0223b29f89b45f4af41588dcaf0ca572ada32872a88224f311373917f1b37d08d1",
+                x"02d3c79b99ac4d265c2f97ac11e3232c07a598b020cf56c6f055472c893c0967ae",
+                x"038242640732773249312c47ca7bdb50ca79f15f2ecc32b9c83ceebba44fb74df7",
+                x"03e36200aaa8dce9453567bba108bdc51f7f1174b97a65e4dc4402fc5de779d41c",
+                x"03cbdd028cfe32c1c1f2d84bfec71e19f92df509bba7b8ad31ca6c1a134fe09204",
+                x"03f178fcce82f95c524b53b077e6180bd2d779a9057fdff4255a0af95af918cee0",
+                x"03de13fc96ea6899acbdc5db3afaa683f62fe35b60ff6eb723dad28a11d2b12f8c"
+            ],
+            covenant_quorum: 6,
+            unbonding_time: 1008,
+            unbonding_fee: 64000,
+            max_staking_amount: 5000000,
+            min_staking_amount: 500000,
+            min_staking_time: 64000,
+            max_staking_time: 64000,
+            confirmation_depth: 10
+        };
         // bbn-1 version 1
-        let bbn_global_params_1 = BBNGlobalParam {
+        let bbn_global_params_1 = BBNGlobalParamV1 {
             version: 1,
             activation_height: 864790,
-            staking_cap: 0,
             cap_height: 864799,
             //bbn1
             tag: x"62626e31",
@@ -166,9 +252,11 @@ module bitcoin_move::bbn {
             confirmation_depth: 10
         };
         let obj =
-            object::new_named_object(
-                BBNGlobalParams { bbn_global_param: vector[bbn_global_params_1] }
-            );
+            object::new_named_object(BBNGlobalParams {
+                max_version: 1,
+        });
+        object::add_field(&mut obj, 0, bbn_global_param_0);
+        object::add_field(&mut obj, 1, bbn_global_params_1);
         object::to_shared(obj);
     }
 
@@ -179,38 +267,25 @@ module bitcoin_move::bbn {
     }
 
     fun new_bbn_stake_seal(
-        block_height: u64, txid: address, vout: u32, tag: vector, staker_pub_key: vector,
-        finality_provider_pub_key: vector, staking_time: u16, staking_amount: u64
+        block_height: u64, txid: address, staking_output_index: u32, tag: vector, staker_pub_key: vector,
+        finality_provider_pub_key: vector, staking_time: u16, staking_value: u64
     ): Object {
         object::new(BBNStakeSeal {
-            block_height: block_height,
-            txid: txid,
-            vout: vout,
-            tag: tag,
-            staker_pub_key: staker_pub_key,
-            finality_provider_pub_key: finality_provider_pub_key,
-            staking_time: staking_time,
-            staking_amount: staking_amount
+            block_height,
+            txid,
+            staking_output_index,
+            tag,
+            staker_pub_key,
+            finality_provider_pub_key,
+            staking_time,
+            staking_value
         })
     }
 
-    fun get_bbn_param(block_height: u64): Option {
+    fun get_bbn_param_v1(): &BBNGlobalParamV1 {
         let object_id = object::named_object_id();
-        let params = object::borrow(object::borrow_object(object_id));
-        let i = 0;
-        let len = length(¶ms.bbn_global_param);
-        while (i < len) {
-            let param = borrow(¶ms.bbn_global_param, i);
-            i = i + 1;
-            if (param.cap_height !=0 && block_height > param.cap_height) {
-                continue
-            };
-            if (block_height < param.activation_height) {
-                continue
-            };
-            return some(*param)
-        };
-        none()
+        let param_obj = object::borrow_object(object_id);
+        object::borrow_field(param_obj, 1)
     }
 
     fun try_get_bbn_op_return_ouput(tx_output: &vector): Option {
@@ -273,17 +348,21 @@ module bitcoin_move::bbn {
         try_get_bbn_staking_output(types::tx_output(&tx), &script_buf::new(staking_output_pk_script))
     }
 
+    /// Check if the transaction is a possible Babylon transaction
+    /// If the transaction contains an OP_RETURN output with the correct tag, it is considered a possible Babylon transaction
     public fun is_possible_bbn_tx(txid: address): bool {
         let block_height_opt = bitcoin::get_tx_height(txid);
         if (is_none(&block_height_opt)) {
             return false
         };
         let block_height = option::destroy_some(block_height_opt);
-        let param_opt = get_bbn_param(block_height);
-        if (is_none(¶m_opt)) {
+        let param = get_bbn_param_v1();
+        if (block_height < param.activation_height) {
+            return false
+        };
+        if (block_height > param.cap_height) {
             return false
         };
-        let param = option::destroy_some(param_opt);
         let tx_opt = bitcoin::get_tx(txid);
         if (is_none(&tx_opt)) {
             return false
@@ -295,28 +374,28 @@ module bitcoin_move::bbn {
             return false
         };
         let output = option::destroy_some(output_opt);
-        validate_bbn_op_return_data(¶m, &tx, &output.op_return_data)
+        if (output.op_return_data.tag != param.tag) {
+            return false
+        };
+        true 
     }
 
     public entry fun process_bbn_tx_entry(txid: address){
         process_bbn_tx(txid)
     }
 
-    fun validate_bbn_op_return_data(param: &BBNGlobalParam, tx: &Transaction, op_return_data: &BBNV0OpReturnData): bool {
+    fun validate_bbn_op_return_data(param: &BBNGlobalParamV1, op_return_data: &BBNV0OpReturnData): Result {
+        if (op_return_data.version != 0) {
+            return err_str(b"Invalid version")
+        };
         if (op_return_data.tag != param.tag) {
-            return false
+            return err_str(b"Invalid tag")
         };
         if (op_return_data.staking_time < param.min_staking_time
             || op_return_data.staking_time > param.max_staking_time) {
-            return false
-        };
-        if (!vector::contains(¶m.covenant_pks, &op_return_data.finality_provider_pub_key)) {
-            return false
-        };
-        if (tx_lock_time(tx) < (op_return_data.staking_time as u32)) {
-            return false
+            return err_str(b"Invalid staking time")
         };
-        true
+        ok(true)
     }
 
     fun process_bbn_tx(txid: address) {
@@ -324,9 +403,8 @@ module bitcoin_move::bbn {
         assert!(is_some(&block_height_opt), ErrorTransactionNotFound);
         let block_height = option::destroy_some(block_height_opt);
 
-        let param_opt = get_bbn_param(block_height);
-        assert!(is_some(¶m_opt), ErrorNotBabylonTx);
-        let param = option::destroy_some(param_opt);
+        let param = get_bbn_param_v1();
+        assert!(block_height >= param.activation_height && block_height <= param.cap_height, ErrorOutBlockRange);
 
         let tx_opt = bitcoin::get_tx(txid);
         assert!(is_some(&tx_opt), ErrorTransactionNotFound);
@@ -335,27 +413,59 @@ module bitcoin_move::bbn {
         let tx_output = types::tx_output(&tx);
 
         let op_return_output_opt = try_get_bbn_op_return_ouput(tx_output);
-        assert!(is_some(&op_return_output_opt), ErrorNoBabylonOpReturn);
+        assert!(is_some(&op_return_output_opt), ErrorNotBabylonTx);
         let op_return_output = option::destroy_some(op_return_output_opt);
         
-        let BBNOpReturnOutput{op_return_output_idx: _, op_return_data} = op_return_output;
+        let process_result = process_parsed_bbn_tx(param, txid, block_height, &tx, op_return_output);
+        if (is_err(&process_result)) {
+            let error = result::unwrap_err(process_result);
+            let event = BBNStakingFailedEvent {
+                block_height,
+                txid,
+                error
+            };
+            event::emit(event);
+        }else{
+            let stake_object_id = result::unwrap(process_result);
+            let event = BBNStakingEvent {
+                block_height,
+                txid,
+                stake_object_id
+            };
+            event::emit(event);
+        }
+    }
 
-        let valid = validate_bbn_op_return_data(¶m, &tx, &op_return_data);
+    fun process_parsed_bbn_tx(param: &BBNGlobalParamV1, txid: address, block_height: u64, tx: &Transaction, op_return_output: BBNOpReturnOutput): Result {
         
-        assert!(valid, ErrorInvalidBabylonOpReturn);
+        let BBNOpReturnOutput{op_return_output_idx: _, op_return_data} = op_return_output;
+        let valid_result = validate_bbn_op_return_data(param, &op_return_data);
+        
+        if (is_err(&valid_result)) {
+            return as_err(valid_result)
+        };
 
         let staking_output_pk_script = build_staking_tx_output_script_pubkey(
             op_return_data.staker_pub_key, vector::singleton(op_return_data.finality_provider_pub_key), param.covenant_pks, param.covenant_quorum, op_return_data.staking_time
         );
 
+        let tx_output = types::tx_output(tx);
         let staking_output_opt = try_get_bbn_staking_output(tx_output, &staking_output_pk_script);
-        assert!(is_some(&staking_output_opt), ErrorNoBabylonStakingOutput);
+        if (is_none(&staking_output_opt)) {
+            return err_str(b"Staking output not found")
+        };
+    
         let staking_output_idx = option::destroy_some(staking_output_opt);
         let staking_output = borrow(tx_output, (staking_output_idx as u64));
 
         let seal_protocol = type_info::type_name();
 
         let txout_value = txout_value(staking_output);
+
+        if(txout_value < param.min_staking_amount || txout_value > param.max_staking_amount){
+            return err_str(b"Invalid staking amount")
+        };
+
         let out_point = types::new_outpoint(txid, staking_output_idx);
         let utxo_obj = utxo::borrow_mut_utxo(out_point);
         let utxo = object::borrow_mut(utxo_obj);
@@ -373,6 +483,8 @@ module bitcoin_move::bbn {
         
         let seal = utxo::new_utxo_seal(seal_protocol, seal_object_id);
         utxo::add_seal_internal(utxo, seal);
+
+        return ok(seal_object_id)
     }
 
     fun pubkey_to_rooch_address(pubkey: &vector): address {
@@ -460,12 +572,12 @@ module bitcoin_move::bbn {
         stake.txid
     }
 
-    public fun vout(stake: &BBNStakeSeal): u32 {
-        stake.vout
+    public fun staking_output_index(stake: &BBNStakeSeal): u32 {
+        stake.staking_output_index
     }
 
     public fun outpoint(stake: &BBNStakeSeal): types::OutPoint {
-        types::new_outpoint(stake.txid, stake.vout)
+        types::new_outpoint(stake.txid, stake.staking_output_index)
     }
 
     public fun tag(stake: &BBNStakeSeal): &vector {
@@ -484,8 +596,8 @@ module bitcoin_move::bbn {
         stake.staking_time
     }
 
-    public fun staking_amount(stake: &BBNStakeSeal): u64 {
-        stake.staking_amount
+    public fun staking_value(stake: &BBNStakeSeal): u64 {
+        stake.staking_value
     }
 
     public fun is_expired(stake: &BBNStakeSeal): bool {
@@ -674,14 +786,12 @@ module bitcoin_move::bbn {
         let bbn_opreturn_data_opt = parse_bbn_op_return_data(&script_buf);
         let bbn_opreturn_data = option::destroy_some(bbn_opreturn_data_opt);
         let BBNV0OpReturnData{tag:_, version:_, staker_pub_key, finality_provider_pub_key, staking_time} = bbn_opreturn_data;
-        let params_opt = get_bbn_param(864790);
-        assert!(is_some(¶ms_opt), 1000);
-        let params = option::destroy_some(params_opt);
+        let param = get_bbn_param_v1();
         let sb = build_staking_tx_output_script_pubkey(
             staker_pub_key,
             vector::singleton(finality_provider_pub_key),
-            params.covenant_pks,
-            params.covenant_quorum,
+            param.covenant_pks,
+            param.covenant_quorum,
             staking_time
         );
         let result = script_buf::into_bytes(sb);