14703155990

Committed 28 Apr 2025 07:55AM UTC coverage: 79.634% (-0.09%) from 79.726%

Build # 14703155990

Build Type

push

github

Committed by

dan-da

Commit Message

test: fix shared_tokio_runtime macro

addresses review comments:
https://github.com/Neptune-Crypto/neptune-core/pull/569#discussion_r2062924684
https://github.com/Neptune-Crypto/neptune-core/pull/569#discussion_r2062938756

1. adds back a #[traced_test] that got removed in efe4da2f.

2. adds missing visibility specifier to async test fn inside macro.

The missing specifier didn't cause any error or warning during
compilation or linting, but it is clearly more correct to have it in
place.

Run Details

1 of 2 new or added lines in 2 files covered. (50.0%)

46 existing lines in 3 files now uncovered.

37143 of 46642 relevant lines covered (79.63%)

232101.38 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.33

/src/models/blockchain/type_scripts/time_lock.rs

use std::collections::HashMap;
use std::sync::OnceLock;

use get_size2::GetSize;
use itertools::Itertools;
use num_traits::Zero;
use serde::Deserialize;
use serde::Serialize;
use tasm_lib::memory::encode_to_memory;
use tasm_lib::memory::FIRST_NON_DETERMINISTICALLY_INITIALIZED_MEMORY_ADDRESS;
use tasm_lib::prelude::Digest;
use tasm_lib::prelude::Library;
use tasm_lib::structure::verify_nd_si_integrity::VerifyNdSiIntegrity;
use tasm_lib::triton_vm::prelude::*;
use tasm_lib::twenty_first::math::b_field_element::BFieldElement;
use tasm_lib::twenty_first::math::bfield_codec::BFieldCodec;

use super::TypeScript;
use super::TypeScriptWitness;
use crate::models::blockchain::transaction::primitive_witness::PrimitiveWitness;
use crate::models::blockchain::transaction::primitive_witness::SaltedUtxos;
use crate::models::blockchain::transaction::transaction_kernel::TransactionKernel;
use crate::models::blockchain::transaction::transaction_kernel::TransactionKernelField;
use crate::models::blockchain::transaction::utxo::Coin;
use crate::models::blockchain::transaction::utxo::Utxo;
use crate::models::blockchain::type_scripts::TypeScriptAndWitness;
use crate::models::proof_abstractions::mast_hash::MastHash;
use crate::models::proof_abstractions::tasm::program::ConsensusProgram;
use crate::models::proof_abstractions::timestamp::Timestamp;
use crate::models::proof_abstractions::SecretWitness;

#[derive(Debug, Copy, Clone, Deserialize, Serialize, BFieldCodec, GetSize, PartialEq, Eq)]
pub struct TimeLock;

impl TimeLock {
    /// Create a `TimeLock` type-script-and-state-pair that releases the coins at the
    /// given release date, which corresponds to the number of milliseconds that passed
    /// since the unix epoch started (00:00 am UTC on Jan 1 1970).
    pub fn until(date: Timestamp) -> Coin {
        Coin {
            type_script_hash: TimeLock.hash(),
            state: vec![date.0],
        }
    }

    /// Get the release date from a `Utxo`, if any. If there aren't any, return
    /// the null release date.
    pub fn extract_release_date(utxo: &Utxo) -> Timestamp {
        utxo.coins()
            .iter()
            .find_map(Coin::release_date)
            .unwrap_or_else(Timestamp::zero)
    }
}

