mirror of
https://github.com/logos-blockchain/logos-execution-zone.git
synced 2026-07-09 15:29:34 +00:00
844 lines
30 KiB
Rust
844 lines
30 KiB
Rust
use std::{path::Path, sync::Arc, time::Instant};
|
|
|
|
use anyhow::{Context as _, Result, anyhow};
|
|
use borsh::BorshDeserialize;
|
|
use common::{
|
|
HashType,
|
|
block::{BedrockStatus, Block, HashableBlockData},
|
|
transaction::{LeeTransaction, clock_invocation},
|
|
};
|
|
use config::{GenesisAction, SequencerConfig};
|
|
use itertools::Itertools as _;
|
|
use lee::{AccountId, PublicTransaction, public_transaction::Message};
|
|
use lee_core::GENESIS_BLOCK_ID;
|
|
use log::{error, info, warn};
|
|
use logos_blockchain_key_management_system_service::keys::{ED25519_SECRET_KEY_SIZE, Ed25519Key};
|
|
use logos_blockchain_zone_sdk::sequencer::{DepositInfo, WithdrawArg};
|
|
use mempool::{MemPool, MemPoolHandle};
|
|
#[cfg(feature = "mock")]
|
|
pub use mock::SequencerCoreWithMockClients;
|
|
use num_bigint::BigUint;
|
|
pub use storage::error::DbError;
|
|
use storage::sequencer::{
|
|
RocksDBIO,
|
|
sequencer_cells::{PendingDepositEventRecord, WithdrawalReconciliationKey},
|
|
};
|
|
|
|
use crate::{
|
|
block_publisher::{BlockPublisherTrait, ZoneSdkPublisher},
|
|
block_store::SequencerStore,
|
|
};
|
|
|
|
pub mod block_publisher;
|
|
pub mod block_store;
|
|
pub mod config;
|
|
|
|
#[cfg(feature = "mock")]
|
|
pub mod mock;
|
|
|
|
/// The origin of a transaction.
|
|
#[derive(Clone, Copy)]
|
|
pub enum TransactionOrigin {
|
|
/// Basic transactions submitted by users via RPC.
|
|
User,
|
|
/// Transactions generated by the sequencer itself.
|
|
Sequencer,
|
|
}
|
|
|
|
#[derive(Clone, Debug, BorshDeserialize)]
|
|
struct DepositMetadata {
|
|
recipient_id: lee::AccountId,
|
|
}
|
|
|
|
impl DepositMetadata {
|
|
fn decode(bytes: &[u8]) -> Result<Self, std::io::Error> {
|
|
Self::try_from_slice(bytes)
|
|
}
|
|
}
|
|
|
|
pub struct SequencerCore<BP: BlockPublisherTrait = ZoneSdkPublisher> {
|
|
state: lee::V03State,
|
|
store: SequencerStore,
|
|
mempool: MemPool<(TransactionOrigin, LeeTransaction)>,
|
|
sequencer_config: SequencerConfig,
|
|
chain_height: u64,
|
|
block_publisher: BP,
|
|
}
|
|
|
|
impl<BP: BlockPublisherTrait> SequencerCore<BP> {
|
|
/// Starts the sequencer using the provided configuration.
|
|
/// If an existing database is found, the sequencer state is loaded from it and
|
|
/// assumed to represent the correct latest state consistent with Bedrock-finalized data.
|
|
/// If no database is found, the sequencer performs a fresh start from genesis,
|
|
/// initializing its state with the accounts defined in the configuration file.
|
|
fn open_or_create_store(config: &SequencerConfig) -> (SequencerStore, lee::V03State, Block) {
|
|
let signing_key = lee::PrivateKey::try_new(config.signing_key).unwrap();
|
|
let db_path = config.home.join("rocksdb");
|
|
|
|
if db_path.exists() {
|
|
let store = SequencerStore::open_db(&db_path, signing_key).unwrap_or_else(|err| {
|
|
panic!(
|
|
"Failed to open database at {} with error: {err}",
|
|
db_path.display()
|
|
)
|
|
});
|
|
let state = store
|
|
.get_lee_state()
|
|
.expect("Failed to read state from store");
|
|
let genesis_block = store
|
|
.get_block_at_id(store.genesis_id())
|
|
.expect("Failed to read genesis block from store")
|
|
.expect("Genesis block not found in store");
|
|
(store, state, genesis_block)
|
|
} else {
|
|
warn!(
|
|
"Database not found at {}, starting from genesis",
|
|
db_path.display()
|
|
);
|
|
|
|
let (genesis_state, genesis_txs) = build_genesis_state(config);
|
|
|
|
let hashable_data = HashableBlockData {
|
|
block_id: GENESIS_BLOCK_ID,
|
|
transactions: genesis_txs,
|
|
prev_block_hash: HashType([0; 32]),
|
|
timestamp: 0,
|
|
};
|
|
let genesis_block = hashable_data.into_pending_block(&signing_key);
|
|
|
|
let store = SequencerStore::create_db_with_genesis(
|
|
&db_path,
|
|
&genesis_block,
|
|
&genesis_state,
|
|
signing_key,
|
|
)
|
|
.expect("Failed to create database with genesis block");
|
|
|
|
(store, genesis_state, genesis_block)
|
|
}
|
|
}
|
|
|
|
pub async fn start_from_config(
|
|
config: SequencerConfig,
|
|
) -> (Self, MemPoolHandle<(TransactionOrigin, LeeTransaction)>) {
|
|
let bedrock_signing_key =
|
|
load_or_create_signing_key(&config.home.join("bedrock_signing_key"))
|
|
.expect("Failed to load or create bedrock signing key");
|
|
|
|
let (store, state, _genesis_block) = Self::open_or_create_store(&config);
|
|
|
|
let latest_block_meta = store
|
|
.latest_block_meta()
|
|
.expect("Failed to read latest block meta from store");
|
|
|
|
let initial_checkpoint = store
|
|
.get_zone_checkpoint()
|
|
.expect("Failed to load zone-sdk checkpoint");
|
|
let is_fresh_start = initial_checkpoint.is_none();
|
|
|
|
let (mempool, mempool_handle) = MemPool::new(config.mempool_max_size);
|
|
replay_unfulfilled_deposit_events(&store, mempool_handle.clone());
|
|
|
|
let block_publisher = BP::new(
|
|
&config.bedrock_config,
|
|
bedrock_signing_key,
|
|
config.retry_pending_blocks_timeout,
|
|
initial_checkpoint,
|
|
Self::on_checkpoint(store.dbio()),
|
|
Self::on_finalized_block(store.dbio()),
|
|
Self::on_deposit_event(store.dbio(), mempool_handle.clone()),
|
|
Self::on_withdraw_event(store.dbio()),
|
|
)
|
|
.await
|
|
.expect("Failed to initialize Block Publisher");
|
|
|
|
// Fresh start (no checkpoint): republish all pending blocks
|
|
if is_fresh_start {
|
|
let mut pending_blocks = store
|
|
.get_all_blocks()
|
|
.filter_ok(|block| matches!(block.bedrock_status, BedrockStatus::Pending))
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.expect("Failed to read blocks from store while republishing on fresh start");
|
|
pending_blocks.sort_unstable_by_key(|block| block.header.block_id);
|
|
|
|
assert!(
|
|
pending_blocks
|
|
.first()
|
|
.is_none_or(|block| block.header.block_id == GENESIS_BLOCK_ID),
|
|
"First pending block on fresh start should be the genesis block"
|
|
);
|
|
|
|
for block in &pending_blocks {
|
|
block_publisher
|
|
.publish_block(block, vec![])
|
|
.await
|
|
.unwrap_or_else(|err| {
|
|
panic!(
|
|
"Failed to publish block {} on fresh start: {err:#}",
|
|
block.header.block_id
|
|
)
|
|
});
|
|
}
|
|
}
|
|
|
|
let sequencer_core = Self {
|
|
state,
|
|
store,
|
|
mempool,
|
|
chain_height: latest_block_meta.id,
|
|
sequencer_config: config,
|
|
block_publisher,
|
|
};
|
|
|
|
(sequencer_core, mempool_handle)
|
|
}
|
|
|
|
fn on_checkpoint(dbio: Arc<RocksDBIO>) -> block_publisher::CheckpointSink {
|
|
Box::new(move |cp| {
|
|
let bytes = match serde_json::to_vec(&cp) {
|
|
Ok(b) => b,
|
|
Err(err) => {
|
|
error!("Failed to serialize zone-sdk checkpoint: {err:#}");
|
|
return;
|
|
}
|
|
};
|
|
if let Err(err) = dbio.put_zone_sdk_checkpoint_bytes(&bytes) {
|
|
error!("Failed to persist zone-sdk checkpoint: {err:#}");
|
|
}
|
|
})
|
|
}
|
|
|
|
fn on_finalized_block(dbio: Arc<RocksDBIO>) -> block_publisher::FinalizedBlockSink {
|
|
Box::new(move |block_id| {
|
|
// NOTE: Theoretically Zone SDK may report finalization happening multiple times for the
|
|
// same block. In practice this is very unlikely to happen. For that to
|
|
// happen Sequencer should crash between receiving Finalized and Checkpoint events while
|
|
// these events happen very fast (because Checkpoints are generated by Zone SDK
|
|
// locally).
|
|
|
|
if let Err(err) = dbio.clean_pending_blocks_up_to(block_id) {
|
|
error!("Failed to mark pending blocks finalized up to {block_id}: {err:#}");
|
|
}
|
|
|
|
match dbio.remove_fulfilled_pending_deposit_events_up_to_block(block_id) {
|
|
Ok(0) => {}
|
|
Ok(removed) => {
|
|
info!(
|
|
"Removed {removed} fulfilled pending deposit events up to finalized block {block_id}"
|
|
);
|
|
}
|
|
Err(err) => {
|
|
error!(
|
|
"Failed to remove fulfilled pending deposit events up to block {block_id}: {err:#}"
|
|
);
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
fn on_deposit_event(
|
|
dbio: Arc<RocksDBIO>,
|
|
mempool_handle: MemPoolHandle<(TransactionOrigin, LeeTransaction)>,
|
|
) -> block_publisher::OnDepositEventSink {
|
|
Box::new(move |deposit| {
|
|
// NOTE: Theoretically Zone SDK may report multiple identical deposits. In practice this
|
|
// is very unlikely to happen. For that to happen Sequencer should crash
|
|
// between receiving Deposit and Checkpoint events while these events happen
|
|
// very fast (because Checkpoints are generated by Zone SDK locally).
|
|
|
|
let dbio = Arc::clone(&dbio);
|
|
let mempool_handle = mempool_handle.clone();
|
|
|
|
Box::pin(async move {
|
|
let id_hex = hex::encode(deposit.op_id);
|
|
info!("Observed Bedrock Deposit event with id: {id_hex}");
|
|
|
|
let event_record = pending_deposit_event_record(&deposit);
|
|
|
|
match dbio.add_pending_deposit_event(event_record.clone()) {
|
|
Ok(true) => {}
|
|
Ok(false) => {
|
|
info!(
|
|
"Deposit event {id_hex} already persisted as unfulfilled, skipping duplicate enqueue",
|
|
);
|
|
return;
|
|
}
|
|
Err(err) => {
|
|
error!(
|
|
"Failed to persist unfulfilled deposit event {id_hex} before enqueue: {err:#}. Deposit will be lost.",
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
|
|
let tx = match build_bridge_deposit_tx_from_event(&event_record) {
|
|
Ok(tx) => tx,
|
|
Err(err) => {
|
|
error!(
|
|
"Failed to build transaction from Bedrock deposit event {id_hex}: {err:#}. Deposit will be lost.",
|
|
);
|
|
return;
|
|
}
|
|
};
|
|
|
|
if let Err(err) = mempool_handle
|
|
.push((TransactionOrigin::Sequencer, tx))
|
|
.await
|
|
{
|
|
error!(
|
|
"Failed to queue sequencer transaction built from finalized Bedrock event: {err:#}. Deposit will be lost."
|
|
);
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
fn on_withdraw_event(dbio: Arc<RocksDBIO>) -> block_publisher::OnWithdrawEventSink {
|
|
Box::new(move |withdraw| {
|
|
let dbio = Arc::clone(&dbio);
|
|
Box::pin(async move {
|
|
let hash_encoded = hex::encode(withdraw.tx_hash.as_ref());
|
|
let withdraw_key = match withdraw_event_reconciliation_key(&withdraw.op.outputs) {
|
|
Ok(key) => key,
|
|
Err(err) => {
|
|
error!(
|
|
"Failed to build reconciliation key for Bedrock Withdraw event with tx_hash {hash_encoded}: {err:#}"
|
|
);
|
|
return;
|
|
}
|
|
};
|
|
|
|
match dbio.consume_unseen_withdraw_count(withdraw_key) {
|
|
Ok(true) => {
|
|
info!("Validated Bedrock Withdraw event with tx_hash: {hash_encoded}");
|
|
}
|
|
Ok(false) => warn!(
|
|
"Unexpected Bedrock Withdraw event with tx_hash {hash_encoded}: no matching unseen withdraw found"
|
|
),
|
|
Err(err) => error!(
|
|
"Failed to reconcile Bedrock Withdraw event with tx_hash {hash_encoded}: {err:#}"
|
|
),
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
/// Produces a new block from mempool transactions and publishes it via zone-sdk.
|
|
pub async fn produce_new_block(&mut self) -> Result<u64> {
|
|
let BlockWithMeta {
|
|
block,
|
|
deposit_event_ids,
|
|
withdrawals,
|
|
} = self
|
|
.build_block_from_mempool()
|
|
.context("Failed to build block from mempool transactions")?;
|
|
|
|
let withdrawal_reconciliation_keys = withdrawals
|
|
.iter()
|
|
.map(|withdraw| withdraw_event_reconciliation_key(&withdraw.outputs))
|
|
.collect::<Result<_>>()
|
|
.context("Failed to build reconciliation keys for block withdrawals")?;
|
|
|
|
self.block_publisher
|
|
.publish_block(&block, withdrawals)
|
|
.await
|
|
.context("Failed to publish block to Bedrock")?;
|
|
|
|
self.store.update(
|
|
&block,
|
|
&deposit_event_ids,
|
|
withdrawal_reconciliation_keys,
|
|
&self.state,
|
|
)?;
|
|
|
|
Ok(self.chain_height)
|
|
}
|
|
|
|
/// Validates and applies a single mempool transaction to the current state.
|
|
/// Returns `Ok(true)` if the transaction was valid and applied, `Ok(false)` if
|
|
/// it was skipped due to validation failure.
|
|
fn apply_mempool_transaction(
|
|
&mut self,
|
|
origin: TransactionOrigin,
|
|
tx: &LeeTransaction,
|
|
block_height: u64,
|
|
timestamp: u64,
|
|
deposit_event_ids: &mut Vec<HashType>,
|
|
withdrawals: &mut Vec<WithdrawArg>,
|
|
) -> Result<bool> {
|
|
let tx_hash = tx.hash();
|
|
match origin {
|
|
TransactionOrigin::User => {
|
|
let validated_diff = match tx.validate_on_state(
|
|
&self.state,
|
|
block_height,
|
|
timestamp,
|
|
) {
|
|
Ok(diff) => diff,
|
|
Err(err) => {
|
|
error!(
|
|
"Transaction with hash {tx_hash} failed execution check with error: {err:#?}, skipping it",
|
|
);
|
|
return Ok(false);
|
|
}
|
|
};
|
|
|
|
if let Some(withdraw_data) = extract_bridge_withdraw_data(tx) {
|
|
withdrawals.push(withdraw_data);
|
|
}
|
|
|
|
self.state.apply_state_diff(validated_diff);
|
|
}
|
|
TransactionOrigin::Sequencer => {
|
|
let LeeTransaction::Public(public_tx) = tx else {
|
|
panic!("Sequencer may only generate Public transactions, found {tx:#?}");
|
|
};
|
|
|
|
if let Some(deposit_op_id) = extract_bridge_deposit_id(tx) {
|
|
deposit_event_ids.push(deposit_op_id);
|
|
}
|
|
|
|
self.state
|
|
.transition_from_public_transaction(public_tx, block_height, timestamp)
|
|
.context("Failed to execute sequencer-generated transaction")?;
|
|
}
|
|
}
|
|
|
|
info!("Validated transaction with hash {tx_hash}, including it in block");
|
|
Ok(true)
|
|
}
|
|
|
|
fn build_block_from_mempool(&mut self) -> Result<BlockWithMeta> {
|
|
let now = Instant::now();
|
|
|
|
let new_block_height = self.next_block_id();
|
|
|
|
let mut valid_transactions = Vec::new();
|
|
let mut deposit_event_ids = Vec::new();
|
|
let mut withdrawals = Vec::new();
|
|
|
|
let max_block_size = usize::try_from(self.sequencer_config.max_block_size.as_u64())
|
|
.expect("`max_block_size` should fit into usize");
|
|
|
|
let latest_block_meta = self
|
|
.store
|
|
.latest_block_meta()
|
|
.context("Failed to get latest block meta from store")?;
|
|
|
|
let new_block_timestamp = u64::try_from(chrono::Utc::now().timestamp_millis())
|
|
.expect("Timestamp must be positive");
|
|
|
|
let clock_tx = clock_invocation(new_block_timestamp);
|
|
let clock_lee_tx = LeeTransaction::Public(clock_tx.clone());
|
|
|
|
while let Some((origin, tx)) = self.mempool.pop() {
|
|
let tx_hash = tx.hash();
|
|
|
|
let temp_valid_transactions = [
|
|
valid_transactions.as_slice(),
|
|
std::slice::from_ref(&tx),
|
|
std::slice::from_ref(&clock_lee_tx),
|
|
]
|
|
.concat();
|
|
let temp_hashable_data = HashableBlockData {
|
|
block_id: new_block_height,
|
|
transactions: temp_valid_transactions,
|
|
prev_block_hash: latest_block_meta.hash,
|
|
timestamp: new_block_timestamp,
|
|
};
|
|
|
|
let block_size = borsh::to_vec(&temp_hashable_data)
|
|
.context("Failed to serialize block for size check")?
|
|
.len();
|
|
|
|
if block_size > max_block_size {
|
|
warn!(
|
|
"Transaction with hash {tx_hash} deferred to next block: \
|
|
block size {block_size} bytes would exceed limit of {max_block_size} bytes",
|
|
);
|
|
self.mempool.push_front((origin, tx));
|
|
break;
|
|
}
|
|
|
|
if self.apply_mempool_transaction(
|
|
origin,
|
|
&tx,
|
|
new_block_height,
|
|
new_block_timestamp,
|
|
&mut deposit_event_ids,
|
|
&mut withdrawals,
|
|
)? {
|
|
valid_transactions.push(tx);
|
|
}
|
|
|
|
if valid_transactions.len() >= self.sequencer_config.max_num_tx_in_block {
|
|
break;
|
|
}
|
|
}
|
|
|
|
self.state
|
|
.transition_from_public_transaction(&clock_tx, new_block_height, new_block_timestamp)
|
|
.context("Clock transaction failed. Aborting block production.")?;
|
|
valid_transactions.push(clock_lee_tx);
|
|
|
|
let hashable_data = HashableBlockData {
|
|
block_id: new_block_height,
|
|
transactions: valid_transactions,
|
|
prev_block_hash: latest_block_meta.hash,
|
|
timestamp: new_block_timestamp,
|
|
};
|
|
|
|
let block = hashable_data
|
|
.clone()
|
|
.into_pending_block(self.store.signing_key());
|
|
|
|
self.chain_height = new_block_height;
|
|
|
|
log::info!(
|
|
"Created block with {} transactions in {} seconds",
|
|
hashable_data.transactions.len(),
|
|
now.elapsed().as_secs()
|
|
);
|
|
|
|
Ok(BlockWithMeta {
|
|
block,
|
|
deposit_event_ids,
|
|
withdrawals,
|
|
})
|
|
}
|
|
|
|
pub const fn state(&self) -> &lee::V03State {
|
|
&self.state
|
|
}
|
|
|
|
pub const fn block_store(&self) -> &SequencerStore {
|
|
&self.store
|
|
}
|
|
|
|
pub const fn chain_height(&self) -> u64 {
|
|
self.chain_height
|
|
}
|
|
|
|
pub const fn sequencer_config(&self) -> &SequencerConfig {
|
|
&self.sequencer_config
|
|
}
|
|
|
|
/// Marks all pending blocks with `block_id <= last_finalized_block_id` as
|
|
/// finalized. Idempotent. Production callers don't invoke this directly —
|
|
/// it's wired up in `start_from_config` to the publisher's
|
|
/// `on_finalized_block` sink, which fires on `Event::TxsFinalized` /
|
|
/// `Event::FinalizedInscriptions`. Kept on the type for tests.
|
|
// TODO: Delete blocks instead of marking them as finalized. Current
|
|
// approach is used because we still have `GetBlockDataRequest`.
|
|
pub fn clean_finalized_blocks_from_db(&self, last_finalized_block_id: u64) -> Result<()> {
|
|
info!("Clearing pending blocks up to id: {last_finalized_block_id}");
|
|
self.store
|
|
.dbio()
|
|
.clean_pending_blocks_up_to(last_finalized_block_id)?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Returns the list of stored pending blocks.
|
|
pub fn get_pending_blocks(&self) -> Result<Vec<Block>> {
|
|
Ok(self
|
|
.store
|
|
.get_all_blocks()
|
|
.collect::<block_store::DbResult<Vec<Block>>>()?
|
|
.into_iter()
|
|
.filter(|block| matches!(block.bedrock_status, BedrockStatus::Pending))
|
|
.collect())
|
|
}
|
|
|
|
pub fn block_publisher(&self) -> BP {
|
|
self.block_publisher.clone()
|
|
}
|
|
|
|
fn next_block_id(&self) -> u64 {
|
|
self.chain_height
|
|
.checked_add(1)
|
|
.unwrap_or_else(|| panic!("Max block height reached: {}", self.chain_height))
|
|
}
|
|
}
|
|
|
|
struct BlockWithMeta {
|
|
block: Block,
|
|
deposit_event_ids: Vec<HashType>,
|
|
withdrawals: Vec<WithdrawArg>,
|
|
}
|
|
|
|
/// Checks the database for any pending deposit events that have not yet been marked as submitted in
|
|
/// a block, and re-queues them in the mempool in a separate async task for inclusion in the next
|
|
/// block.
|
|
fn replay_unfulfilled_deposit_events(
|
|
store: &SequencerStore,
|
|
mempool_handle: MemPoolHandle<(TransactionOrigin, LeeTransaction)>,
|
|
) {
|
|
let replay_records: Vec<PendingDepositEventRecord> = store
|
|
.get_unfulfilled_deposit_events()
|
|
.expect("Failed to load unfulfilled deposit events")
|
|
.into_iter()
|
|
.filter(|record| record.submitted_in_block_id.is_none())
|
|
.collect();
|
|
|
|
if replay_records.is_empty() {
|
|
return;
|
|
}
|
|
|
|
info!(
|
|
"Found {} unfulfilled deposit events in DB, re-queueing",
|
|
replay_records.len()
|
|
);
|
|
tokio::spawn(async move {
|
|
for record in replay_records {
|
|
let tx = match build_bridge_deposit_tx_from_event(&record) {
|
|
Ok(tx) => tx,
|
|
Err(err) => {
|
|
warn!(
|
|
"Skipping replay of pending deposit event {} due to tx build failure: {err:#}",
|
|
hex::encode(record.deposit_op_id)
|
|
);
|
|
continue;
|
|
}
|
|
};
|
|
|
|
if let Err(err) = mempool_handle
|
|
.push((TransactionOrigin::Sequencer, tx))
|
|
.await
|
|
{
|
|
error!(
|
|
"Failed to re-queue unfulfilled deposit event {} from DB: {err:#}",
|
|
hex::encode(record.deposit_op_id)
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/// Builds the initial genesis state from `testnet_initial_state` plus configured genesis
|
|
/// transactions. Returns the final state and the list of [`LeeTransaction`]s that should be
|
|
/// committed to the genesis block so external observers can replay them.
|
|
fn build_genesis_state(config: &SequencerConfig) -> (lee::V03State, Vec<LeeTransaction>) {
|
|
#[cfg(not(feature = "testnet"))]
|
|
let mut state = testnet_initial_state::initial_state();
|
|
|
|
#[cfg(feature = "testnet")]
|
|
let mut state = testnet_initial_state::initial_state_testnet();
|
|
|
|
let genesis_txs = config
|
|
.genesis
|
|
.iter()
|
|
.map(|genesis_tx| match genesis_tx {
|
|
GenesisAction::SupplyAccount {
|
|
account_id,
|
|
balance,
|
|
} => build_supply_account_genesis_transaction(account_id, *balance),
|
|
GenesisAction::SupplyBridgeAccount { balance } => {
|
|
build_supply_bridge_account_genesis_transaction(*balance)
|
|
}
|
|
})
|
|
.chain(std::iter::once(clock_invocation(0)))
|
|
.inspect(|tx| {
|
|
state
|
|
.transition_from_public_transaction(tx, GENESIS_BLOCK_ID, 0)
|
|
.expect("Failed to execute genesis transaction");
|
|
})
|
|
.map(LeeTransaction::Public)
|
|
.collect();
|
|
|
|
(state, genesis_txs)
|
|
}
|
|
|
|
fn build_supply_account_genesis_transaction(
|
|
account_id: &AccountId,
|
|
balance: u128,
|
|
) -> PublicTransaction {
|
|
let faucet_program_id = programs::faucet().id();
|
|
let vault_program_id = programs::vault().id();
|
|
let recipient_vault_id = vault_core::compute_vault_account_id(vault_program_id, *account_id);
|
|
|
|
let message = Message::try_new(
|
|
faucet_program_id,
|
|
vec![system_accounts::faucet_account_id(), recipient_vault_id],
|
|
vec![],
|
|
faucet_core::Instruction::GenesisTransferVault {
|
|
vault_program_id,
|
|
recipient_id: *account_id,
|
|
amount: balance,
|
|
},
|
|
)
|
|
.expect("Failed to serialize genesis transfer instruction");
|
|
let witness_set = lee::public_transaction::WitnessSet::from_raw_parts(vec![]);
|
|
|
|
PublicTransaction::new(message, witness_set)
|
|
}
|
|
|
|
fn build_supply_bridge_account_genesis_transaction(balance: u128) -> PublicTransaction {
|
|
let faucet_program_id = programs::faucet().id();
|
|
let bridge_account_id = system_accounts::bridge_account_id();
|
|
|
|
let message = Message::try_new(
|
|
faucet_program_id,
|
|
vec![system_accounts::faucet_account_id(), bridge_account_id],
|
|
vec![],
|
|
faucet_core::Instruction::GenesisTransferDirect { amount: balance },
|
|
)
|
|
.expect("Failed to serialize bridge genesis transfer instruction");
|
|
let witness_set = lee::public_transaction::WitnessSet::from_raw_parts(vec![]);
|
|
|
|
PublicTransaction::new(message, witness_set)
|
|
}
|
|
|
|
fn pending_deposit_event_record(deposit: &DepositInfo) -> PendingDepositEventRecord {
|
|
PendingDepositEventRecord {
|
|
deposit_op_id: HashType(deposit.op_id),
|
|
source_tx_hash: HashType(deposit.tx_hash.0),
|
|
amount: deposit.amount,
|
|
metadata: deposit.metadata.clone().into(),
|
|
submitted_in_block_id: None,
|
|
}
|
|
}
|
|
|
|
fn build_bridge_deposit_tx_from_event(event: &PendingDepositEventRecord) -> Result<LeeTransaction> {
|
|
let metadata = DepositMetadata::decode(&event.metadata)
|
|
.context("Failed to decode finalized Bedrock deposit metadata")?;
|
|
|
|
let bridge_program_id = programs::bridge().id();
|
|
let vault_program_id = programs::vault().id();
|
|
let recipient_vault_id =
|
|
vault_core::compute_vault_account_id(vault_program_id, metadata.recipient_id);
|
|
|
|
let message = Message::try_new(
|
|
bridge_program_id,
|
|
vec![system_accounts::bridge_account_id(), recipient_vault_id],
|
|
vec![],
|
|
bridge_core::Instruction::Deposit {
|
|
l1_deposit_op_id: event.deposit_op_id.0,
|
|
vault_program_id,
|
|
recipient_id: metadata.recipient_id,
|
|
amount: event.amount,
|
|
},
|
|
)
|
|
.context("Failed to build bridge deposit message")?;
|
|
|
|
let witness_set = lee::public_transaction::WitnessSet::from_raw_parts(vec![]);
|
|
Ok(LeeTransaction::Public(PublicTransaction::new(
|
|
message,
|
|
witness_set,
|
|
)))
|
|
}
|
|
|
|
#[must_use]
|
|
fn extract_bridge_deposit_id(tx: &LeeTransaction) -> Option<HashType> {
|
|
let LeeTransaction::Public(tx) = tx else {
|
|
return None;
|
|
};
|
|
|
|
let message = tx.message();
|
|
if message.program_id != programs::bridge().id() {
|
|
return None;
|
|
}
|
|
|
|
let instruction =
|
|
risc0_zkvm::serde::from_slice::<bridge_core::Instruction, u32>(&message.instruction_data)
|
|
.ok()?;
|
|
|
|
match instruction {
|
|
bridge_core::Instruction::Deposit {
|
|
l1_deposit_op_id, ..
|
|
} => Some(HashType(l1_deposit_op_id)),
|
|
bridge_core::Instruction::Withdraw { .. } => None,
|
|
}
|
|
}
|
|
|
|
#[must_use]
|
|
fn extract_bridge_withdraw_data(tx: &LeeTransaction) -> Option<WithdrawArg> {
|
|
let LeeTransaction::Public(tx) = tx else {
|
|
return None;
|
|
};
|
|
|
|
let message = tx.message();
|
|
if message.program_id != programs::bridge().id() {
|
|
return None;
|
|
}
|
|
|
|
let instruction =
|
|
risc0_zkvm::serde::from_slice::<bridge_core::Instruction, u32>(&message.instruction_data)
|
|
.ok()?;
|
|
|
|
let bridge_core::Instruction::Withdraw {
|
|
amount,
|
|
bedrock_account_pk,
|
|
} = instruction
|
|
else {
|
|
return None;
|
|
};
|
|
|
|
let recipient_pk = logos_blockchain_key_management_system_service::keys::ZkPublicKey::from(
|
|
BigUint::from_bytes_le(&bedrock_account_pk),
|
|
);
|
|
|
|
Some(WithdrawArg {
|
|
outputs: logos_blockchain_core::mantle::ledger::Outputs::new(
|
|
logos_blockchain_core::mantle::Note::new(amount, recipient_pk),
|
|
),
|
|
})
|
|
}
|
|
|
|
fn withdraw_event_reconciliation_key(
|
|
outputs: &logos_blockchain_core::mantle::ledger::Outputs,
|
|
) -> Result<WithdrawalReconciliationKey> {
|
|
let [note] = outputs.as_ref().as_slice() else {
|
|
return Err(anyhow!(
|
|
"Unsupported withdraw output count for reconciliation: {}",
|
|
outputs.len()
|
|
));
|
|
};
|
|
|
|
// `extract_bridge_withdraw_data` maps [u8;32] LE -> BigUint -> ZkPublicKey.
|
|
// Reconcile by reversing that direction here.
|
|
let mut bedrock_account_pk = BigUint::from(note.pk.into_inner()).to_bytes_le();
|
|
if bedrock_account_pk.len() > 32 {
|
|
return Err(anyhow!(
|
|
"Withdraw recipient public key is too large: {} bytes",
|
|
bedrock_account_pk.len()
|
|
));
|
|
}
|
|
bedrock_account_pk.resize(32, 0);
|
|
|
|
let bedrock_account_pk: [u8; 32] = bedrock_account_pk
|
|
.try_into()
|
|
.expect("Public key bytes were padded/truncated to 32 bytes");
|
|
|
|
Ok(WithdrawalReconciliationKey {
|
|
amount: note.value,
|
|
bedrock_account_pk,
|
|
})
|
|
}
|
|
|
|
/// Load signing key from file or generate a new one if it doesn't exist.
|
|
fn load_or_create_signing_key(path: &Path) -> Result<Ed25519Key> {
|
|
if path.exists() {
|
|
let key_bytes = std::fs::read(path)?;
|
|
|
|
let key_array: [u8; ED25519_SECRET_KEY_SIZE] = key_bytes
|
|
.try_into()
|
|
.map_err(|_bytes| anyhow!("Found key with incorrect length"))?;
|
|
|
|
Ok(Ed25519Key::from_bytes(&key_array))
|
|
} else {
|
|
let mut key_bytes = [0_u8; ED25519_SECRET_KEY_SIZE];
|
|
rand::RngCore::fill_bytes(&mut rand::thread_rng(), &mut key_bytes);
|
|
// Create parent directory if it doesn't exist
|
|
if let Some(parent) = path.parent() {
|
|
std::fs::create_dir_all(parent)?;
|
|
}
|
|
std::fs::write(path, key_bytes)?;
|
|
Ok(Ed25519Key::from_bytes(&key_bytes))
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[cfg(feature = "mock")]
|
|
mod tests;
|