Struct SimpleValidator

pub struct SimpleValidator { /* private fields */ }

A simple validator. See SimpleValidatorFactory for construction

Trait Implementations

impl Validator for SimpleValidator

fn decode_commitment_tx( &self, keys: &InMemorySigner, setup: &ChannelSetup, is_counterparty: bool, tx: &Transaction, output_witscripts: &[Vec<u8>], ) -> Result<CommitmentInfo, ValidationError>

panics if keys doesn’t have counterparty keys populated

fn validate_payment_balance( &self, incoming_msat: u64, outgoing_msat: u64, invoiced_amount_msat: Option<u64>, ) -> Result<(), ValidationError>

When thinking about payment routing and balance, it is useful to consider three cases:

1. When invoiced_amount_msat is specified and the incoming_msat is 0; e.g. we are paying an invoice and there is no loop in the routing through us
2. When invoiced_amount_msat is specified and the incoming_msat is not 0; e.g. we are paying an invoice and there is a loop in the routing that includes us
3. When no invoiced_amount_msat is specified and the incoming_msat is not 0; e.g forwarding a payment.

fn validate_setup_channel( &self, wallet: &dyn Wallet, setup: &ChannelSetup, holder_shutdown_key_path: &[u32], ) -> Result<(), ValidationError>

Validate ready channel parameters. The holder_shutdown_key_path should be an empty vector if the setup.holder_shutdown_script is not set or the address is in the allowlist.

fn validate_channel_value( &self, setup: &ChannelSetup, ) -> Result<(), ValidationError>

Validate channel value after it is late-filled

fn validate_onchain_tx( &self, wallet: &dyn Wallet, channels: Vec<Option<Arc<Mutex<ChannelSlot>>>>, tx: &Transaction, segwit_flags: &[bool], values_sat: &[u64], opaths: &[Vec<u32>], weight_lower_bound: usize, ) -> Result<u64, ValidationError>

Validate an onchain transaction (funding tx, simple sweeps). This transaction may fund multiple channels at the same time.

fn validate_counterparty_commitment_tx( &self, estate: &EnforcementState, commit_num: u64, commitment_point: &PublicKey, setup: &ChannelSetup, cstate: &ChainState, info2: &CommitmentInfo2, ) -> Result<(), ValidationError>

Validate a counterparty commitment

fn validate_holder_commitment_tx( &self, estate: &EnforcementState, commit_num: u64, commitment_point: &PublicKey, setup: &ChannelSetup, cstate: &ChainState, info2: &CommitmentInfo2, ) -> Result<(), ValidationError>

Validate a holder commitment

fn validate_counterparty_revocation( &self, state: &EnforcementState, revoke_num: u64, commitment_secret: &SecretKey, ) -> Result<(), ValidationError>

Check a counterparty’s revocation of an old state. This also makes a note that the counterparty has committed to their current commitment transaction.

fn decode_and_validate_htlc_tx( &self, is_counterparty: bool, setup: &ChannelSetup, txkeys: &TxCreationKeys, tx: &Transaction, redeemscript: &ScriptBuf, htlc_amount_sat: u64, output_witscript: &ScriptBuf, ) -> Result<(u32, HTLCOutputInCommitment, SegwitV0Sighash, EcdsaSighashType), ValidationError>

Phase 1 decoding of 2nd level HTLC tx and validation by recomposition

fn validate_htlc_tx( &self, setup: &ChannelSetup, _cstate: &ChainState, _is_counterparty: bool, htlc: &HTLCOutputInCommitment, feerate_per_kw: u32, ) -> Result<(), ValidationError>

Phase 2 validation of 2nd level HTLC tx

fn decode_and_validate_mutual_close_tx( &self, wallet: &dyn Wallet, setup: &ChannelSetup, estate: &EnforcementState, tx: &Transaction, wallet_paths: &[Vec<u32>], ) -> Result<ClosingTransaction, ValidationError>

Phase 1 decoding and recomposition of mutual_close

fn validate_mutual_close_tx( &self, wallet: &dyn Wallet, setup: &ChannelSetup, estate: &EnforcementState, to_holder_value_sat: u64, to_counterparty_value_sat: u64, holder_script: &Option<ScriptBuf>, counterparty_script: &Option<ScriptBuf>, holder_wallet_path_hint: &[u32], ) -> Result<(), ValidationError>

Phase 2 Validatation of mutual_close

fn validate_delayed_sweep( &self, wallet: &dyn Wallet, setup: &ChannelSetup, cstate: &ChainState, tx: &Transaction, input: usize, amount_sat: u64, wallet_path: &[u32], ) -> Result<(), ValidationError>

Validation of delayed sweep transaction

fn validate_counterparty_htlc_sweep( &self, wallet: &dyn Wallet, setup: &ChannelSetup, cstate: &ChainState, tx: &Transaction, redeemscript: &ScriptBuf, input: usize, amount_sat: u64, wallet_path: &[u32], ) -> Result<(), ValidationError>

Validation of counterparty htlc sweep transaction (first level commitment htlc outputs)

fn validate_justice_sweep( &self, wallet: &dyn Wallet, _setup: &ChannelSetup, cstate: &ChainState, tx: &Transaction, input: usize, amount_sat: u64, wallet_path: &[u32], ) -> Result<(), ValidationError>

Validation of justice sweep transaction

fn enforce_balance(&self) -> bool

Whether the policy specifies that holder balance should be tracked and enforced.

fn minimum_initial_balance(&self, holder_value_msat: u64) -> u64

The minimum initial commitment transaction balance to us, given the funding amount. The result is in satoshi.

fn is_ready(&self, cstate: &ChainState) -> bool

Channel ready for normal operation, funding is buried and not closing

fn policy(&self) -> Box<&dyn Policy>

The associated policy

fn set_next_holder_commit_num( &self, estate: &mut EnforcementState, num: u64, current_commitment_info: CommitmentInfo2, counterparty_signatures: CommitmentSignatures, ) -> Result<(), ValidationError>

Set next holder commitment number

fn get_current_holder_commitment_info( &self, estate: &mut EnforcementState, commitment_number: u64, ) -> Result<CommitmentInfo2, ValidationError>

Get the current commitment info

fn set_next_counterparty_commit_num( &self, estate: &mut EnforcementState, num: u64, current_point: PublicKey, current_commitment_info: CommitmentInfo2, ) -> Result<(), ValidationError>

Set next counterparty commitment number

fn set_next_counterparty_revoke_num( &self, estate: &mut EnforcementState, num: u64, ) -> Result<(), ValidationError>

Set next counterparty revoked commitment number

fn validate_block( &self, proof: &TxoProof, height: u32, header: &BlockHeader, external_block_hash: Option<&BlockHash>, prev_filter_header: &FilterHeader, outpoint_watches: &[OutPoint], trusted_oracle_pubkeys: &Vec<PublicKey>, ) -> Result<(), ValidationError>

Validate a block and a TXOO proof for spent/unspent watched outputs

fn validate_invoice( &self, invoice: &Invoice, now: Duration, ) -> Result<(), ValidationError>

Validate an invoice