impl ConsensusProgram for TimeLock {
    fn library_and_code(&self) -> (Library, Vec<LabelledInstruction>) {
        let (library, audit_preloaded_data, audit_subroutine) = {
            let mut library = Library::new();
            let audit_preloaded_data = library.import(Box::new(VerifyNdSiIntegrity::<
                TimeLockWitnessMemory,
            >::default()));
            let audit_subroutine = library.all_imports();
            (library, audit_preloaded_data, audit_subroutine)
        };

        // Generated by tasm-lang compiler
        // `tasm-lang typescript-timelock.rs type-script-time-lock.tasm`
        // 2024-09-09
        let code = triton_asm! {
        call main
        halt
        {&audit_subroutine}

        main:
        call tasmlib_verifier_own_program_digest
        dup 4
        dup 4
        dup 4
        dup 4
        dup 4
        push -6
        write_mem 5
        pop 1
        hint self_digest = stack[0..5]
        call tasmlib_io_read_stdin___digest
        dup 4
        dup 4
        dup 4
        dup 4
        dup 4
        push -11
        write_mem 5
        pop 1
        hint tx_kernel_digest = stack[0..5]
        call tasmlib_io_read_stdin___digest
        dup 4
        dup 4
        dup 4
        dup 4
        dup 4
        push -16
        write_mem 5
        pop 1
        hint input_utxos_digest = stack[0..5]
        call tasmlib_io_read_stdin___digest
        hint _output_utxos_digest = stack[0..5]
        push 5
        hint leaf_index = stack[0]
        call tasmlib_io_read_secin___bfe
        dup 0
        push -17
        write_mem 1
        pop 1
        hint timestamp = stack[0]
        push -17
        read_mem 1
        pop 1
        call encode_BField
        call tasm_langs_hash_varlen
        hint leaf = stack[0..5]
        push 3
        hint tree_height = stack[0]
        push -7
        read_mem 5
        pop 1
        dup 5
        dup 13
        dup 12
        dup 12
        dup 12
        dup 12
        dup 12
        call tasmlib_hashing_merkle_verify
        call tasmlib_io_read_secin___bfe
        hint input_utxos_pointer = stack[0]

        /* Audit preloaded data */
        // ... *input_utxos_pointer
        dup 0
        call {audit_preloaded_data}
        // ... *input_utxos_pointer witness_size

        pop 1
        // ... *input_utxos_pointer

        call tasmlib_io_read_secin___bfe
        split
        hint _output_utxos_pointer = stack[0..2]
        dup 2
        hint input_salted_utxos = stack[0]
        dup 0
        call tasm_langs_hash_varlen_boxed_value___SaltedUtxos
        hint input_salted_utxos_digest = stack[0..5]
        dup 4
        dup 4
        dup 4
        dup 4
        dup 4
        push -12
        read_mem 5
        pop 1
        call tasmlib_hashing_eq_digest
        assert
        dup 5
        addi 4
        hint input_utxos = stack[0]
        push 0
        hint i = stack[0]
        call _binop_Lt__LboolR_bool_32_while_loop
        pop 5
        pop 5
        pop 5
        pop 5
        pop 5
        pop 5
        pop 5
        pop 4
        return
        _binop_Eq__LboolR_bool_49_then:
        pop 1
        dup 0
        addi 1
        hint state = stack[0]
        dup 0
        read_mem 1
        pop 1
        push 1
        eq
        assert
        dup 0
        push 0
        push 1
        mul
        push 1
        add
        push 00000000001073741824
        dup 1
        lt
        assert
        add
        read_mem 1
        pop 1
        hint release_date = stack[0]
        dup 0
        split
        push -17
        read_mem 1
        pop 1
        split
        swap 3
        swap 1
        swap 3
        swap 2
        call tasmlib_arithmetic_u64_lt
        assert
        pop 1
        pop 1
        push 0
        return
        _binop_Eq__LboolR_bool_49_else:
        return
        _binop_Lt__LboolR_bool_42_while_loop:
        dup 0
        dup 2
        read_mem 1
        pop 1
        swap 1
        lt
        push 0
        eq
        skiz
        return
        dup 1
        push 1
        add
        dup 1
        call tasm_langs_dynamic_list_element_finder
        pop 1
        addi 1
        hint coin = stack[0]
        dup 0
        read_mem 1
        push 00000000001073741824
        dup 2
        lt
        assert
        addi 2
        add
        push 4
        add
        read_mem 5
        pop 1
        push -2
        read_mem 5
        pop 1
        call tasmlib_hashing_eq_digest
        push 1
        swap 1
        skiz
        call _binop_Eq__LboolR_bool_49_then
        skiz
        call _binop_Eq__LboolR_bool_49_else
        dup 1
        push 1
        call tasmlib_arithmetic_u32_safeadd
        swap 2
        pop 1
        pop 1
        recurse
        _binop_Lt__LboolR_bool_32_while_loop:
        dup 0
        dup 2
        read_mem 1
        pop 1
        swap 1
        lt
        push 0
        eq
        skiz
        return
        dup 1
        push 1
        add
        dup 1
        call tasm_langs_dynamic_list_element_finder
        pop 1
        addi 1
        addi 1
        hint coins = stack[0]
        push 0
        hint j = stack[0]
        call _binop_Lt__LboolR_bool_42_while_loop
        dup 2
        push 1
        call tasmlib_arithmetic_u32_safeadd
        swap 3
        pop 1
        pop 1
        pop 1
        recurse
        encode_BField:
        call tasmlib_memory_dyn_malloc
        push 1
        swap 1
        write_mem 1
        write_mem 1
        push -2
        add
        return
        tasm_langs_dynamic_list_element_finder:
        dup 0
        push 0
        eq
        skiz
        return
        swap 1
        read_mem 1
        push 00000000001073741824
        dup 2
        lt
        assert
        addi 2
        add
        swap 1
        addi -1
        recurse
        tasm_langs_hash_varlen:
        read_mem 1
        push 2
        add
        swap 1
        call tasmlib_hashing_algebraic_hasher_hash_varlen
        return
        tasm_langs_hash_varlen_boxed_value___SaltedUtxos:
        dup 0
        push 0
        addi 3
        swap 1
        addi 3
        swap 1
        dup 1
        read_mem 1
        pop 1
        push 00000000001073741824
        dup 1
        lt
        assert
        addi 1
        dup 2
        dup 1
        add
        swap 3
        pop 1
        add
        swap 1
        pop 1
        call tasmlib_hashing_algebraic_hasher_hash_varlen
        return
        tasmlib_arithmetic_u32_safeadd:
        hint input_lhs: u32 = stack[0]
        hint input_rhs: u32 = stack[1]
        add
        dup 0
        split
        pop 1
        push 0
        eq
        assert
        return
        tasmlib_arithmetic_u64_lt:
        hint lhs: u64 = stack[0..2]
        hint rhs: u64 = stack[2..4]
        swap 3
        swap 2
        dup 2
        dup 2
        lt
        swap 4
        lt
        swap 2
        eq
        mul
        add
        return
        tasmlib_hashing_absorb_multiple:
        hint len: u32 = stack[0]
        hint _sequence: void_pointer = stack[1]
        dup 0
        push 10
        swap 1
        div_mod
        swap 1
        pop 1
        swap 1
        dup 1
        push -1
        mul
        dup 3
        add
        add
        swap 1
        swap 2
        push 0
        push 0
        push 0
        push 0
        swap 4
        call tasmlib_hashing_absorb_multiple_hash_all_full_chunks
        pop 5
        push -1
        add
        push 9
        dup 2
        push -1
        mul
        add
        call tasmlib_hashing_absorb_multiple_pad_varnum_zeros
        pop 1
        push 1
        swap 2
        dup 1
        add
        call tasmlib_hashing_absorb_multiple_read_remainder
        pop 2
        sponge_absorb
        return
        tasmlib_hashing_absorb_multiple_hash_all_full_chunks:
        dup 5
        dup 1
        eq
        skiz
        return
        sponge_absorb_mem
        recurse
        tasmlib_hashing_absorb_multiple_pad_varnum_zeros:
        dup 0
        push 0
        eq
        skiz
        return
        push 0
        swap 3
        swap 2
        swap 1
        push -1
        add
        recurse
        tasmlib_hashing_absorb_multiple_read_remainder:
        dup 1
        dup 1
        eq
        skiz
        return
        read_mem 1
        swap 1
        swap 2
        swap 1
        recurse
        tasmlib_hashing_algebraic_hasher_hash_varlen:
        hint length: u32 = stack[0]
        hint _addr: void_pointer = stack[1]
        sponge_init
        call tasmlib_hashing_absorb_multiple
        sponge_squeeze
        swap 5
        pop 1
        swap 5
        pop 1
        swap 5
        pop 1
        swap 5
        pop 1
        swap 5
        pop 1
        return
        tasmlib_hashing_eq_digest:
        hint input_a4: digest = stack[0..5]
        hint input_b4: digest = stack[5..10]
        swap 6
        eq
        swap 6
        eq
        swap 6
        eq
        swap 6
        eq
        swap 2
        eq
        mul
        mul
        mul
        mul
        return
        tasmlib_hashing_merkle_verify:
        hint leaf: digest = stack[0..5]
        hint leaf_index: u32 = stack[5]
        hint tree_height: u32 = stack[6]
        hint root: digest = stack[7..12]
        dup 6
        push 2
        pow
        dup 0
        dup 7
        lt
        assert
        dup 6
        add
        swap 6
        pop 1
        dup 6
        skiz
        call tasmlib_hashing_merkle_verify_tree_height_is_not_zero
        swap 2
        swap 4
        swap 6
        pop 1
        swap 2
        swap 4
        pop 1
        assert_vector
        pop 5
        return
        tasmlib_hashing_merkle_verify_tree_height_is_not_zero:
        push 1
        swap 7
        pop 1
        call tasmlib_hashing_merkle_verify_traverse_tree
        return
        tasmlib_hashing_merkle_verify_traverse_tree:
        merkle_step
        recurse_or_return
        tasmlib_io_read_secin___bfe:
        divine 1
        return
        tasmlib_io_read_stdin___digest:
        read_io 5
        return
        tasmlib_memory_dyn_malloc:
        push -1
        read_mem 1
        pop 1
        dup 0
        push 0
        eq
        skiz
        call tasmlib_memory_dyn_malloc_initialize
        push 00000000002147483647
        dup 1
        lt
        assert
        dup 0
        push 1
        add
        push -1
        write_mem 1
        pop 1
        push 00000000004294967296
        mul
        return
        tasmlib_memory_dyn_malloc_initialize:
        pop 1
        push 1
        return
        tasmlib_verifier_own_program_digest:
        dup 15
        dup 15
        dup 15
        dup 15
        dup 15
        return
        };

        (library, code)
    }

