Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
135 changes: 111 additions & 24 deletions node/src/aggregates/instance.rs
Original file line number Diff line number Diff line change
Expand Up @@ -399,6 +399,9 @@ pub enum InstanceAlert {
/// Goat refused the data of a confirmed peg-in for good: no instance
/// parameters stored, no graph started by this operator.
ConfirmInstanceRejected,
/// The committee answers do not yield the peg-in transactions; the instance
/// is failed instead of waiting forever for a Prepare nobody can build.
PeginTxidsUnderivable,
}

impl InstanceAlert {
Expand All @@ -411,6 +414,7 @@ impl InstanceAlert {
InstanceAlert::PeginConfirmRoundFailed => "pegin_confirm_round_failed",
InstanceAlert::AnswerPeginRequestFailed => "answer_pegin_request_failed",
InstanceAlert::ConfirmInstanceRejected => "confirm_instance_rejected",
InstanceAlert::PeginTxidsUnderivable => "pegin_txids_underivable",
}
}
}
Expand Down Expand Up @@ -636,11 +640,21 @@ pub async fn signing_gate(
if status.is_failed() {
return Ok(SigningGate::Closed(format!("instance is {status}")));
}
if instance.btc_height <= 0 {
return Ok(SigningGate::Open);
let mut prepare_height = instance.btc_height;
if prepare_height <= 0 {
// The scan has not stored the Prepare height yet; ask Bitcoin rather than
// signing blind, since T0 may already have passed on a lagging node.
let Some(prepare_txid) = instance.btc_txid.clone() else {
anyhow::bail!("instance {instance_id} has no Peg-In-Prepare txid yet");
};
match btc_client.get_tx_info(&prepare_txid.0).await?.and_then(|tx| tx.status.block_height) {
Some(height) => prepare_height = i64::from(height),
// T0 counts from the Prepare confirmation, which has not happened.
None => return Ok(SigningGate::Open),
}
}
let height = i64::from(btc_client.get_height().await?);
Ok(signing_gate_for(status, instance.btc_height, height, &PeginDeadlines::from_env()))
Ok(signing_gate_for(status, prepare_height, height, &PeginDeadlines::from_env()))
}

// -------------------------------------------------------------------- handler
Expand Down Expand Up @@ -702,10 +716,32 @@ impl InstanceAggregate {
ctx: &mut ApplyContext<'_>,
instance: &Instance,
status: InstanceBridgeInStatus,
transition: Transition,
mut transition: Transition,
) -> anyhow::Result<()> {
let instance_id = instance.instance_id;
let mut final_status = status;
// The answers fix the three peg-in txids. Answers they cannot be derived
// from never will be: fail the instance and say so.
let mut pegin_txids_derived = None;
if transition.next == Some(InstanceBridgeInStatus::CommitteesAnswered)
&& let Some(answers) = transition.committees_answers.clone()
{
let mut seeded = instance.clone();
seeded.committees_answers = answers;
match pegin_txids(&seeded) {
Ok(txids) => pegin_txids_derived = Some(txids),
Err(error) => {
warn!(
event = "instance_transition",
instance_id = %instance_id,
error = %error,
"could not derive the peg-in txids from the committee answers; failing the instance"
);
transition.next = Some(InstanceBridgeInStatus::NoEnoughCommitteesAnswered);
transition.alerts.push(InstanceAlert::PeginTxidsUnderivable);
}
}
}
if let Some(next) = transition.next.filter(|next| *next != status) {
let mut update = InstanceUpdate::new_with_instance_id(instance_id)
.with_status(next.to_string())
Expand All @@ -714,25 +750,13 @@ impl InstanceAggregate {
update = update.with_btc_height(height);
}
if let Some(answers) = transition.committees_answers.clone() {
update = update.with_committees_answers(answers.clone());
if next == InstanceBridgeInStatus::CommitteesAnswered {
let mut seeded = instance.clone();
seeded.committees_answers = answers;
match pegin_txids(&seeded) {
Ok((deposit, confirm, cancel)) => {
update = update
.with_btc_txid(deposit)
.with_pegin_confirm_txid(confirm)
.with_pegin_cancel_txid(cancel);
}
Err(error) => warn!(
event = "instance_transition",
instance_id = %instance_id,
error = %error,
"could not derive the peg-in txids from the committee answers"
),
}
}
update = update.with_committees_answers(answers);
}
if let Some((deposit, confirm, cancel)) = pegin_txids_derived {
update = update
.with_btc_txid(deposit)
.with_pegin_confirm_txid(confirm)
.with_pegin_cancel_txid(cancel);
}
if let Some(tx_hash) = transition.post_pegin_txhash.clone() {
update = update.with_post_pegin(tx_hash);
Expand Down Expand Up @@ -794,7 +818,18 @@ impl InstanceAggregate {
}
}
RelayerL1Broadcasted => {
self.close_confirm_round(ctx, instance.instance_id, "Peg-In-Confirm confirmed");
// The nonce rounds are over, but the relayer still needs every
// member's PeginConfirmPartialSig (it carries the endorsement for
// postPeginData): that row keeps being resent until L2Minted.
for kind in ["PeginConfirmNonce", "PeginConfirmNonceConsensus"] {
ctx.effects.close_outbox(
EngineOutboxCloseTarget::Row(format!(
"instance:{}:{kind}",
instance.instance_id
)),
"Peg-In-Confirm confirmed",
);
}
if self.relayer {
self.job(ctx, JOB_POST_PEGIN_DATA, Vec::new());
}
Expand Down Expand Up @@ -1605,6 +1640,58 @@ mod tests {
}
}

#[tokio::test]
async fn signing_gate_without_a_stored_prepare_height_asks_bitcoin() {
use bitcoin::hashes::Hash;
let db = store::create_local_db("sqlite::memory:").await;
let (btc, mock) = BTCClient::new_mock_client();
let prepare = bitcoin::Txid::from_byte_array([7; 32]);
let mut row = Instance {
instance_id: Uuid::new_v4(),
network: "regtest".to_string(),
input_utxos: "[]".to_string(),
status: Presigned.to_string(),
created_at: 1,
updated_at: 1,
..Default::default()
};
db.acquire().await.unwrap().insert_instance_if_absent(&row).await.unwrap();
assert!(
signing_gate(&db, &btc, row.instance_id).await.is_err(),
"no Prepare txid: undecided, retried"
);

row.instance_id = Uuid::new_v4();
row.btc_txid = Some(prepare.into());
db.acquire().await.unwrap().insert_instance_if_absent(&row).await.unwrap();
assert!(signing_gate(&db, &btc, row.instance_id).await.unwrap().is_open(), "unconfirmed");

mock.set_tx(
prepare,
esplora_client::Tx {
txid: prepare,
version: 2,
locktime: 0,
vin: Vec::new(),
vout: Vec::new(),
size: 0,
weight: 0,
status: esplora_client::TxStatus {
confirmed: true,
block_height: Some(100),
block_hash: None,
block_time: None,
},
fee: 0,
},
);
mock.set_height(100 + 1_000_000);
assert!(
!signing_gate(&db, &btc, row.instance_id).await.unwrap().is_open(),
"T0 counted from the confirmed Prepare"
);
}

#[test]
fn phases_follow_the_phase_table() {
assert_eq!(phase_of(UserInited), PHASE_ANSWER);
Expand Down
9 changes: 6 additions & 3 deletions node/src/aggregates/instance_jobs.rs
Original file line number Diff line number Diff line change
Expand Up @@ -35,7 +35,7 @@ use crate::utils::{
get_committee_pub_nonce_for_instance, get_committee_pub_nonces_for_instance,
get_graph_by_instance_id_and_operator_pubkey, get_instance_parameters,
has_required_presigned_graphs, is_io_not_found_error, order_committee_values,
read_instance_info_from_goat, read_pegin_request,
pegin_inputs_answerable, read_instance_info_from_goat, read_pegin_request,
store_committee_agg_nonce_consensus_for_instance, store_committee_endorse_sig_for_pegin,
store_committee_partial_sig_for_instance, store_committee_pub_nonce_for_instance,
store_instance_parameters, tx_visible, verify_pegin_endorsement,
Expand Down Expand Up @@ -252,14 +252,17 @@ async fn answer_pegin_request(deps: &JobDeps, instance_id: Uuid) -> Result<Step>
Some(InstanceBridgeInStatus::UserInited) => {}
other => return Step::ignore(format!("instance is {other:?}; answer window closed")),
}
let (_, _, answered_by) =
read_pegin_request(&deps.btc_client, &deps.goat_client, instance_id).await?;
let (user_info, _, answered_by) = read_pegin_request(&deps.goat_client, instance_id).await?;
// Gateway.answerPeginRequest accepts a repeat answer (it overwrites the
// stored pubkey and emits CommitteeResponse again), so every re-run must
// check what the contract already holds for this signer.
if answered_by.contains(&deps.goat_client.get_default_signer_address()) {
return Step::ignore("this committee already answered");
}
// Retried until the inputs settle; leaving UserInited cancels this job.
if let Some(reason) = pegin_inputs_answerable(&deps.btc_client, &user_info.inputs).await? {
return Step::retry(reason, 30);
}
let committee_master_key = CommitteeMasterKey::new(get_bitvm_key()?);
let instance_keypair = load_or_create_committee_instance_keypair(
&deps.local_db,
Expand Down
55 changes: 38 additions & 17 deletions node/src/aggregates/instance_scan.rs
Original file line number Diff line number Diff line change
Expand Up @@ -33,6 +33,9 @@ use uuid::Uuid;

const TASK_KEY_ANSWER_WINDOW: &str = "instance_answer_window_scan";
const TASK_KEY_BTC: &str = "instance_btc_scan";
/// Instances parked in CommitteesAnswered or Timeout page separately: many
/// never move again and must not use up the live instances' budget.
const TASK_KEY_BTC_PARKED: &str = "instance_btc_scan_parked";
const SCAN_MARKS_LIMIT: usize = 50_000;

// ----------------------------------------------------------------- paging
Expand Down Expand Up @@ -177,41 +180,46 @@ fn mark_settled_timeout(instance_id: Uuid) {
settled.insert(instance_id);
}

/// Statuses the Bitcoin scan follows. The key-deletion statuses are only
/// followed on committee nodes with deletion enabled.
fn scanned_statuses(actor: &Actor) -> (Vec<String>, bool) {
/// Statuses the Bitcoin scan follows: the live ones and the parked ones,
/// paged apart. The key-deletion statuses are only followed on committee
/// nodes with deletion enabled.
fn scanned_statuses(actor: &Actor) -> (Vec<String>, Vec<String>, bool) {
use InstanceBridgeInStatus::*;
let key_scan = *actor == Actor::Committee && is_enable_committee_instance_key_delete();
let mut statuses = vec![CommitteesAnswered, UserBroadcastPeginPrepare, Presigned, Timeout];
let mut live = vec![UserBroadcastPeginPrepare, Presigned];
if key_scan {
statuses.extend([RelayerL1Broadcasted, RelayerL2Minted]);
live.extend([RelayerL1Broadcasted, RelayerL2Minted]);
}
(statuses.iter().map(ToString::to_string).collect(), key_scan)
let parked = [CommitteesAnswered, Timeout];
(
live.iter().map(ToString::to_string).collect(),
parked.iter().map(ToString::to_string).collect(),
key_scan,
)
}

/// Record a Bitcoin snapshot for every live instance.
/// Record a Bitcoin snapshot for every scanned instance: one page of the live
/// instances and one page of the parked ones per tick.
pub async fn scan_instances_on_bitcoin(
local_db: &LocalDB,
btc_client: &BTCClient,
engine: &EngineHandle,
actor: &Actor,
) -> anyhow::Result<()> {
let (statuses, key_scan) = scanned_statuses(actor);
let mut query = InstanceQuery::default().with_statuses(statuses);
let (live, parked, key_scan) = scanned_statuses(actor);
let mut live_query = InstanceQuery::default().with_statuses(live);
if key_scan {
query = query.with_raw_condition(format!(
live_query = live_query.with_raw_condition(format!(
"(status NOT IN ('{}', '{}') OR key_deleted = 0)",
InstanceBridgeInStatus::RelayerL1Broadcasted,
InstanceBridgeInStatus::RelayerL2Minted
));
}
let instances = find_one_instance_page(
local_db,
TASK_KEY_BTC,
query,
get_instance_maintenance_batch_size(),
)
.await?;
let batch = get_instance_maintenance_batch_size();
let mut instances = find_one_instance_page(local_db, TASK_KEY_BTC, live_query, batch).await?;
let parked_query = InstanceQuery::default().with_statuses(parked);
instances
.extend(find_one_instance_page(local_db, TASK_KEY_BTC_PARKED, parked_query, batch).await?);
if instances.is_empty() {
return Ok(());
}
Expand Down Expand Up @@ -583,6 +591,19 @@ mod tests {
use client::goat_chain::{PeginData, PeginStatus};
use store::GoatTxType;

#[test]
fn parked_instances_do_not_share_the_live_page() {
use InstanceBridgeInStatus::*;
let (live, parked, _) = scanned_statuses(&Actor::Operator);
for status in [CommitteesAnswered, Timeout] {
assert!(parked.contains(&status.to_string()) && !live.contains(&status.to_string()));
}
for status in [UserBroadcastPeginPrepare, Presigned] {
assert!(live.contains(&status.to_string()) && !parked.contains(&status.to_string()));
}
assert_ne!(TASK_KEY_BTC, TASK_KEY_BTC_PARKED);
}

async fn database() -> (LocalDB, tempfile::TempDir) {
let dir = tempfile::tempdir().unwrap();
let db = LocalDB::new_with_busy_timeout(
Expand Down
Loading
Loading