eip712 0.1.0

tool to generate EIP-712 compatible Solidity
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

// Copyright (c) 2022 Sam Wilson.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

use eip712::abi::{self, Kind, StateMutability};

#[cfg(target_arch = "wasm32")]
use wasm_bindgen_test::wasm_bindgen_test as test;

#[test]
fn ownable() {
    let ownable = abi::from_slice(include_bytes!("abi/ownable.json")).unwrap();
    assert_eq!(4, ownable.len());

    // event OwnershipTransferred(address previousOwner, address newOwner)
    let event = ownable[0].as_event().unwrap();
    assert_eq!(false, event.anonymous());
    assert_eq!("OwnershipTransferred", event.name());

    let inputs = event.inputs();
    assert_eq!(2, inputs.len());

    assert_eq!(true, inputs[0].indexed());
    assert_eq!(
        Kind::address(),
        inputs[0].internal_kind().clone().try_into().unwrap()
    );
    assert_eq!("previousOwner", inputs[0].name());
    assert_eq!(&Kind::address(), inputs[0].kind());

    assert_eq!(true, inputs[1].indexed());
    assert_eq!(
        Kind::address(),
        inputs[1].internal_kind().clone().try_into().unwrap()
    );
    assert_eq!("newOwner", inputs[1].name());
    assert_eq!(&Kind::address(), inputs[1].kind());

    //
    // function owner()
    //
    let func = ownable[1].as_function().unwrap();
    assert_eq!("owner", func.name());
    assert_eq!(StateMutability::View, func.state_mutability());

    assert!(func.inputs().is_empty());

    let outputs = func.outputs();
    assert_eq!(1, outputs.len());

    assert_eq!(
        Kind::address(),
        outputs[0].internal_kind().clone().try_into().unwrap()
    );
    assert_eq!("", outputs[0].name());
    assert_eq!(&Kind::address(), outputs[0].kind());

    //
    // function renounceOwnership()
    //
    let func = ownable[2].as_function().unwrap();
    assert_eq!("renounceOwnership", func.name());
    assert_eq!(StateMutability::Nonpayable, func.state_mutability());

    assert!(func.inputs().is_empty());
    assert!(func.outputs().is_empty());

    //
    // function transferOwnership(address newOwner)
    //
    let func = ownable[3].as_function().unwrap();
    assert_eq!("transferOwnership", func.name());
    assert_eq!(StateMutability::Nonpayable, func.state_mutability());

    assert!(func.outputs().is_empty());

    let inputs = func.inputs();
    assert_eq!(1, inputs.len());

    assert_eq!(
        Kind::address(),
        inputs[0].internal_kind().clone().try_into().unwrap()
    );
    assert_eq!("newOwner", inputs[0].name());
    assert_eq!(&Kind::address(), inputs[0].kind());
}

const FOO: &[u8] = include_bytes!("abi/foo.json");

#[test]
fn foo() {
    let foo = abi::from_slice(FOO).unwrap();
    assert_eq!(3, foo.len());

    // TODO
}

#[test]
fn foo_to_foo() {
    let expected: serde_json::Value = serde_json::from_slice(FOO).unwrap();

    let foo = abi::from_slice(FOO).unwrap();
    let actual = serde_json::to_value(foo).unwrap();

    if expected != actual {
        println!("Expected:");
        println!("{:#}", expected);
        println!();
        println!("Actual:");
        println!("{:#}", actual);
    }

    assert_eq!(expected, actual);
}