    fn hash(&self) -> Digest {
        static HASH: OnceLock<Digest> = OnceLock::new();

        *HASH.get_or_init(|| self.program().hash())
    }
}

impl TypeScript for TimeLock {
    type State = Timestamp;
}

#[derive(Debug, Clone, Deserialize, Serialize, BFieldCodec, GetSize, PartialEq, Eq)]
pub struct TimeLockWitness {
    /// One timestamp for every input UTXO. Inputs that do not have a time lock are
    /// assigned timestamp 0, which is automatically satisfied.
    release_dates: Vec<Timestamp>,
    input_utxos: SaltedUtxos,
    transaction_kernel: TransactionKernel,
}

type TimeLockWitnessMemory = SaltedUtxos;

impl SecretWitness for TimeLockWitness {
    fn nondeterminism(&self) -> NonDeterminism {
        let mut memory: HashMap<BFieldElement, BFieldElement> = HashMap::new();
        let input_salted_utxos_address = FIRST_NON_DETERMINISTICALLY_INITIALIZED_MEMORY_ADDRESS;
        let output_salted_utxos_address = encode_to_memory::<TimeLockWitnessMemory>(
            &mut memory,
            input_salted_utxos_address,
            &self.input_utxos,
        );
        let individual_tokens = vec![
            self.transaction_kernel.timestamp.0,
            input_salted_utxos_address,
            output_salted_utxos_address,
        ];
        let mast_path = self
            .transaction_kernel
            .mast_path(TransactionKernelField::Timestamp)
            .clone();
        NonDeterminism::new(individual_tokens)
            .with_digests(mast_path)
            .with_ram(memory)
    }

