/
lib.rs
129 lines (115 loc) · 3.1 KB
/
lib.rs
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
// TODO: #![deny(missing_docs)]
#![warn(clippy::all)]
#![cfg_attr(feature = "strict", deny(warnings))]
pub mod binops;
pub mod channel;
pub mod curve;
mod division;
pub mod ecdsa;
pub mod fft;
pub mod fibonacci;
pub mod field;
pub mod gcd;
pub mod jacobian;
pub mod merkle;
pub mod montgomery;
pub mod orders;
pub mod pedersen;
mod pedersen_points;
pub mod polynomial;
pub mod square_root;
pub mod u256;
mod utils;
pub mod wnaf;
use curve::Affine;
use field::FieldElement;
use u256::U256;
pub mod proofs;
fn from_bytes(bytes: &[u8; 32]) -> U256 {
U256::from_bytes_be(bytes)
}
fn to_bytes(num: &U256) -> [u8; 32] {
num.to_bytes_be()
}
pub fn hash(a: &[u8; 32], b: &[u8; 32]) -> [u8; 32] {
let hash = pedersen::hash(&[from_bytes(a), from_bytes(b)]);
to_bytes(&hash)
}
pub fn public_key(private_key: &[u8; 32]) -> ([u8; 32], [u8; 32]) {
let p = ecdsa::private_to_public(&from_bytes(private_key));
match p {
Affine::Zero => panic!(),
Affine::Point { x, y } => (x.to_bytes(), y.to_bytes()),
}
}
pub fn sign(message_hash: &[u8; 32], private_key: &[u8; 32]) -> ([u8; 32], [u8; 32]) {
let (r, w) = ecdsa::sign(&from_bytes(message_hash), &from_bytes(private_key));
(to_bytes(&r), to_bytes(&w))
}
pub fn verify(
message_hash: &[u8; 32],
signature: (&[u8; 32], &[u8; 32]),
public_key: (&[u8; 32], &[u8; 32]),
) -> bool {
ecdsa::verify(
&from_bytes(message_hash),
&from_bytes(signature.0),
&from_bytes(signature.1),
&Affine::Point {
x: FieldElement::from(public_key.0),
y: FieldElement::from(public_key.1),
},
)
}
pub type MakerMessage = orders::MakerMessage<[u8; 32]>;
pub fn maker_hash(message: &MakerMessage) -> [u8; 32] {
let m = orders::MakerMessage {
vault_a: message.vault_a,
vault_b: message.vault_b,
amount_a: message.amount_a,
amount_b: message.amount_b,
token_a: from_bytes(&message.token_a),
token_b: from_bytes(&message.token_b),
trade_id: message.trade_id,
};
let h = orders::hash_maker(&m);
to_bytes(&h)
}
pub fn taker_hash(maker_hash: &[u8; 32], vault_a: u32, vault_b: u32) -> [u8; 32] {
let h = orders::hash_taker(&from_bytes(maker_hash), vault_a, vault_b);
to_bytes(&h)
}
pub fn maker_sign(message: &MakerMessage, private_key: &[u8; 32]) -> ([u8; 32], [u8; 32]) {
sign(&maker_hash(message), private_key)
}
pub fn taker_sign(
message: &MakerMessage,
vault_a: u32,
vault_b: u32,
private_key: &[u8; 32],
) -> ([u8; 32], [u8; 32]) {
sign(
&taker_hash(&maker_hash(message), vault_a, vault_b),
private_key,
)
}
pub fn maker_verify(
message: &MakerMessage,
signature: (&[u8; 32], &[u8; 32]),
public_key: (&[u8; 32], &[u8; 32]),
) -> bool {
verify(&maker_hash(message), signature, public_key)
}
pub fn taker_verify(
message: &MakerMessage,
vault_a: u32,
vault_b: u32,
signature: (&[u8; 32], &[u8; 32]),
public_key: (&[u8; 32], &[u8; 32]),
) -> bool {
verify(
&taker_hash(&maker_hash(message), vault_a, vault_b),
signature,
public_key,
)
}