tidecoin-consensus-core 0.1.0

Shared Tidecoin consensus-validation core types.
Documentation 
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

//! Shared typed verification facade over the Tidecoin interpreter.

use crate::{
    Interpreter, ScriptError, ScriptFlags, SpendContext, TidecoinValidationError,
    TransactionContext, VERIFY_CLEANSTACK, VERIFY_P2SH, VERIFY_WITNESS,
};
use primitives::Transaction;

/// Detailed failure information for a typed verification call.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VerificationFailure {
    /// High-level verification error.
    pub error: TidecoinValidationError,
    /// Final interpreter script error.
    pub script_error: ScriptError,
}

/// Verifies a single typed spend and returns the shared-core validation error.
pub fn verify_script_input(
    tx: &Transaction,
    input_index: usize,
    spend: SpendContext<'_>,
    flags: u32,
) -> Result<(), TidecoinValidationError> {
    verify_script_input_detailed(tx, input_index, spend, flags).map_err(|failure| failure.error)
}

/// Validates raw verification bits against the shared Tidecoin engine contract.
pub fn validate_verification_flags(flags: u32) -> Result<(), TidecoinValidationError> {
    let _ = ScriptFlags::from_bits(normalize_flags(flags))?;
    Ok(())
}

/// Same as [`verify_script_input`] but also reports the final interpreter script error.
pub fn verify_script_input_detailed(
    tx: &Transaction,
    input_index: usize,
    spend: SpendContext<'_>,
    flags: u32,
) -> Result<(), VerificationFailure> {
    let flags = ScriptFlags::from_bits(normalize_flags(flags)).map_err(simple_failure)?;
    let tx_ctx = TransactionContext::new(tx);
    let mut interpreter =
        Interpreter::new(&tx_ctx, input_index, spend, flags).map_err(simple_failure)?;

    interpreter.verify().map_err(|err| {
        let script_error = interpreter.last_script_error();
        VerificationFailure { error: normalize_script_error(err, script_error), script_error }
    })
}

fn normalize_flags(mut flags: u32) -> u32 {
    if flags & VERIFY_CLEANSTACK != 0 {
        flags |= VERIFY_P2SH | VERIFY_WITNESS;
    }
    flags
}

fn simple_failure(error: TidecoinValidationError) -> VerificationFailure {
    VerificationFailure { error, script_error: ScriptError::Ok }
}

fn normalize_script_error(
    error: TidecoinValidationError,
    script_error: ScriptError,
) -> TidecoinValidationError {
    match error {
        TidecoinValidationError::Script(_) => TidecoinValidationError::Script(script_error),
        other => other,
    }
}