    fn standard_input(&self) -> PublicInput {
        self.type_script_standard_input()
    }

    fn program(&self) -> Program {
        TimeLock.program()
    }
}

impl TypeScriptWitness for TimeLockWitness {
    fn transaction_kernel(&self) -> TransactionKernel {
        self.transaction_kernel.clone()
    }

    fn salted_input_utxos(&self) -> SaltedUtxos {
        self.input_utxos.clone()
    }

    fn salted_output_utxos(&self) -> SaltedUtxos {
        SaltedUtxos::empty()
    }

    fn type_script_and_witness(&self) -> TypeScriptAndWitness {
        TypeScriptAndWitness::new_with_nondeterminism(TimeLock.program(), self.nondeterminism())
    }

    fn new(
        transaction_kernel: TransactionKernel,
        salted_input_utxos: SaltedUtxos,
        _salted_output_utxos: SaltedUtxos,
    ) -> Self {
        let release_dates = salted_input_utxos
            .utxos
            .iter()
            .map(TimeLock::extract_release_date)
            .collect_vec();

        Self {
            release_dates,
            input_utxos: salted_input_utxos,
            transaction_kernel,
        }
    }
}

impl From<PrimitiveWitness> for TimeLockWitness {
    fn from(primitive_witness: PrimitiveWitness) -> Self {
        let release_dates = primitive_witness
            .input_utxos
            .utxos
            .iter()
            .map(TimeLock::extract_release_date)
            .collect_vec();
        let transaction_kernel = TransactionKernel::from(primitive_witness.clone());
        let input_utxos = primitive_witness.input_utxos.clone();

        Self {
            release_dates,
            input_utxos,
            transaction_kernel,
        }
    }
}

#[cfg(any(test, feature = "arbitrary-impls"))]
pub mod neptune_arbitrary {
    use num_traits::CheckedSub;
    use proptest::arbitrary::Arbitrary;
    use proptest::collection::vec;
    use proptest::strategy::BoxedStrategy;
    use proptest::strategy::Strategy;
    use proptest_arbitrary_interop::arb;

    use super::super::native_currency_amount::NativeCurrencyAmount;
    use super::*;
    use crate::models::blockchain::transaction::transaction_kernel::TransactionKernelModifier;
    use crate::models::blockchain::transaction::PublicAnnouncement;

    impl Arbitrary for TimeLockWitness {
        /// Parameters are:
        ///  - release_dates : `Vec<u64>` One release date per input UTXO. 0 if the time lock
        ///    coin is absent.
        ///  - num_outputs : usize Number of outputs.
        ///  - num_public_announcements : usize Number of public announcements.
        ///  - transaction_timestamp: Timestamp determining when the transaction takes place.
        type Parameters = (Vec<Timestamp>, usize, usize, Timestamp);

        type Strategy = BoxedStrategy<Self>;

