blvm-node 0.1.31

Bitcoin Commons BLVM: Minimal Bitcoin node implementation using blvm-protocol and blvm-consensus
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

//! verify_covenant_proof RPC (path 2, requires CTV).

#![cfg(all(feature = "bip70-http", feature = "ctv"))]

use blvm_node::config::PaymentConfig;
use blvm_node::payment::processor::PaymentProcessor;
use blvm_node::payment::state_machine::PaymentStateMachine;
use blvm_node::rpc::payment::PaymentRpc;
use blvm_protocol::payment::PaymentOutput;
use serde_json::json;
use std::sync::Arc;

fn create_test_outputs() -> Vec<PaymentOutput> {
    vec![PaymentOutput {
        script: vec![0x51, 0x87],
        amount: Some(100_000),
    }]
}

fn create_rpc() -> (PaymentRpc, Arc<PaymentStateMachine>) {
    let processor =
        Arc::new(PaymentProcessor::new(PaymentConfig::default()).expect("payment processor"));
    let state_machine = Arc::new(PaymentStateMachine::new(processor));
    (
        PaymentRpc::with_state_machine(state_machine.clone()),
        state_machine,
    )
}

#[tokio::test]
async fn verify_covenant_proof_accepts_valid_proof() {
    let (rpc, state_machine) = create_rpc();
    let (payment_id, covenant_proof) = state_machine
        .create_payment_request(create_test_outputs(), None, true)
        .await
        .expect("create payment with covenant");

    let proof = covenant_proof.expect("covenant proof created");
    let proof_bytes = bincode::serialize(&proof).expect("serialize covenant proof");

    let result = rpc
        .verify_covenant_proof(&json!([hex::encode(&proof_bytes), 0u32, 100_000u64,]))
        .await
        .expect("verify_covenant_proof");

    assert_eq!(result["verified"], true, "payment_id={payment_id}");
}

#[tokio::test]
async fn verify_covenant_proof_rejects_amount_mismatch() {
    let (rpc, state_machine) = create_rpc();
    let (_payment_id, covenant_proof) = state_machine
        .create_payment_request(create_test_outputs(), None, true)
        .await
        .expect("create payment with covenant");

    let proof_bytes = bincode::serialize(&covenant_proof.expect("proof")).unwrap();

    let result = rpc
        .verify_covenant_proof(&json!([hex::encode(&proof_bytes), 0u32, 1u64,]))
        .await
        .expect("verify_covenant_proof");

    assert_eq!(result["verified"], false);
}

#[tokio::test]
async fn verify_covenant_proof_rejects_empty_bytes() {
    let (rpc, _state_machine) = create_rpc();

    let result = rpc
        .verify_covenant_proof(&json!(["", 0u32, 100_000u64]))
        .await
        .expect("verify_covenant_proof");

    assert_eq!(result["verified"], false);
}