From c9b6df2be90239219da946bb74493f4ffedce9a7 Mon Sep 17 00:00:00 2001 From: moudyellaz Date: Fri, 10 Jul 2026 19:02:23 +0200 Subject: [PATCH] chore(cross-zone): remove stale old-style program_methods guest bins --- program_methods/guest/src/bin/bridge_lock.rs | 121 ----------------- .../guest/src/bin/cross_zone_inbox.rs | 127 ------------------ .../guest/src/bin/cross_zone_outbox.rs | 72 ---------- .../guest/src/bin/ping_receiver.rs | 48 ------- program_methods/guest/src/bin/ping_sender.rs | 59 -------- .../guest/src/bin/wrapped_token.rs | 70 ---------- 6 files changed, 497 deletions(-) delete mode 100644 program_methods/guest/src/bin/bridge_lock.rs delete mode 100644 program_methods/guest/src/bin/cross_zone_inbox.rs delete mode 100644 program_methods/guest/src/bin/cross_zone_outbox.rs delete mode 100644 program_methods/guest/src/bin/ping_receiver.rs delete mode 100644 program_methods/guest/src/bin/ping_sender.rs delete mode 100644 program_methods/guest/src/bin/wrapped_token.rs diff --git a/program_methods/guest/src/bin/bridge_lock.rs b/program_methods/guest/src/bin/bridge_lock.rs deleted file mode 100644 index 75e0e871..00000000 --- a/program_methods/guest/src/bin/bridge_lock.rs +++ /dev/null @@ -1,121 +0,0 @@ -use bridge_lock_core::{Instruction, balance_bytes, escrow_account_id, escrow_seed, read_balance}; -use cross_zone_outbox_core::Instruction as OutboxInstruction; -use lee_core::{ - account::AccountWithMetadata, - program::{AccountPostState, ChainedCall, Claim, ProgramInput, ProgramOutput, read_lee_inputs}, -}; -use wrapped_token_core::Instruction as WrappedInstruction; - -fn main() { - let ( - ProgramInput { - self_program_id, - caller_program_id, - pre_states, - instruction, - }, - instruction_words, - ) = read_lee_inputs::(); - - assert!( - caller_program_id.is_none(), - "bridge_lock is only invoked as a top-level user transaction" - ); - - let Instruction::Lock { - amount, - target_zone, - target_program_id, - target_accounts, - payload, - outbox_program_id, - ordinal, - } = instruction; - - // Value conservation: the forwarded payload must mint exactly what is locked. - let WrappedInstruction::Mint { - amount: mint_amount, - .. - } = decode_mint(&payload); - assert_eq!( - mint_amount, amount, - "locked amount must equal the wrapped mint amount" - ); - - // pre_states: [holder holding (authorized), escrow PDA, outbox PDA]. - let [holder, escrow, outbox] = <[AccountWithMetadata; 3]>::try_from(pre_states) - .expect("Lock requires holder, escrow, and outbox accounts"); - - assert!(holder.is_authorized, "holder must authorize the lock"); - assert_eq!( - holder.account.program_owner, self_program_id, - "holder account must be a bridge_lock holding" - ); - assert_eq!( - escrow.account_id, - escrow_account_id(self_program_id), - "second account must be the escrow PDA" - ); - - let holder_new = read_balance(&holder.account.data.clone().into_inner()) - .checked_sub(amount) - .expect("insufficient balance to lock"); - let escrow_new = read_balance(&escrow.account.data.clone().into_inner()) - .checked_add(amount) - .expect("escrow balance overflow"); - - let mut holder_account = holder.account.clone(); - holder_account.data = balance_bytes(holder_new) - .to_vec() - .try_into() - .expect("balance fits in account data"); - let holder_post = AccountPostState::new(holder_account); - - let mut escrow_account = escrow.account.clone(); - escrow_account.data = balance_bytes(escrow_new) - .to_vec() - .try_into() - .expect("balance fits in account data"); - let escrow_post = - AccountPostState::new_claimed_if_default(escrow_account, Claim::Pda(escrow_seed())); - - let call = ChainedCall::new( - outbox_program_id, - vec![outbox.clone()], - &OutboxInstruction::Emit { - target_zone, - target_program_id, - target_accounts, - payload, - ordinal, - }, - ); - - ProgramOutput::new( - self_program_id, - caller_program_id, - instruction_words, - vec![holder, escrow, outbox.clone()], - vec![ - holder_post, - escrow_post, - AccountPostState::new(outbox.account), - ], - ) - .with_chained_calls(vec![call]) - .write(); -} - -/// Decodes the cross-zone payload (risc0 words, little-endian bytes) into the -/// wrapped-token instruction it carries. -fn decode_mint(payload: &[u8]) -> WrappedInstruction { - assert!( - payload.len() % 4 == 0, - "payload must be u32-aligned instruction words" - ); - let words: Vec = payload - .chunks_exact(4) - .map(|chunk| u32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]])) - .collect(); - risc0_zkvm::serde::from_slice(&words).expect("payload decodes to a wrapped-token instruction") -} diff --git a/program_methods/guest/src/bin/cross_zone_inbox.rs b/program_methods/guest/src/bin/cross_zone_inbox.rs deleted file mode 100644 index 41a1015b..00000000 --- a/program_methods/guest/src/bin/cross_zone_inbox.rs +++ /dev/null @@ -1,127 +0,0 @@ -use cross_zone_inbox_core::{ - InboxConfig, Instruction, SeenShard, inbox_config_account_id, inbox_seen_shard_account_id, - inbox_seen_shard_seed, message_key, -}; -use lee_core::{ - account::AccountWithMetadata, - program::{AccountPostState, ChainedCall, Claim, ProgramInput, ProgramOutput, read_lee_inputs}, -}; - -fn unchanged(pre: &AccountWithMetadata) -> AccountPostState { - AccountPostState::new(pre.account.clone()) -} - -fn main() { - let ( - ProgramInput { - self_program_id, - caller_program_id, - pre_states, - instruction, - }, - instruction_words, - ) = read_lee_inputs::(); - - assert!( - caller_program_id.is_none(), - "Inbox is only invoked as a top-level sequencer-origin transaction" - ); - - let msg = match instruction { - Instruction::Dispatch(msg) => msg, - }; - - assert!( - msg.l1_inclusion_witness.is_none(), - "l1_inclusion_witness must be None in v1" - ); - - // pre_states layout: [config, seen_shard, then the target accounts]. - let mut accounts = pre_states.into_iter(); - let config = accounts.next().expect("config account required"); - let seen = accounts.next().expect("seen shard account required"); - let target_accounts: Vec = accounts.collect(); - - assert_eq!( - config.account_id, - inbox_config_account_id(self_program_id), - "First account must be the inbox config PDA" - ); - assert_eq!( - seen.account_id, - inbox_seen_shard_account_id(self_program_id, &msg.src_zone, msg.src_block_id), - "Second account must be the seen-shard PDA" - ); - - let cfg = InboxConfig::from_bytes(&config.account.data.clone().into_inner()) - .expect("inbox config decodes"); - - assert!( - msg.src_zone != cfg.self_zone, - "Source zone must not be this zone" - ); - let allowed_targets = cfg - .allowed_targets - .get(&msg.src_zone) - .expect("Source zone is not an allowed peer"); - assert!( - allowed_targets.contains(&msg.target_program_id), - "Target program is not allowed for this peer" - ); - - let key = message_key(&msg.src_zone, msg.src_block_id, msg.src_tx_index); - let mut shard = - SeenShard::from_bytes(&seen.account.data.clone().into_inner()).expect("seen shard decodes"); - let already_seen = shard.contains(&key); - - // On replay this is a no-op: the seen shard is untouched and no call is made. - let (seen_post, chained_calls) = if already_seen { - (unchanged(&seen), vec![]) - } else { - shard.insert(key); - let mut seen_account = seen.account.clone(); - seen_account.data = shard - .to_bytes() - .try_into() - .expect("seen shard fits in account data"); - let seen_post = AccountPostState::new_claimed_if_default( - seen_account, - Claim::Pda(inbox_seen_shard_seed(&msg.src_zone, msg.src_block_id)), - ); - - // The payload carries the target instruction as risc0 words, little-endian. - assert!( - msg.payload.len() % 4 == 0, - "payload must be u32-aligned instruction words" - ); - let instruction_data = msg - .payload - .chunks_exact(4) - .map(|c| u32::from_le_bytes([c[0], c[1], c[2], c[3]])) - .collect(); - - let call = ChainedCall { - program_id: msg.target_program_id, - pre_states: target_accounts.clone(), - instruction_data, - pda_seeds: vec![], - }; - (seen_post, vec![call]) - }; - - let mut post_states = vec![unchanged(&config), seen_post]; - post_states.extend(target_accounts.iter().map(unchanged)); - - let mut pre_states = vec![config, seen]; - pre_states.extend(target_accounts); - - ProgramOutput::new( - self_program_id, - caller_program_id, - instruction_words, - pre_states, - post_states, - ) - .with_chained_calls(chained_calls) - .write(); -} diff --git a/program_methods/guest/src/bin/cross_zone_outbox.rs b/program_methods/guest/src/bin/cross_zone_outbox.rs deleted file mode 100644 index 432e8d9c..00000000 --- a/program_methods/guest/src/bin/cross_zone_outbox.rs +++ /dev/null @@ -1,72 +0,0 @@ -use cross_zone_outbox_core::{Instruction, OutboxRecord, outbox_pda, outbox_pda_seed}; -use lee_core::{ - account::AccountWithMetadata, - program::{AccountPostState, Claim, ProgramInput, ProgramOutput, read_lee_inputs}, -}; - -fn main() { - let ( - ProgramInput { - self_program_id, - caller_program_id, - pre_states, - instruction, - }, - instruction_words, - ) = read_lee_inputs::(); - - assert!( - caller_program_id.is_some(), - "Outbox is only callable through a chain call from a user program" - ); - - let (target_zone, target_program_id, target_accounts, payload, ordinal) = match instruction { - Instruction::Emit { - target_zone, - target_program_id, - target_accounts, - payload, - ordinal, - } => ( - target_zone, - target_program_id, - target_accounts, - payload, - ordinal, - ), - }; - - let [outbox] = - <[AccountWithMetadata; 1]>::try_from(pre_states).expect("Emit requires exactly 1 account"); - - assert_eq!( - outbox.account_id, - outbox_pda(self_program_id, &target_zone, ordinal), - "Account must be the outbox PDA for (target_zone, ordinal)" - ); - - let mut post_account = outbox.account.clone(); - post_account.data = OutboxRecord { - target_zone, - target_program_id, - target_accounts, - payload, - } - .to_bytes() - .try_into() - .expect("OutboxRecord fits in account data"); - - let post = AccountPostState::new_claimed_if_default( - post_account, - Claim::Pda(outbox_pda_seed(&target_zone, ordinal)), - ); - - ProgramOutput::new( - self_program_id, - caller_program_id, - instruction_words, - vec![outbox], - vec![post], - ) - .write(); -} diff --git a/program_methods/guest/src/bin/ping_receiver.rs b/program_methods/guest/src/bin/ping_receiver.rs deleted file mode 100644 index 4fd9679f..00000000 --- a/program_methods/guest/src/bin/ping_receiver.rs +++ /dev/null @@ -1,48 +0,0 @@ -use lee_core::{ - account::AccountWithMetadata, - program::{AccountPostState, Claim, ProgramInput, ProgramOutput, read_lee_inputs}, -}; -use ping_core::{ReceiverInstruction, ping_record_pda, ping_record_seed}; - -fn main() { - let ( - ProgramInput { - self_program_id, - caller_program_id, - pre_states, - instruction, - }, - instruction_words, - ) = read_lee_inputs::(); - - assert!( - caller_program_id.is_some(), - "ping_receiver is only callable through a chained call" - ); - - let payload = match instruction { - ReceiverInstruction::Record { payload } => payload, - }; - - let [record] = <[AccountWithMetadata; 1]>::try_from(pre_states) - .expect("Record requires exactly 1 account"); - assert_eq!( - record.account_id, - ping_record_pda(self_program_id), - "Account must be the ping record PDA" - ); - - let mut post_account = record.account.clone(); - post_account.data = payload.try_into().expect("payload fits in account data"); - let post = - AccountPostState::new_claimed_if_default(post_account, Claim::Pda(ping_record_seed())); - - ProgramOutput::new( - self_program_id, - caller_program_id, - instruction_words, - vec![record], - vec![post], - ) - .write(); -} diff --git a/program_methods/guest/src/bin/ping_sender.rs b/program_methods/guest/src/bin/ping_sender.rs deleted file mode 100644 index d0ad04f5..00000000 --- a/program_methods/guest/src/bin/ping_sender.rs +++ /dev/null @@ -1,59 +0,0 @@ -use cross_zone_outbox_core::Instruction as OutboxInstruction; -use lee_core::{ - account::AccountWithMetadata, - program::{AccountPostState, ChainedCall, ProgramInput, ProgramOutput, read_lee_inputs}, -}; -use ping_core::SenderInstruction; - -fn main() { - let ( - ProgramInput { - self_program_id, - caller_program_id, - pre_states, - instruction, - }, - instruction_words, - ) = read_lee_inputs::(); - - assert!( - caller_program_id.is_none(), - "ping_sender is only invoked as a top-level user transaction" - ); - - let SenderInstruction::Send { - outbox_program_id, - target_zone, - target_program_id, - target_accounts, - payload, - ordinal, - } = instruction; - - // The single account is the outbox PDA the chained call writes into; the - // outbox claims it, so ping_sender forwards it unchanged. - let [outbox] = - <[AccountWithMetadata; 1]>::try_from(pre_states).expect("Send requires exactly 1 account"); - - let call = ChainedCall::new( - outbox_program_id, - vec![outbox.clone()], - &OutboxInstruction::Emit { - target_zone, - target_program_id, - target_accounts, - payload, - ordinal, - }, - ); - - ProgramOutput::new( - self_program_id, - caller_program_id, - instruction_words, - vec![outbox.clone()], - vec![AccountPostState::new(outbox.account)], - ) - .with_chained_calls(vec![call]) - .write(); -} diff --git a/program_methods/guest/src/bin/wrapped_token.rs b/program_methods/guest/src/bin/wrapped_token.rs deleted file mode 100644 index d0e7595f..00000000 --- a/program_methods/guest/src/bin/wrapped_token.rs +++ /dev/null @@ -1,70 +0,0 @@ -use lee_core::{ - account::AccountWithMetadata, - program::{AccountPostState, Claim, ProgramInput, ProgramOutput, read_lee_inputs}, -}; -use wrapped_token_core::{ - Instruction, balance_bytes, config_account_id, holding_account_id, holding_seed, read_balance, - read_minter, -}; - -fn main() { - let ( - ProgramInput { - self_program_id, - caller_program_id, - pre_states, - instruction, - }, - instruction_words, - ) = read_lee_inputs::(); - - let Instruction::Mint { recipient, amount } = instruction; - - // pre_states: [config PDA, recipient holding PDA]. - let [config, holding] = <[AccountWithMetadata; 2]>::try_from(pre_states) - .expect("Mint requires the config and recipient holding accounts"); - - // The config PDA is genesis-seeded with the authorized minter (the cross-zone - // inbox). Pin the caller to it, since the guest cannot import the inbox id. - assert_eq!( - config.account_id, - config_account_id(self_program_id), - "first account must be the wrapped-token config PDA" - ); - let minter = read_minter(&config.account.data.clone().into_inner()) - .expect("config account holds an authorized minter id"); - assert_eq!( - caller_program_id, - Some(minter), - "Mint is only callable by the authorized minter (the cross-zone inbox)" - ); - - assert_eq!( - holding.account_id, - holding_account_id(self_program_id, &recipient), - "second account must be the recipient holding PDA" - ); - - let new_balance = read_balance(&holding.account.data.clone().into_inner()) - .checked_add(amount) - .expect("wrapped-token balance overflow"); - let mut holding_account = holding.account.clone(); - holding_account.data = balance_bytes(new_balance) - .to_vec() - .try_into() - .expect("balance fits in account data"); - let holding_post = AccountPostState::new_claimed_if_default( - holding_account, - Claim::Pda(holding_seed(&recipient)), - ); - let config_post = AccountPostState::new(config.account.clone()); - - ProgramOutput::new( - self_program_id, - caller_program_id, - instruction_words, - vec![config, holding], - vec![config_post, holding_post], - ) - .write(); -}