        fn arbitrary_with(parameters: Self::Parameters) -> Self::Strategy {
            let (release_dates, num_outputs, num_public_announcements, transaction_timestamp) =
                parameters;
            let num_inputs = release_dates.len();
            (
                vec(arb::<Digest>(), num_inputs),
                vec(NativeCurrencyAmount::arbitrary_non_negative(), num_inputs),
                vec(arb::<Digest>(), num_outputs),
                vec(NativeCurrencyAmount::arbitrary_non_negative(), num_outputs),
                vec(arb::<PublicAnnouncement>(), num_public_announcements),
                NativeCurrencyAmount::arbitrary_coinbase(),
                NativeCurrencyAmount::arbitrary_non_negative(),
            )
                .prop_flat_map(
                    move |(
                        input_address_seeds,
                        input_amounts,
                        output_address_seeds,
                        mut output_amounts,
                        public_announcements,
                        maybe_coinbase,
                        mut fee,
                    )| {
                        // generate inputs
                        let (mut input_utxos, input_lock_scripts_and_witnesses) =
                            PrimitiveWitness::transaction_inputs_from_address_seeds_and_amounts(
                                &input_address_seeds,
                                &input_amounts,
                            );
                        let total_inputs = input_amounts.into_iter().sum::<NativeCurrencyAmount>();

                        // add time locks to input UTXOs (changes Utxo hash)
                        for (utxo, release_date) in input_utxos.iter_mut().zip(release_dates.iter())
                        {
                            if !release_date.is_zero() {
                                let time_lock_coin = TimeLock::until(*release_date);
                                let mut coins = utxo.coins().to_vec();
                                coins.push(time_lock_coin);
                                *utxo = (utxo.lock_script_hash(), coins).into()
                            }
                        }

                        // generate valid output amounts
                        PrimitiveWitness::find_balanced_output_amounts_and_fee(
                            total_inputs,
                            maybe_coinbase,
                            &mut output_amounts,
                            &mut fee,
                        );

                        // generate output UTXOs
                        let output_utxos =
                            PrimitiveWitness::valid_tx_outputs_from_amounts_and_address_seeds(
                                &output_amounts,
                                &output_address_seeds,
                                None,
                            );

                        // generate primitive transaction witness and time lock witness from there
                        PrimitiveWitness::arbitrary_primitive_witness_with(
                            &input_utxos,
                            &input_lock_scripts_and_witnesses,
                            &output_utxos,
                            &public_announcements,
                            NativeCurrencyAmount::zero(),
                            maybe_coinbase,
                        )
                        .prop_map(move |mut transaction_primitive_witness| {
                            let modified_kernel = TransactionKernelModifier::default()
                                .timestamp(transaction_timestamp)
                                .modify(transaction_primitive_witness.kernel);

                            transaction_primitive_witness.kernel = modified_kernel;
                            TimeLockWitness::from(transaction_primitive_witness)
                        })
                        .boxed()
                    },
                )
                .boxed()
        }
    }

    /// Generate a `Strategy` for a [`PrimitiveWitness`] with the given numbers of
    /// inputs, outputs, and public announcements, with active timelocks.
    ///
    /// The UTXOs are timelocked with a release date set between `now` and six
    /// months from `now`.
    ///
    // Public bc used in benchmarks.
    #[doc(hidden)]
    pub fn arbitrary_primitive_witness_with_active_timelocks(
        num_inputs: usize,
        num_outputs: usize,
        num_announcements: usize,
        now: Timestamp,
    ) -> BoxedStrategy<PrimitiveWitness> {
        vec(
            Timestamp::arbitrary_between(now, now + Timestamp::months(6)),
            num_inputs + num_outputs,
        )
        .prop_flat_map(move |release_dates| {
            arbitrary_primitive_witness_with_timelocks(
                num_inputs,
                num_outputs,
                num_announcements,
                now,
                release_dates,
            )
        })
        .boxed()
    }

    /// Generate a `Strategy` for a [`PrimitiveWitness`] with the given numbers of
    /// inputs, outputs, and public announcements, with expired timelocks.
    ///
    /// The UTXOs are timelocked with a release date set between six months in the
    /// past relative to `now` and `now`.
    ///
    // Public bc used in benchmarks.
    #[doc(hidden)]
    pub fn arbitrary_primitive_witness_with_expired_timelocks(
        num_inputs: usize,
        num_outputs: usize,
        num_announcements: usize,
        now: Timestamp,
    ) -> BoxedStrategy<PrimitiveWitness> {
        vec(
            Timestamp::arbitrary_between(now - Timestamp::months(6), now - Timestamp::millis(1)),
            num_inputs + num_outputs,
        )
        .prop_flat_map(move |release_dates| {
            arbitrary_primitive_witness_with_timelocks(
                num_inputs,
                num_outputs,
                num_announcements,
                now,
                release_dates,
            )
        })
        .boxed()
    }

