evmlib 0.8.1

Safe Network EVM
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

#![allow(clippy::expect_used)]

mod common;

use alloy::network::{Ethereum, EthereumWallet, NetworkWallet};
use alloy::node_bindings::AnvilInstance;
use alloy::primitives::U256;
use alloy::providers::fillers::{
    BlobGasFiller, ChainIdFiller, FillProvider, GasFiller, JoinFill, NonceFiller,
    SimpleNonceManager, WalletFiller,
};
use alloy::providers::{Identity, RootProvider, WalletProvider};
use alloy::signers::local::PrivateKeySigner;
use evmlib::contract::network_token::NetworkToken;
use evmlib::testnet::{deploy_network_token_contract, start_node};
use evmlib::transaction_config::TransactionConfig;
use evmlib::wallet::wallet_address;
use std::str::FromStr;

async fn setup() -> (
    AnvilInstance,
    NetworkToken<
        FillProvider<
            JoinFill<
                JoinFill<
                    JoinFill<
                        Identity,
                        JoinFill<
                            GasFiller,
                            JoinFill<BlobGasFiller, JoinFill<NonceFiller, ChainIdFiller>>,
                        >,
                    >,
                    NonceFiller<SimpleNonceManager>,
                >,
                WalletFiller<EthereumWallet>,
            >,
            RootProvider,
            Ethereum,
        >,
        Ethereum,
    >,
) {
    let (node, rpc_url) = start_node().unwrap();

    let network_token = deploy_network_token_contract(&rpc_url, &node)
        .await
        .unwrap();

    (node, network_token)
}

#[tokio::test]
async fn test_deploy() {
    setup().await;
}

#[tokio::test]
async fn test_balance_of() {
    let (_anvil, contract) = setup().await;

    let account = <EthereumWallet as NetworkWallet<Ethereum>>::default_signer_address(
        contract.contract.provider().wallet(),
    );

    let balance = contract.balance_of(account).await.unwrap();

    assert_eq!(
        balance,
        U256::from_str("2500000000000000000000000").unwrap()
    );
}

#[tokio::test]
async fn test_approve() {
    let (_anvil, network_token) = setup().await;

    let account = wallet_address(network_token.contract.provider().wallet());

    let transaction_value = U256::from(1);
    let spender = PrivateKeySigner::random();

    let transaction_config = TransactionConfig::default();

    // Approve for the spender to spend a value from the funds of the owner (our default account).
    let approval_result = network_token
        .approve(spender.address(), transaction_value, &transaction_config)
        .await;

    assert!(
        approval_result.is_ok(),
        "Approval failed with error: {:?}",
        approval_result.err()
    );

    let allowance = network_token
        .contract
        .allowance(account, spender.address())
        .call()
        .await
        .unwrap();

    assert_eq!(allowance, transaction_value);
}