From 2534fcdebd6a9659bd197207029970423d2c365a Mon Sep 17 00:00:00 2001 From: felicityin Date: Tue, 27 Jun 2023 20:23:41 +0800 Subject: [PATCH] test: checkpoint tx --- common/src/traits/tx_builder.rs | 1 + common/src/types/tx_builder.rs | 16 ++-- devtools/tx-tests/src/config/type_ids.toml | 16 ++-- devtools/tx-tests/src/main.rs | 12 +++ devtools/tx-tests/src/tx/checkpoint.rs | 66 +++++++++++++ devtools/tx-tests/src/tx/init.rs | 8 +- devtools/tx-tests/src/tx/mod.rs | 2 + tx-builder/src/ckb/checkpoint.rs | 102 +++++++++++---------- tx-builder/src/ckb/define/scripts.rs | 14 +-- tx-builder/src/ckb/define/types.rs | 4 +- tx-builder/src/ckb/delegate.rs | 8 +- tx-builder/src/ckb/delegate_smt.rs | 9 +- tx-builder/src/ckb/init.rs | 18 +++- tx-builder/src/ckb/mint.rs | 4 +- tx-builder/src/ckb/stake.rs | 6 +- tx-builder/src/ckb/stake_smt.rs | 27 ++++-- tx-builder/src/ckb/tests/checkpoint.rs | 71 -------------- tx-builder/src/ckb/tests/mod.rs | 1 - tx-builder/src/ckb/utils/cell_dep.rs | 15 +++ tx-builder/src/ckb/utils/script.rs | 8 +- 20 files changed, 229 insertions(+), 179 deletions(-) create mode 100644 devtools/tx-tests/src/tx/checkpoint.rs delete mode 100644 tx-builder/src/ckb/tests/checkpoint.rs diff --git a/common/src/traits/tx_builder.rs b/common/src/traits/tx_builder.rs index 8443b05..9632a32 100644 --- a/common/src/traits/tx_builder.rs +++ b/common/src/traits/tx_builder.rs @@ -102,6 +102,7 @@ where kicker_key: PrivateKey, ckb: CkbNetwork, type_ids: CheckpointTypeIds, + epoch_len: u64, new_checkpoint: Checkpoint, ) -> Self; diff --git a/common/src/types/tx_builder.rs b/common/src/types/tx_builder.rs index dc78a51..564e4d7 100644 --- a/common/src/types/tx_builder.rs +++ b/common/src/types/tx_builder.rs @@ -75,8 +75,8 @@ pub struct StakeItem { pub inauguration_epoch: Epoch, } -impl From<&StakeItem> for StakeInfoDelta { - fn from(stake: &StakeItem) -> Self { +impl From for StakeInfoDelta { + fn from(stake: StakeItem) -> Self { StakeInfoDelta::new_builder() .is_increase(Byte::new(stake.is_increase.into())) .amount(to_uint128(stake.amount)) @@ -111,8 +111,8 @@ impl DelegateItem { } } -impl From<&DelegateItem> for DelegateInfoDelta { - fn from(delegate: &DelegateItem) -> Self { +impl From for DelegateInfoDelta { + fn from(delegate: DelegateItem) -> Self { DelegateInfoDelta::new_builder() .staker(Identity::new_unchecked( delegate.staker.as_bytes().to_owned().into(), @@ -125,7 +125,7 @@ impl From<&DelegateItem> for DelegateInfoDelta { } } -#[derive(Default)] +#[derive(Default, Clone)] pub struct Checkpoint { pub epoch: Epoch, pub period: u32, @@ -137,8 +137,8 @@ pub struct Checkpoint { pub propose_count: Vec, } -impl From<&Checkpoint> for CheckpointCellData { - fn from(checkpoint: &Checkpoint) -> Self { +impl From for CheckpointCellData { + fn from(checkpoint: Checkpoint) -> Self { CheckpointCellData::new_builder() .version(Byte::default()) .epoch(to_uint64(checkpoint.epoch)) @@ -160,7 +160,7 @@ pub fn propose_counts(proposes: &[ProposeCount]) -> ProposeCounts { propose_count.build() } -#[derive(Default)] +#[derive(Default, Clone)] pub struct Proof { pub number: u64, pub round: u64, diff --git a/devtools/tx-tests/src/config/type_ids.toml b/devtools/tx-tests/src/config/type_ids.toml index 6865026..9029cc1 100644 --- a/devtools/tx-tests/src/config/type_ids.toml +++ b/devtools/tx-tests/src/config/type_ids.toml @@ -1,8 +1,8 @@ -selection_type_id = "0x67c75bb2759250649b097b4251315758b4ee03508acb4f284bc33e0dd914c5d7" -issue_type_id = "0xf033654bfed1833c031340f8c94f17e6dd5564a412117be60dac5b2ef6d438a4" -checkpoint_type_id = "0x65b0165752ae44e18be4f722857c695bfe38986e740de8003703dd8c34916120" -metadata_type_id = "0x626e1e688278f6db98a1ce2d44d186e18c43c9b781d33225333a1062401bec0d" -stake_smt_type_id = "0xdb58fc7a64eae103975fe88567bd532a051d7732ee0faeb51a5497ac3ddf75df" -delegate_smt_type_id = "0x778f21066818394dc3f1d46562cc0bc145bd43bbf45f0a36b9aa092efa3542b4" -reward_smt_type_id = "0x41085040c66d8bc910a9780ad83472385e7cb03dd0c574dd3a5eab689ceffb8e" -xudt_owner = "0x7ab05e531ae8f970f227f334010f67d9a74ee9f7e902920185c709c63fc7d416" +selection_type_id = "0x705d8dc9b7cd351e29bfb24fb4443e0f7f40b01b13940db5a6f54adfa7b63170" +issue_type_id = "0x3054fe87c40f2ef563bb83e868bab744a173fe37a651d0448116a684e33650d5" +checkpoint_type_id = "0xf451af07b7771925065b3010362c5103cc1809a60de8fc2c9c82d2bec3404d0c" +metadata_type_id = "0xc5387cff490467c52bd2b2352c152a6aa57bbf469e4aa5fe51459ed0647c14c6" +stake_smt_type_id = "0x9b95a2923c775ab42e71314a3110614e86e051fd9c05186f0b0c335fd91e4630" +delegate_smt_type_id = "0xcba604590a06ccc77db8dd827516cb8dbddce2e176cc7ba36d7b4a40dd6b49a9" +reward_smt_type_id = "0x64ec42c5d6de37fc37ed337727ab73c54fef46204cba58bf4b923986b4aef858" +xudt_owner = "0x5bcdd4abdbc6b06a0e949bb469cc6d35e11c443fc9ab0586d5a937c662044964" diff --git a/devtools/tx-tests/src/main.rs b/devtools/tx-tests/src/main.rs index 2e25cd0..7d9971a 100644 --- a/devtools/tx-tests/src/main.rs +++ b/devtools/tx-tests/src/main.rs @@ -42,6 +42,13 @@ async fn main() { .num_args(1) .default_value("") .help("test delegate tx"), + ) + .arg( + clap::Arg::new("checkpoint") + .short('c') + .required(false) + .num_args(0) + .help("test checkpoint tx"), ); let matches = cmd.get_matches(); @@ -49,6 +56,7 @@ async fn main() { let mint = matches.get_one::("mint").unwrap().to_owned(); let stake = matches.get_one::("stake").unwrap().as_str(); let delegate = matches.get_one::("delegate").unwrap().as_str(); + let checkpoint = matches.get_one::("checkpoint").unwrap().to_owned(); let ckb = CkbNetwork { network_type: NetworkType::Testnet, @@ -80,4 +88,8 @@ async fn main() { _ => unimplemented!(), } } + + if checkpoint { + checkpoint_tx(ckb.clone()).await; + } } diff --git a/devtools/tx-tests/src/tx/checkpoint.rs b/devtools/tx-tests/src/tx/checkpoint.rs new file mode 100644 index 0000000..fde16c9 --- /dev/null +++ b/devtools/tx-tests/src/tx/checkpoint.rs @@ -0,0 +1,66 @@ +use ckb_sdk::unlock::ScriptSigner; +use common::traits::tx_builder::ICheckpointTxBuilder; +use common::types::tx_builder::{Checkpoint, CheckpointTypeIds, CkbNetwork}; +use rpc_client::ckb_client::ckb_rpc_client::CkbRpcClient; +use tx_builder::ckb::checkpoint::CheckpointTxBuilder; +use tx_builder::ckb::utils::omni::{omni_eth_ckb_address, omni_eth_signer}; +use tx_builder::ckb::utils::tx::{gen_script_group, send_tx}; + +use crate::config::parse_file; +use crate::config::types::{PrivKeys, TypeIds as CTypeIds}; +use crate::{PRIV_KEYS_PATH, TYPE_IDS_PATH}; + +pub async fn checkpoint_tx(ckb: CkbNetwork) { + let priv_keys: PrivKeys = parse_file(PRIV_KEYS_PATH); + let test_kicker_key = priv_keys.staker_privkeys[0].clone().into_h256().unwrap(); + println!( + "kicker ckb addres: {}\n", + omni_eth_ckb_address(&ckb.network_type, test_kicker_key.clone()).unwrap() + ); + + let type_ids: CTypeIds = parse_file(TYPE_IDS_PATH); + let metadata_type_id = type_ids.metadata_type_id.into_h256().unwrap(); + let checkpoint_type_id = type_ids.checkpoint_type_id.into_h256().unwrap(); + + let mut tx = CheckpointTxBuilder::new( + test_kicker_key.clone(), + ckb.clone(), + CheckpointTypeIds { + metadata_type_id, + checkpoint_type_id, + }, + 2, + Checkpoint { + epoch: 1, + period: 1, + latest_block_height: 10, + timestamp: 11111, + ..Default::default() + }, + ) + .await + .build_tx() + .await + .unwrap(); + + let signer = omni_eth_signer(test_kicker_key).unwrap(); + let script_groups = gen_script_group(&ckb.client, &tx).await.unwrap(); + let mut first_group = true; + + for group in script_groups.lock_groups.iter() { + if !first_group { + println!("sign; not checkpoint id: {:?}", group.1.input_indices); + tx = signer.sign_tx(&tx, group.1).unwrap(); + } else { + println!("not sign; checkpoint id: {:?}", group.1.input_indices); + } + first_group = false; + } + + match send_tx(&ckb.client, &tx.data().into()).await { + Ok(tx_hash) => println!("tx hash: 0x{}", tx_hash), + Err(e) => println!("{}", e), + } + + println!("\ntx: {}", tx); +} diff --git a/devtools/tx-tests/src/tx/init.rs b/devtools/tx-tests/src/tx/init.rs index 8248a0b..14fadf9 100644 --- a/devtools/tx-tests/src/tx/init.rs +++ b/devtools/tx-tests/src/tx/init.rs @@ -25,12 +25,14 @@ pub async fn init_tx(ckb: CkbNetwork) { Checkpoint { epoch: 0, period: 0, + latest_block_height: 10, + timestamp: 11111, ..Default::default() }, Metadata { - epoch_len: 2, - period_len: 2, - quorum: 2, + epoch_len: 100, + period_len: 100, + quorum: 10, ..Default::default() }, ) diff --git a/devtools/tx-tests/src/tx/mod.rs b/devtools/tx-tests/src/tx/mod.rs index f100e83..6f60cde 100644 --- a/devtools/tx-tests/src/tx/mod.rs +++ b/devtools/tx-tests/src/tx/mod.rs @@ -1,8 +1,10 @@ +mod checkpoint; mod delegate; mod init; mod mint; mod stake; +pub use checkpoint::checkpoint_tx; pub use delegate::{add_delegate_tx, first_delegate_tx, reedem_delegate_tx}; pub use init::init_tx; pub use mint::mint_tx; diff --git a/tx-builder/src/ckb/checkpoint.rs b/tx-builder/src/ckb/checkpoint.rs index 24c7742..db4245d 100644 --- a/tx-builder/src/ckb/checkpoint.rs +++ b/tx-builder/src/ckb/checkpoint.rs @@ -5,15 +5,12 @@ use bytes::Bytes; use ckb_sdk::{unlock::ScriptSigner, ScriptGroup, ScriptGroupType}; use ckb_types::{ core::{Capacity, TransactionBuilder, TransactionView}, - packed::{CellInput, CellOutput, Script}, + packed::{CellInput, CellOutput}, prelude::{Entity, Pack}, }; use common::{ traits::{ckb_rpc_client::CkbRpc, tx_builder::ICheckpointTxBuilder}, - types::{ - ckb_rpc_client::Cell, - tx_builder::{CheckpointTypeIds, CkbNetwork}, - }, + types::tx_builder::{CheckpointTypeIds, CkbNetwork}, }; use common::{ types::tx_builder::{Checkpoint, PrivateKey}, @@ -25,7 +22,10 @@ use crate::ckb::{ define::error::CkbTxErr, utils::{ cell_collector::get_unique_cell, - cell_dep::{metadata_cell_dep, omni_lock_dep, secp256k1_lock_dep, xudt_type_dep}, + cell_dep::{ + always_success_lock_dep, checkpoint_type_dep, metadata_cell_dep, omni_lock_dep, + secp256k1_lock_dep, xudt_type_dep, + }, omni::{omni_eth_address, omni_eth_signer, omni_eth_witness_placeholder}, script::{always_success_lock, checkpoint_type, omni_eth_lock}, tx::balance_tx, @@ -36,11 +36,11 @@ pub struct CheckpointTxBuilder where C: CkbRpc, { - kicker_key: PrivateKey, - ckb: CkbNetwork, - type_ids: CheckpointTypeIds, - new_checkpoint: Checkpoint, - checkpoint_type_script: Script, + kicker_key: PrivateKey, + ckb: CkbNetwork, + type_ids: CheckpointTypeIds, + epoch_len: u64, + new_checkpoint: Checkpoint, } #[async_trait] @@ -52,44 +52,61 @@ where kicker_key: PrivateKey, ckb: CkbNetwork, type_ids: CheckpointTypeIds, + epoch_len: u64, new_checkpoint: Checkpoint, ) -> Self { - let checkpoint_type_script = - checkpoint_type(&ckb.network_type, &type_ids.checkpoint_type_id); Self { kicker_key, ckb, type_ids, + epoch_len, new_checkpoint, - checkpoint_type_script, } } async fn build_tx(&self) -> Result { + let checkpoint_type = + checkpoint_type(&self.ckb.network_type, &self.type_ids.checkpoint_type_id); + let last_checkpoint_cell = - get_unique_cell(&self.ckb.client, self.checkpoint_type_script.clone()).await?; - self.check_occasion(last_checkpoint_cell.clone()).await?; + get_unique_cell(&self.ckb.client, checkpoint_type.clone()).await?; + + let last_checkpoint_data = CheckpointCellData::new_unchecked( + last_checkpoint_cell.output_data.unwrap().into_bytes(), + ); + + self.check_occasion( + to_u64(&last_checkpoint_data.epoch()), + to_u32(&last_checkpoint_data.period()), + ) + .await?; let inputs: Vec = vec![CellInput::new_builder() .previous_output(last_checkpoint_cell.out_point.into()) .build()]; - let new_checkpoint_data: CheckpointCellData = (&self.new_checkpoint).into(); - let outputs_data = vec![new_checkpoint_data.as_bytes()]; + let new_checkpoint_data: CheckpointCellData = self.new_checkpoint.clone().into(); + let outputs_data = vec![new_checkpoint_data + .as_builder() + .metadata_type_id(last_checkpoint_data.metadata_type_id()) // metdata type script hash + .build() + .as_bytes()]; let outputs = vec![CellOutput::new_builder() .lock(always_success_lock(&self.ckb.network_type)) - .type_(Some(self.checkpoint_type_script.clone()).pack()) + .type_(Some(checkpoint_type).pack()) .build_exact_capacity(Capacity::bytes(outputs_data[0].len())?)?]; let cell_deps = vec![ omni_lock_dep(&self.ckb.network_type), secp256k1_lock_dep(&self.ckb.network_type), xudt_type_dep(&self.ckb.network_type), + always_success_lock_dep(&self.ckb.network_type), + checkpoint_type_dep(&self.ckb.network_type), metadata_cell_dep( &self.ckb.client, &self.ckb.network_type, - &self.type_ids.metadata_type_id, + &self.type_ids.metadata_type_id, // metadata type script args ) .await?, ]; @@ -115,7 +132,6 @@ where let tx = balance_tx(&self.ckb.client, kick_lock.clone(), tx).await?; let signer = omni_eth_signer(self.kicker_key.clone())?; - let tx_view = signer.sign_tx(&tx, &ScriptGroup { script: kick_lock, group_type: ScriptGroupType::Lock, @@ -131,39 +147,29 @@ impl CheckpointTxBuilder where C: CkbRpc, { - async fn check_occasion(&self, last_checkpoint_cell: Cell) -> Result<(), CkbTxErr> { - let last_checkpoint_cell_data = CheckpointCellData::new_unchecked( - last_checkpoint_cell.output_data.unwrap().into_bytes(), - ); - let last_epoch = to_u64(&last_checkpoint_cell_data.epoch()); - let last_period = to_u32(&last_checkpoint_cell_data.period()); - match self.new_checkpoint.epoch { - latest_epoch if latest_epoch == last_epoch.saturating_add(1) => { - match self.new_checkpoint.period { - 0 => Ok(()), - _ => Err(CkbTxErr::NotCheckpointOccasion { - current_epoch: last_epoch, - current_period: last_period, - recorded_epoch: latest_epoch, - recorded_period: self.new_checkpoint.period, - }), - } - } - latest_epoch if latest_epoch == last_epoch => match self.new_checkpoint.period { - last_period if last_period == last_period.saturating_add(1) => Ok(()), - _ => Err(CkbTxErr::NotCheckpointOccasion { + async fn check_occasion(&self, last_epoch: u64, last_period: u32) -> Result<(), CkbTxErr> { + if (last_period as u64) == self.epoch_len - 1 { + if self.new_checkpoint.period != 0 || self.new_checkpoint.epoch != last_epoch + 1 { + Err(CkbTxErr::NotCheckpointOccasion { current_epoch: last_epoch, current_period: last_period, - recorded_epoch: latest_epoch, - recorded_period: last_period, - }), - }, - _ => Err(CkbTxErr::NotCheckpointOccasion { + recorded_epoch: self.new_checkpoint.epoch, + recorded_period: self.new_checkpoint.period, + }) + } else { + Ok(()) + } + } else if self.new_checkpoint.period != last_period + 1 + || self.new_checkpoint.epoch != last_epoch + 1 + { + Err(CkbTxErr::NotCheckpointOccasion { current_epoch: last_epoch, current_period: last_period, recorded_epoch: self.new_checkpoint.epoch, recorded_period: self.new_checkpoint.period, - }), + }) + } else { + Ok(()) } } } diff --git a/tx-builder/src/ckb/define/scripts.rs b/tx-builder/src/ckb/define/scripts.rs index 0d7f25e..853a747 100644 --- a/tx-builder/src/ckb/define/scripts.rs +++ b/tx-builder/src/ckb/define/scripts.rs @@ -76,17 +76,17 @@ lazy_static::lazy_static! { }; // todo: main net - pub static ref ALWAYS_SUCCESS_MAINNET: Script = Script { + pub static ref ALWAYS_SUCCESS_LOCK_MAINNET: Script = Script { code_hash: h256!("0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"), hash_type: ScriptHashType::Type, tx_hash: h256!("0x71a7ba8fc96349fea0ed3a5c47992e3b4084b031a42264a018e0072e8172e46c"), index: 0, dep_type: DepType::Code, }; - pub static ref ALWAYS_SUCCESS_TESTNET: Script = Script { - code_hash: h256!("0x00000000000000000000000000000000000000000000000000545950455f4944"), + pub static ref ALWAYS_SUCCESS_LOCK_TESTNET: Script = Script { + code_hash: h256!("0xd4edb0fa797f92bc0dcb8bcef036c55e3f591316ca4af6a5fb4cc4a5e67cb014"), hash_type: ScriptHashType::Type, - tx_hash: h256!("0x842380984bff8b2c7bbb8fd8886bd6784795f2f8ad140e4e2b41d771fa27314d"), + tx_hash: h256!("0x1f2d3579dcb8599e31ce71f3b471be7e1edd77c314c0942eb26d11c80d259ba9"), index: 0, dep_type: DepType::Code, }; @@ -171,7 +171,7 @@ lazy_static::lazy_static! { dep_type: DepType::Code, }; - // todo + // todo: main net pub static ref DELEGATE_REQUIREMENT_TYPE_MAINNET: Script = Script { code_hash: h256!("0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"), hash_type: ScriptHashType::Type, @@ -180,9 +180,9 @@ lazy_static::lazy_static! { dep_type: DepType::Code, }; pub static ref DELEGATE_REQUIREMENT_TYPE_TESTNET: Script = Script { - code_hash: h256!("0x58c63de75a92d3ed83a0636d29454173608ff27a053891258e96a9a44e84ce37"), + code_hash: h256!("0x1122036fd7be9796625b60a22e045fe5d03ffb2d559e86098d896645f3f356b0"), hash_type: ScriptHashType::Type, - tx_hash: h256!("0xc2721314c82baf732583e3e0612b7735d0e0af87994b89b3ce6c33f51c1095fb"), + tx_hash: h256!("0x95876df71b1c631ba6cc1abb1e2d789cebef35837f223bfd56ad7b66bc8fcb0e"), index: 0, dep_type: DepType::Code, }; diff --git a/tx-builder/src/ckb/define/types.rs b/tx-builder/src/ckb/define/types.rs index da17a18..f22d1a4 100644 --- a/tx-builder/src/ckb/define/types.rs +++ b/tx-builder/src/ckb/define/types.rs @@ -149,7 +149,7 @@ impl From for AStakeAtCellLockData { AStakeAtCellLockData::new_builder() .l1_pub_key(value.l1_pub_key) .bls_pub_key(value.bls_pub_key) - .delta((&value.stake_info).into()) + .delta(value.stake_info.into()) .build() } } @@ -178,7 +178,7 @@ pub struct DelegateAtCellLockData { impl From for ADelegateAtCellLockData { fn from(value: DelegateAtCellLockData) -> Self { let infos = DelegateInfoDeltas::new_builder() - .extend(value.delegator_infos.iter().map(Into::into)) + .extend(value.delegator_infos.into_iter().map(Into::into)) .build(); ADelegateAtCellLockData::new_builder() // .version(value.version.into()) // useless diff --git a/tx-builder/src/ckb/delegate.rs b/tx-builder/src/ckb/delegate.rs index 6414307..97eff95 100644 --- a/tx-builder/src/ckb/delegate.rs +++ b/tx-builder/src/ckb/delegate.rs @@ -402,14 +402,14 @@ impl DelegateTxBuilder { )?; updated_delegates = updated_delegates.push( - (&DelegateItem { + DelegateItem { staker: delegate.staker.clone(), total_amount: actual_info.total_elect_amount, is_increase: actual_info.is_increase, amount: actual_info.amount, inauguration_epoch: delegate.inauguration_epoch, - }) - .into(), + } + .into(), ); } else { if delegate.is_increase { @@ -417,7 +417,7 @@ impl DelegateTxBuilder { } let mut delegate = delegate.to_owned(); delegate.total_amount = delegate.amount; - updated_delegates = updated_delegates.push((&delegate).into()); + updated_delegates = updated_delegates.push(delegate.into()); } } diff --git a/tx-builder/src/ckb/delegate_smt.rs b/tx-builder/src/ckb/delegate_smt.rs index 1c1fbb8..e7e0de7 100644 --- a/tx-builder/src/ckb/delegate_smt.rs +++ b/tx-builder/src/ckb/delegate_smt.rs @@ -36,8 +36,8 @@ use crate::ckb::utils::{ get_delegate_cell, get_delegate_requirement_cell, get_unique_cell, get_withdraw_cell, }, cell_dep::{ - checkpoint_cell_dep, delegate_lock_dep, delegate_smt_type_dep, metadata_cell_dep, - omni_lock_dep, secp256k1_lock_dep, withdraw_lock_dep, xudt_type_dep, + always_success_lock_dep, checkpoint_cell_dep, delegate_lock_dep, delegate_smt_type_dep, + metadata_cell_dep, omni_lock_dep, secp256k1_lock_dep, withdraw_lock_dep, xudt_type_dep, }, omni::{omni_eth_address, omni_eth_witness_placeholder}, script::{ @@ -111,6 +111,7 @@ impl IDelegateSmtTxBuilder for DelegateS let cell_deps = vec![ secp256k1_lock_dep(&self.ckb.network_type), omni_lock_dep(&self.ckb.network_type), + always_success_lock_dep(&self.ckb.network_type), xudt_type_dep(&self.ckb.network_type), delegate_lock_dep(&self.ckb.network_type), delegate_smt_type_dep(&self.ckb.network_type), @@ -259,11 +260,11 @@ impl DelegateSmtTxBuilder { new_delegates.push(delegate.as_builder().amount(to_uint128(0)).build()); } - let new_delegate_data = old_delegate_data.lock().clone(); + let inner_delegate_data = old_delegate_data.lock(); let new_delegate_data = old_delegate_data .as_builder() .lock( - new_delegate_data + inner_delegate_data .as_builder() .delegator_infos(new_delegates.build()) .build(), diff --git a/tx-builder/src/ckb/init.rs b/tx-builder/src/ckb/init.rs index f5013e7..595cf0c 100644 --- a/tx-builder/src/ckb/init.rs +++ b/tx-builder/src/ckb/init.rs @@ -20,7 +20,7 @@ use molecule::prelude::Builder; use common::traits::ckb_rpc_client::CkbRpc; use common::traits::tx_builder::IInitTxBuilder; use common::types::tx_builder::*; -use common::utils::convert::to_h256; +use common::utils::convert::{to_axon_byte32, to_h256}; use crate::ckb::define::constants::START_EPOCH; use crate::ckb::define::scripts::*; @@ -139,7 +139,7 @@ impl IInitTxBuilder for InitTxBuilder { script: seeder_lock, group_type: ScriptGroupType::Lock, input_indices: vec![0], - output_indices: vec![0], + output_indices: vec![], })?; Ok((tx, type_id_args)) @@ -148,14 +148,13 @@ impl IInitTxBuilder for InitTxBuilder { impl InitTxBuilder { fn build_data(&self) -> Vec { - let checkpoint: CheckpointCellData = (&self.checkpoint).into(); vec![ // issue cell data InfoCellData::new_simple(0, 0, H256::default()).pack(), // selection cell data Bytes::default(), // checkpoint cell data - checkpoint.as_bytes(), + CheckpointCellData::new_builder().build().as_bytes(), // metadata cell data AMetadataCellData::from(MetadataCellData { metadata: vec![self.metadata.clone()], @@ -274,6 +273,17 @@ impl InitTxBuilder { .pack() .pack(); + // checkpoint cell data + let checkpoint: CheckpointCellData = self.checkpoint.clone().into(); + outputs_data[2] = checkpoint + .as_builder() + .metadata_type_id(to_axon_byte32( + &metadata_type(&self.ckb.network_type, &metadata_type_id).calc_script_hash(), + )) + .build() + .as_bytes() + .pack(); + let type_ids = TypeIds { issue_type_id, selection_type_id, diff --git a/tx-builder/src/ckb/mint.rs b/tx-builder/src/ckb/mint.rs index a5f5e0a..34ae794 100644 --- a/tx-builder/src/ckb/mint.rs +++ b/tx-builder/src/ckb/mint.rs @@ -101,13 +101,13 @@ impl IMintTxBuilder for MintTxBuilder { script: seeder_lock.clone(), group_type: ScriptGroupType::Lock, input_indices: vec![1], - output_indices: vec![0], + output_indices: vec![], })?; let tx = signer.sign_tx(&tx, &ScriptGroup { script: seeder_lock, group_type: ScriptGroupType::Lock, input_indices: vec![2], - output_indices: vec![0], + output_indices: vec![], })?; Ok(tx) diff --git a/tx-builder/src/ckb/stake.rs b/tx-builder/src/ckb/stake.rs index 462e7fe..acf457b 100644 --- a/tx-builder/src/ckb/stake.rs +++ b/tx-builder/src/ckb/stake.rs @@ -328,12 +328,12 @@ impl StakeTxBuilder { inner_stake_data .as_builder() .delta( - (&StakeItem { + StakeItem { is_increase: actual_info.is_increase, amount: actual_info.amount, inauguration_epoch: self.stake.inauguration_epoch, - }) - .into(), + } + .into(), ) .build(), ) diff --git a/tx-builder/src/ckb/stake_smt.rs b/tx-builder/src/ckb/stake_smt.rs index 866283c..f1f08e0 100644 --- a/tx-builder/src/ckb/stake_smt.rs +++ b/tx-builder/src/ckb/stake_smt.rs @@ -43,8 +43,8 @@ use crate::ckb::utils::{ cell_collector::{get_stake_cell, get_unique_cell, get_withdraw_cell}, cell_data::{stake_item, token_cell_data, update_withdraw_data}, cell_dep::{ - checkpoint_cell_dep, metadata_cell_dep, omni_lock_dep, secp256k1_lock_dep, stake_lock_dep, - stake_smt_type_dep, withdraw_lock_dep, xudt_type_dep, + always_success_lock_dep, checkpoint_cell_dep, metadata_cell_dep, omni_lock_dep, + secp256k1_lock_dep, stake_lock_dep, stake_smt_type_dep, withdraw_lock_dep, xudt_type_dep, }, omni::{omni_eth_address, omni_eth_witness_placeholder}, script::{ @@ -133,6 +133,7 @@ impl IStakeSmtTxBuilder omni_lock_dep(&self.ckb.network_type), secp256k1_lock_dep(&self.ckb.network_type), xudt_type_dep(&self.ckb.network_type), + always_success_lock_dep(&self.ckb.network_type), stake_lock_dep(&self.ckb.network_type), stake_smt_type_dep(&self.ckb.network_type), checkpoint_cell_dep( @@ -149,6 +150,7 @@ impl IStakeSmtTxBuilder .await?, ]; + // todo let mut witnesses = vec![ omni_eth_witness_placeholder().as_bytes(), // Stake smt cell lock omni_eth_witness_placeholder().as_bytes(), // Stake AT cell lock, may not be needed @@ -241,16 +243,21 @@ impl StakeSmtTxBuilder { (old_total_stake_amount, None) }; + let inner_stake_data = old_stake_data.lock(); let new_stake_data = old_stake_data - .lock() .as_builder() - .delta( - (&StakeItem { - is_increase: false, - amount: 0, - inauguration_epoch: 0, - }) - .into(), + .lock( + inner_stake_data + .as_builder() + .delta( + StakeItem { + is_increase: false, + amount: 0, + inauguration_epoch: 0, + } + .into(), + ) + .build(), ) .build() .as_bytes(); diff --git a/tx-builder/src/ckb/tests/checkpoint.rs b/tx-builder/src/ckb/tests/checkpoint.rs deleted file mode 100644 index b35f79f..0000000 --- a/tx-builder/src/ckb/tests/checkpoint.rs +++ /dev/null @@ -1,71 +0,0 @@ -#[cfg(test)] -mod tests { - - use ckb_types::h256; - use common::{ - traits::tx_builder::ICheckpointTxBuilder, - types::{ - axon_rpc_client::mock_latest_check_point_info, - tx_builder::{Checkpoint, CheckpointTypeIds, CkbNetwork, NetworkType}, - }, - utils::convert::to_ckb_h256, - }; - use rpc_client::ckb_client::ckb_rpc_client::CkbRpcClient; - - use crate::ckb::{checkpoint::CheckpointTxBuilder, utils::tx::send_tx}; - - // #[tokio::test] - async fn _checkpoints_tx() { - let test_kicker_key = - h256!("0x13b08bb054d5dd04013156dced8ba2ce4d8cc5973e10d905a228ea1abc267e62"); - let checkpoint_type_id = - h256!("0xfe18e5fde2ca0d863fc9888aed7e3d667249d719542d1dd78aa77de0938c2a83"); - let metadata_type_id = - h256!("0x30bdedc605cdb0b80f7f328c803d6059f0ad7bdeb0ccb8f44019502ac03b68a2"); - - let ckb_client = CkbRpcClient::new("https://testnet.ckb.dev"); - - let mock_axon_checkpoint_info = mock_latest_check_point_info(); - - let mock_checkpoint = Checkpoint { - epoch: 2, - period: 2, - state_root: to_ckb_h256(&mock_axon_checkpoint_info.state_root), - latest_block_height: mock_axon_checkpoint_info.latest_block_height, - latest_block_hash: to_ckb_h256(&mock_axon_checkpoint_info.latest_block_hash), - timestamp: mock_axon_checkpoint_info.timestamp, - proof: (&mock_axon_checkpoint_info.proof).into(), - propose_count: mock_axon_checkpoint_info - .propose_count - .iter() - .map(|propose| propose.into()) - .collect(), - }; - - let ckb = CkbNetwork { - network_type: NetworkType::Testnet, - client: ckb_client.clone(), - }; - - let tx = CheckpointTxBuilder::new( - test_kicker_key.clone(), - ckb, - CheckpointTypeIds { - metadata_type_id, - checkpoint_type_id, - }, - mock_checkpoint, - ) - .await - .build_tx() - .await - .unwrap(); - - println!("tx: {}", tx); - - match send_tx(&ckb_client, &tx.data().into()).await { - Ok(tx_hash) => println!("tx hash: 0x{}", tx_hash), - Err(e) => println!("{}", e), - } - } -} diff --git a/tx-builder/src/ckb/tests/mod.rs b/tx-builder/src/ckb/tests/mod.rs index c9b390a..544301d 100644 --- a/tx-builder/src/ckb/tests/mod.rs +++ b/tx-builder/src/ckb/tests/mod.rs @@ -1,4 +1,3 @@ -mod checkpoint; mod omni; mod reward; mod stake_smt; diff --git a/tx-builder/src/ckb/utils/cell_dep.rs b/tx-builder/src/ckb/utils/cell_dep.rs index eddadd6..672c5e4 100644 --- a/tx-builder/src/ckb/utils/cell_dep.rs +++ b/tx-builder/src/ckb/utils/cell_dep.rs @@ -62,6 +62,21 @@ pub fn secp256k1_lock_dep(network_type: &NetworkType) -> CellDep { } } +pub fn always_success_lock_dep(network_type: &NetworkType) -> CellDep { + match network_type { + NetworkType::Mainnet => cell_dep!( + &ALWAYS_SUCCESS_LOCK_MAINNET.tx_hash, + ALWAYS_SUCCESS_LOCK_MAINNET.index, + ALWAYS_SUCCESS_LOCK_MAINNET.dep_type + ), + NetworkType::Testnet => cell_dep!( + &ALWAYS_SUCCESS_LOCK_TESTNET.tx_hash, + ALWAYS_SUCCESS_LOCK_TESTNET.index, + ALWAYS_SUCCESS_LOCK_TESTNET.dep_type + ), + } +} + pub fn xudt_type_dep(network_type: &NetworkType) -> CellDep { match network_type { NetworkType::Mainnet => cell_dep!( diff --git a/tx-builder/src/ckb/utils/script.rs b/tx-builder/src/ckb/utils/script.rs index d7f2d39..406d5d9 100644 --- a/tx-builder/src/ckb/utils/script.rs +++ b/tx-builder/src/ckb/utils/script.rs @@ -62,13 +62,13 @@ pub fn sighash_lock(pubkey_hash: &Bytes) -> Script { pub fn always_success_lock(network_type: &NetworkType) -> Script { match network_type { NetworkType::Mainnet => script!( - &ALWAYS_SUCCESS_MAINNET.code_hash, - ALWAYS_SUCCESS_MAINNET.hash_type, + &ALWAYS_SUCCESS_LOCK_MAINNET.code_hash, + ALWAYS_SUCCESS_LOCK_MAINNET.hash_type, bytes::Bytes::default() ), NetworkType::Testnet => script!( - &ALWAYS_SUCCESS_TESTNET.code_hash, - ALWAYS_SUCCESS_TESTNET.hash_type, + &ALWAYS_SUCCESS_LOCK_TESTNET.code_hash, + ALWAYS_SUCCESS_LOCK_TESTNET.hash_type, bytes::Bytes::default() ), }