    #[expect(unused_variables, reason = "under development")]
    fn arbitrary_primitive_witness_with_timelocks(
        num_inputs: usize,
        num_outputs: usize,
        num_announcements: usize,
        now: Timestamp,
        release_dates: Vec<Timestamp>,
    ) -> BoxedStrategy<PrimitiveWitness> {
        (
            NativeCurrencyAmount::arbitrary_non_negative(),
            vec(arb::<Digest>(), num_inputs),
            vec(arb::<u64>(), num_inputs),
            vec(arb::<Digest>(), num_outputs),
            vec(arb::<u64>(), num_outputs),
            vec(arb::<PublicAnnouncement>(), num_announcements),
            arb::<u64>(),
            arb::<Option<u64>>(),
        )
            .prop_flat_map(
                move |(
                    total_amount,
                    input_address_seeds,
                    input_dist,
                    output_address_seeds,
                    output_dist,
                    public_announcements,
                    fee_dist,
                    maybe_coinbase_dist,
                )| {
                    let maybe_coinbase_dist = if num_inputs.is_zero() {
                        maybe_coinbase_dist
                    } else {
                        None
                    };

                    // distribute total amount across inputs (+ coinbase)
                    let mut input_denominator = input_dist.iter().map(|u| *u as f64).sum::<f64>();
                    if let Some(d) = maybe_coinbase_dist {
                        input_denominator += d as f64;
                    }
                    let input_weights = input_dist
                        .into_iter()
                        .map(|u| (u as f64) / input_denominator)
                        .collect_vec();
                    let mut input_amounts = input_weights
                        .into_iter()
                        .map(|w| total_amount.to_nau_f64() * w)
                        .map(|f| NativeCurrencyAmount::try_from(f).unwrap())
                        .collect_vec();
                    let maybe_coinbase = if maybe_coinbase_dist.is_some()
                        || input_amounts.is_empty()
                    {
                        Some(
                            total_amount
                                .checked_sub(
                                    &input_amounts.iter().copied().sum::<NativeCurrencyAmount>(),
                                )
                                .unwrap(),
                        )
                    } else {
                        let sum_of_all_but_last = input_amounts
                            .iter()
                            .rev()
                            .skip(1)
                            .copied()
                            .sum::<NativeCurrencyAmount>();
                        *input_amounts.last_mut().unwrap() =
                            total_amount.checked_sub(&sum_of_all_but_last).unwrap();
                        None
                    };

                    // distribute total amount across outputs
                    let output_denominator =
                        output_dist.iter().map(|u| *u as f64).sum::<f64>() + (fee_dist as f64);
                    let output_weights = output_dist
                        .into_iter()
                        .map(|u| (u as f64) / output_denominator)
                        .collect_vec();
                    let output_amounts = output_weights
                        .into_iter()
                        .map(|w| total_amount.to_nau_f64() * w)
                        .map(|f| NativeCurrencyAmount::try_from(f).unwrap())
                        .collect_vec();
                    let total_outputs =
                        output_amounts.iter().copied().sum::<NativeCurrencyAmount>();
                    let fee = total_amount.checked_sub(&total_outputs).unwrap();

                    let (mut input_utxos, input_lock_scripts_and_witnesses) =
                        PrimitiveWitness::transaction_inputs_from_address_seeds_and_amounts(
                            &input_address_seeds,
                            &input_amounts,
                        );
                    let total_inputs = input_amounts.iter().copied().sum::<NativeCurrencyAmount>();

                    assert_eq!(
                        total_inputs + maybe_coinbase.unwrap_or(NativeCurrencyAmount::coins(0)),
                        total_outputs + fee
                    );
                    let mut output_utxos =
                        PrimitiveWitness::valid_tx_outputs_from_amounts_and_address_seeds(
                            &output_amounts,
                            &output_address_seeds,
                            None,
                        );
                    let mut counter = 0usize;
                    for utxo in &mut input_utxos {
                        let release_date = release_dates[counter];
                        let time_lock = TimeLock::until(release_date);
                        let mut coins = utxo.coins().to_vec();
                        coins.push(time_lock);
                        *utxo = Utxo::from((utxo.lock_script_hash(), coins));
                        counter += 1;
                    }
                    for utxo in &mut output_utxos {
                        let mut coins = utxo.coins().to_vec();
                        coins.push(TimeLock::until(release_dates[counter]));
                        *utxo = Utxo::from((utxo.lock_script_hash(), coins));
                        counter += 1;
                    }
                    let release_dates = release_dates.clone();

                    let merge_bit = false;
                    PrimitiveWitness::arbitrary_primitive_witness_with_timestamp_and(
                        &input_utxos,
                        &input_lock_scripts_and_witnesses,
                        &output_utxos,
                        &public_announcements,
                        fee,
                        maybe_coinbase,
                        now,
                        merge_bit,
                    )
                    .prop_map(move |primitive_witness_template| {
                        let mut primitive_witness = primitive_witness_template.clone();
                        let modified_kernel = TransactionKernelModifier::default()
                            .timestamp(now)
                            .modify(primitive_witness.kernel);

                        primitive_witness.kernel = modified_kernel;
                        primitive_witness
                    })
                },
            )
            .boxed()
    }
}

#[cfg(test)]
mod test {
    use proptest::collection::vec;
    use proptest::prelude::Arbitrary;
    use proptest::prelude::Strategy;
    use proptest::prop_assert;
    use proptest::prop_assert_eq;
    use proptest::strategy::Just;
    use proptest::test_runner::TestRunner;
    use proptest_arbitrary_interop::arb;
    use tasm_lib::twenty_first::math::tip5::Tip5;
    use test_strategy::proptest;

    use super::neptune_arbitrary::arbitrary_primitive_witness_with_active_timelocks;
    use super::neptune_arbitrary::arbitrary_primitive_witness_with_expired_timelocks;
    use super::*;
    use crate::models::proof_abstractions::tasm::builtins as tasm;
    use crate::models::proof_abstractions::tasm::program::test::ConsensusProgramSpecification;

