mirror of
https://github.com/logos-blockchain/lssa.git
synced 2026-06-17 14:39:47 +00:00
4bcffafe27
BREAKING CHANGE:
- Crate `nssa` renamed to `lee`; update `Cargo.toml` dependencies from `nssa = { workspace = true }` to `lee = { workspace = true }`.
- Crate `nssa_core` renamed to `lee_core`; update similarly.
- Crate `key_protocol` moved under `lee`; update `Cargo.toml` dependencies from `key_protocol = { workspace = true }` to `lee_key_protocol = { workspace = true }`.
- Type `NSSATransaction` (in `common`) renamed to `LeeTransaction`.
- Error type `nssa::error::NssaError` renamed to `lee::error::LeeError`.
- Error type `nssa_core::error::NssaCoreError` renamed to `lee_core::error::LeeCoreError`.
- All `use nssa::` and `use nssa_core::` import paths must be updated to `use lee::` and `use lee_core::` respectively.
- Guest programs must replace `write_nssa_outputs` with `write_lee_outputs`.
- The sequencer RocksDB column family for the chain state was renamed. Existing databases are incompatible and must be wiped before running the new version.
- Domain separators updated: `"NSSA_seed"` → `"LEE_seed"` (key derivation), `"NSSA/v0.2/KDF-SHA256/"` → `"LEE/v0.2/KDF-SHA256/"` (encryption KDF), `"/NSSA/v0.2/AccountId/PDA/"` →
`"/LEE/v0.2/AccountId/PDA/"` (public PDA address derivation). All previously derived keys, encrypted outputs, and public PDA addresses are invalidated.
95 lines
2.6 KiB
Rust
95 lines
2.6 KiB
Rust
use lee_core::program::{AccountPostState, Claim, ProgramInput, ProgramOutput, read_lee_inputs};
|
|
use risc0_zkvm::sha::{Impl, Sha256 as _};
|
|
|
|
const PRIZE: u128 = 150;
|
|
|
|
type Instruction = u128;
|
|
|
|
struct Challenge {
|
|
difficulty: u8,
|
|
seed: [u8; 32],
|
|
}
|
|
|
|
impl Challenge {
|
|
fn new(bytes: &[u8]) -> Self {
|
|
assert_eq!(bytes.len(), 33);
|
|
let difficulty = bytes[0];
|
|
assert!(difficulty <= 32);
|
|
|
|
let mut seed = [0; 32];
|
|
seed.copy_from_slice(&bytes[1..]);
|
|
Self { difficulty, seed }
|
|
}
|
|
|
|
// Checks if the leftmost `self.difficulty` number of bytes of SHA256(self.data || solution) are
|
|
// zero.
|
|
fn validate_solution(&self, solution: Instruction) -> bool {
|
|
let mut bytes = [0; 32 + 16];
|
|
bytes[..32].copy_from_slice(&self.seed);
|
|
bytes[32..].copy_from_slice(&solution.to_le_bytes());
|
|
let digest: [u8; 32] = Impl::hash_bytes(&bytes).as_bytes().try_into().unwrap();
|
|
let difficulty = usize::from(self.difficulty);
|
|
digest[..difficulty].iter().all(|&b| b == 0)
|
|
}
|
|
|
|
fn next_data(self) -> [u8; 33] {
|
|
let mut result = [0; 33];
|
|
result[0] = self.difficulty;
|
|
result[1..].copy_from_slice(Impl::hash_bytes(&self.seed).as_bytes());
|
|
result
|
|
}
|
|
}
|
|
|
|
/// A pinata program.
|
|
fn main() {
|
|
// Read input accounts.
|
|
// It is expected to receive only two accounts: [pinata_account, winner_account]
|
|
let (
|
|
ProgramInput {
|
|
self_program_id,
|
|
caller_program_id,
|
|
pre_states,
|
|
instruction: solution,
|
|
},
|
|
instruction_words,
|
|
) = read_lee_inputs::<Instruction>();
|
|
|
|
let Ok([pinata, winner]) = <[_; 2]>::try_from(pre_states) else {
|
|
return;
|
|
};
|
|
|
|
let data = Challenge::new(&pinata.account.data);
|
|
|
|
if !data.validate_solution(solution) {
|
|
return;
|
|
}
|
|
|
|
let mut pinata_post = pinata.account.clone();
|
|
let mut winner_post = winner.account.clone();
|
|
pinata_post.balance = pinata_post
|
|
.balance
|
|
.checked_sub(PRIZE)
|
|
.expect("Not enough balance in the pinata");
|
|
pinata_post.data = data
|
|
.next_data()
|
|
.to_vec()
|
|
.try_into()
|
|
.expect("33 bytes should fit into Data");
|
|
winner_post.balance = winner_post
|
|
.balance
|
|
.checked_add(PRIZE)
|
|
.expect("Overflow when adding prize to winner");
|
|
|
|
ProgramOutput::new(
|
|
self_program_id,
|
|
caller_program_id,
|
|
instruction_words,
|
|
vec![pinata, winner],
|
|
vec![
|
|
AccountPostState::new_claimed_if_default(pinata_post, Claim::Authorized),
|
|
AccountPostState::new(winner_post),
|
|
],
|
|
)
|
|
.write();
|
|
}
|