tap_core 6.0.2

Core Timeline Aggregation Protocol library: a fast, efficient and trustless unidirectional micro-payments system.
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

// Copyright 2023-, Semiotic AI, Inc.
// SPDX-License-Identifier: Apache-2.0

use std::{
    collections::HashMap,
    str::FromStr,
    sync::{Arc, RwLock},
};

use rstest::*;
use tap_core::{
    manager::{
        adapters::{RavRead, RavStore},
        context::memory::InMemoryContext,
    },
    receipt::checks::StatefulTimestampCheck,
    signed_message::Eip712SignedMessage,
    tap_eip712_domain, TapVersion,
};
use tap_graph::{Receipt, ReceiptAggregateVoucher};
#[allow(deprecated)]
use thegraph_core::alloy::primitives::{Address, Signature};
use thegraph_core::alloy::{
    dyn_abi::Eip712Domain,
    signers::local::{coins_bip39::English, MnemonicBuilder, PrivateKeySigner},
};

#[fixture]
fn domain_separator() -> Eip712Domain {
    tap_eip712_domain(1, Address::from([0x11u8; 20]), TapVersion::V1)
}

#[fixture]
fn context() -> InMemoryContext {
    let escrow_storage = Arc::new(RwLock::new(HashMap::new()));
    let rav_storage = Arc::new(RwLock::new(None));
    let receipt_storage = Arc::new(RwLock::new(HashMap::new()));

    let timestamp_check = Arc::new(StatefulTimestampCheck::new(0));
    InMemoryContext::new(
        rav_storage,
        receipt_storage.clone(),
        escrow_storage.clone(),
        timestamp_check,
    )
}

#[rstest]
fn check_for_rav_serialization(domain_separator: Eip712Domain) {
    let allocation_id = Address::from_str("0xabababababababababababababababababababab").unwrap();
    let wallet = MnemonicBuilder::<English>::default()
        .phrase("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about")
        .build()
        .unwrap();
    let mut receipts = Vec::new();
    for value in 50..60 {
        receipts.push(
            Eip712SignedMessage::new(
                &domain_separator,
                Receipt {
                    allocation_id,
                    value,
                    nonce: value as u64,
                    timestamp_ns: value as u64,
                },
                &wallet,
            )
            .unwrap(),
        );
    }

    let signed_rav = Eip712SignedMessage::new(
        &domain_separator,
        ReceiptAggregateVoucher::aggregate_receipts(allocation_id, &receipts, None).unwrap(),
        &wallet,
    )
    .unwrap();

    insta::assert_json_snapshot!(receipts);
    insta::assert_json_snapshot!(signed_rav);

    let raw_sig = r#"{
      "r": "0x1596dd0d380ede7aa5dec5ed09ea7d1fa8e4bc8dfdb43a4e965bb4f16906e321",
      "s": "0x788b69625a031fbd2e769928b63505387df16e7c51f19ff67c782bfec101a387",
      "yParity": "0x1"
    }"#;

    serde_json::from_str::<Signature>(raw_sig).unwrap();
    #[allow(deprecated)]
    serde_json::from_str::<Signature>(raw_sig).unwrap();
}

#[rstest]
#[tokio::test]
async fn rav_storage_adapter_test(domain_separator: Eip712Domain, context: InMemoryContext) {
    let wallet = PrivateKeySigner::random();

    let allocation_id = Address::from_str("0xabababababababababababababababababababab").unwrap();

    // Create receipts
    let mut receipts = Vec::new();
    for value in 50..60 {
        receipts.push(
            Eip712SignedMessage::new(
                &domain_separator,
                Receipt::new(allocation_id, value).unwrap(),
                &wallet,
            )
            .unwrap(),
        );
    }

    let signed_rav = Eip712SignedMessage::new(
        &domain_separator,
        ReceiptAggregateVoucher::aggregate_receipts(allocation_id, &receipts, None).unwrap(),
        &wallet,
    )
    .unwrap();

    context.update_last_rav(signed_rav.clone()).await.unwrap();

    // Retreive rav
    let retrieved_rav = context.last_rav().await;
    assert!(retrieved_rav.unwrap().unwrap() == signed_rav);

    // Testing the last rav update...

    // Create more receipts
    let mut receipts = Vec::new();
    for value in 60..70 {
        receipts.push(
            Eip712SignedMessage::new(
                &domain_separator,
                Receipt::new(allocation_id, value).unwrap(),
                &wallet,
            )
            .unwrap(),
        );
    }

    let signed_rav = Eip712SignedMessage::new(
        &domain_separator,
        ReceiptAggregateVoucher::aggregate_receipts(allocation_id, &receipts, None).unwrap(),
        &wallet,
    )
    .unwrap();

    // Update the last rav
    context.update_last_rav(signed_rav.clone()).await.unwrap();

    // Retreive rav
    let retrieved_rav = context.last_rav().await;
    assert!(retrieved_rav.unwrap().unwrap() == signed_rav);
}