    impl ConsensusProgramSpecification for TimeLock {
        #[expect(clippy::needless_return)]
        fn source(&self) {
            // get in the current program's hash digest
            let self_digest: Digest = tasm::own_program_digest();

            // read standard input:
            //  - transaction kernel mast hash
            //  - input salted utxos digest
            //  - output salted utxos digest
            // (All type scripts take this triple as input.)
            let tx_kernel_digest: Digest = tasm::tasmlib_io_read_stdin___digest();
            let input_utxos_digest: Digest = tasm::tasmlib_io_read_stdin___digest();
            let _output_utxos_digest: Digest = tasm::tasmlib_io_read_stdin___digest();

            // divine the timestamp and authenticate it against the kernel mast hash
            let leaf_index: u32 = 5;
            let timestamp: BFieldElement = tasm::tasmlib_io_read_secin___bfe();
            let leaf: Digest = Tip5::hash_varlen(&timestamp.encode());
            let tree_height: u32 = 3;
            tasm::tasmlib_hashing_merkle_verify(tx_kernel_digest, leaf_index, leaf, tree_height);

            // get pointers to objects living in nondeterministic memory:
            //  - input Salted UTXOs
            let input_utxos_pointer: u64 = tasm::tasmlib_io_read_secin___bfe().value();

            // it's important to read the outputs digest too, but we actually don't care about
            // the output UTXOs (in this type script)
            let _output_utxos_pointer: u64 = tasm::tasmlib_io_read_secin___bfe().value();

            // authenticate salted input UTXOs against the digest that was read from stdin
            let input_salted_utxos: SaltedUtxos =
                tasm::decode_from_memory(BFieldElement::new(input_utxos_pointer));
            let input_salted_utxos_digest: Digest = Tip5::hash(&input_salted_utxos);
            assert_eq!(input_salted_utxos_digest, input_utxos_digest);

            // iterate over inputs
            let input_utxos = input_salted_utxos.utxos;
            let mut i = 0;
            while i < input_utxos.len() {
                // get coins
                let coins = input_utxos[i].coins();

                // if this typescript is present
                let mut j: usize = 0;
                while j < coins.len() {
                    let coin: &Coin = &coins[j];
                    if coin.type_script_hash == self_digest {
                        // extract state
                        let state: &Vec<BFieldElement> = &coin.state;

                        // assert format
                        assert!(state.len() == 1);

                        // extract timestamp
                        let release_date: BFieldElement = state[0];

                        // test time lock
                        assert!(release_date.value() < timestamp.value());
                    }
                    j += 1;
                }
                i += 1;
            }

            return;
        }
    }

    #[proptest(cases = 20)]
    fn test_unlocked(
        #[strategy(1usize..=3)] _num_inputs: usize,
        #[strategy(1usize..=3)] _num_outputs: usize,
        #[strategy(1usize..=3)] _num_public_announcements: usize,
        #[strategy(vec(Just(Timestamp::zero()), #_num_inputs))] _release_dates: Vec<Timestamp>,
        #[strategy(Just::<Timestamp>(#_release_dates.iter().copied().min().unwrap()))]
        _transaction_timestamp: Timestamp,
        #[strategy(
            TimeLockWitness::arbitrary_with((
                #_release_dates,
                #_num_outputs,
                #_num_public_announcements,
                #_transaction_timestamp,
            ))
        )]
        time_lock_witness: TimeLockWitness,
    ) {
        let rust_result = TimeLock.run_rust(
            &time_lock_witness.standard_input(),
            time_lock_witness.nondeterminism(),
        );
        prop_assert!(
            rust_result.is_ok(),
            "time lock program did not halt gracefully"
        );
        let tasm_result = TimeLock.run_tasm(
            &time_lock_witness.standard_input(),
            time_lock_witness.nondeterminism(),
        );
        prop_assert!(
            tasm_result.is_ok(),
            "time lock program did not halt gracefully"
        );
        prop_assert_eq!(rust_result.unwrap(), tasm_result.unwrap());
    }

    #[test]
    fn tx_timestamp_same_as_release_time_must_fail() {
        // Verify use of `>`, not `>=`.
        let release_date = Timestamp::now();
        let mut test_runner = TestRunner::deterministic();
        let time_lock_witness =
            TimeLockWitness::arbitrary_with((vec![release_date], 1, 0, release_date))
                .new_tree(&mut test_runner)
                .unwrap()
                .current();
        assert!(
            TimeLock {}
                .run_rust(
                    &time_lock_witness.standard_input(),
                    time_lock_witness.nondeterminism(),
                )
                .is_err(),
            "time lock program failed to panic"
        );
        assert!(
            TimeLock {}
                .run_tasm(
                    &time_lock_witness.standard_input(),
                    time_lock_witness.nondeterminism(),
                )
                .is_err(),
            "time lock program failed to panic"
        );
    }

    #[proptest(cases = 20)]
    fn test_locked(
        #[strategy(1usize..=3)] _num_inputs: usize,
        #[strategy(1usize..=3)] _num_outputs: usize,
        #[strategy(1usize..=3)] _num_public_announcements: usize,
        #[strategy(
            vec(
                Timestamp::arbitrary_between(
                    Timestamp::now() - Timestamp::days(7),
                    Timestamp::now() - Timestamp::days(1),
                ),
                #_num_inputs,
            )
        )]
        _release_dates: Vec<Timestamp>,
        #[strategy(Just::<Timestamp>(#_release_dates.iter().copied().max().unwrap()))]
        _tx_timestamp: Timestamp,
        #[strategy(
            TimeLockWitness::arbitrary_with((
                #_release_dates,
                #_num_outputs,
                #_num_public_announcements,
                #_tx_timestamp,
            ))
        )]
        time_lock_witness: TimeLockWitness,
    ) {
        println!("now: {}", Timestamp::now());
        prop_assert!(
            TimeLock {}
                .run_rust(
                    &time_lock_witness.standard_input(),
                    time_lock_witness.nondeterminism(),
                )
                .is_err(),
            "time lock program failed to panic"
        );
        prop_assert!(
            TimeLock {}
                .run_tasm(
                    &time_lock_witness.standard_input(),
                    time_lock_witness.nondeterminism(),
                )
                .is_err(),
            "time lock program failed to panic"
        );
    }

    #[proptest(cases = 20)]
    fn test_released(
        #[strategy(1usize..=3)] _num_inputs: usize,
        #[strategy(1usize..=3)] _num_outputs: usize,
        #[strategy(1usize..=3)] _num_public_announcements: usize,
        #[strategy(
            vec(
                Timestamp::arbitrary_between(
                    Timestamp::now() - Timestamp::days(7),
                    Timestamp::now() - Timestamp::days(1),
                ),
                #_num_inputs,
            )
        )]
        _release_dates: Vec<Timestamp>,
        #[strategy(Just::<Timestamp>(#_release_dates.iter().copied().max().unwrap()))]
        _tx_timestamp: Timestamp,
        #[strategy(
            TimeLockWitness::arbitrary_with((
                #_release_dates,
                #_num_outputs,
                #_num_public_announcements,
                #_tx_timestamp + Timestamp::days(1),
            ))
        )]
        time_lock_witness: TimeLockWitness,
    ) {
        println!("now: {}", Timestamp::now());
        let rust_result = TimeLock.run_rust(
            &time_lock_witness.standard_input(),
            time_lock_witness.nondeterminism(),
        );
        prop_assert!(
            rust_result.is_ok(),
            "time lock program did not halt gracefully"
        );
        let tasm_result = TimeLock.run_tasm(
            &time_lock_witness.standard_input(),
            time_lock_witness.nondeterminism(),
        );
        prop_assert!(
            tasm_result.is_ok(),
            "time lock program did not halt gracefully"
        );
        prop_assert_eq!(rust_result.unwrap(), tasm_result.unwrap());
    }

    #[proptest(cases = 5)]
    fn primitive_witness_with_active_timelocks_is_invalid(
        #[strategy(arb::<Timestamp>())] _now: Timestamp,
        #[strategy(arbitrary_primitive_witness_with_active_timelocks(2, 2, 2, #_now))]
        primitive_witness: PrimitiveWitness,
    ) {
        // Negative test: Primitive witness spending inputs that are timelocked
        // must fail to validate.
        let rt = crate::tests::tokio_runtime();
        prop_assert!(rt.block_on(primitive_witness.validate()).is_err());
    }

    #[proptest(cases = 10)]
    fn arbitrary_primitive_witness_with_active_timelocks_fails(
        #[strategy(arb::<Timestamp>())] _now: Timestamp,
        #[strategy(arbitrary_primitive_witness_with_active_timelocks(2, 2, 2, #_now))]
        primitive_witness: PrimitiveWitness,
    ) {
        let time_lock_witness = TimeLockWitness::from(primitive_witness);

        prop_assert!(
            TimeLock {}
                .run_rust(
                    &time_lock_witness.standard_input(),
                    time_lock_witness.nondeterminism(),
                )
                .is_err(),
            "time lock program failed to panic"
        );
        prop_assert!(
            TimeLock {}
                .run_tasm(
                    &time_lock_witness.standard_input(),
                    time_lock_witness.nondeterminism(),
                )
                .is_err(),
            "time lock program failed to panic"
        );
    }

    #[proptest(cases = 10)]
    fn arbitrary_primitive_witness_with_expired_timelocks_passes(
        #[strategy(arb::<Timestamp>())] _now: Timestamp,
        #[strategy(arbitrary_primitive_witness_with_expired_timelocks(2, 2, 2, #_now))]
        primitive_witness: PrimitiveWitness,
    ) {
        let time_lock_witness = TimeLockWitness::from(primitive_witness);

        let rust_result = TimeLock.run_rust(
            &time_lock_witness.standard_input(),
            time_lock_witness.nondeterminism(),
        );
        prop_assert!(
            rust_result.is_ok(),
            "time lock program did not halt gracefully"
        );
        let tasm_result = TimeLock.run_tasm(
            &time_lock_witness.standard_input(),
            time_lock_witness.nondeterminism(),
        );
        prop_assert!(
            tasm_result.is_ok(),
            "time lock program did not halt gracefully"
        );
        prop_assert_eq!(tasm_result.unwrap(), rust_result.unwrap());
    }
}

Neptune-Crypto / neptune-core / 14703155990

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous