1use crate::std::{vec, Vec};
12use crate::{util::pad_u32, Token, Word};
13use tiny_keccak::{Hasher, Keccak};
14
15fn pad_bytes(bytes: &[u8]) -> Vec<Word> {
16 let mut result = vec![pad_u32(bytes.len() as u32)];
17 result.extend(pad_fixed_bytes(bytes));
18 result
19}
20
21fn pad_fixed_bytes(bytes: &[u8]) -> Vec<Word> {
22 let len = (bytes.len() + 31) / 32;
23 let mut result = Vec::with_capacity(len);
24 for i in 0..len {
25 let mut padded = [0u8; 32];
26
27 let to_copy = match i == len - 1 {
28 false => 32,
29 true => match bytes.len() % 32 {
30 0 => 32,
31 x => x,
32 },
33 };
34
35 let offset = 32 * i;
36 padded[..to_copy].copy_from_slice(&bytes[offset..offset + to_copy]);
37 result.push(padded);
38 }
39
40 result
41}
42
43#[derive(Debug)]
44enum Mediate {
45 Raw(Vec<Word>),
46 Prefixed(Vec<Word>),
47 PrefixedArray(Vec<Mediate>),
48 PrefixedArrayWithLength(Vec<Mediate>),
49 RawTuple(Vec<Mediate>),
50 PrefixedTuple(Vec<Mediate>),
51}
52
53impl Mediate {
54 fn head_len(&self) -> u32 {
55 match *self {
56 Mediate::Raw(ref raw) => 32 * raw.len() as u32,
57 Mediate::RawTuple(ref mediates) => 32 * mediates.len() as u32,
58 Mediate::Prefixed(_)
59 | Mediate::PrefixedArray(_)
60 | Mediate::PrefixedArrayWithLength(_)
61 | Mediate::PrefixedTuple(_) => 32,
62 }
63 }
64
65 fn tail_len(&self) -> u32 {
66 match *self {
67 Mediate::Raw(_) | Mediate::RawTuple(_) => 0,
68 Mediate::Prefixed(ref pre) => pre.len() as u32 * 32,
69 Mediate::PrefixedArray(ref mediates) => mediates.iter().fold(0, |acc, m| acc + m.head_len() + m.tail_len()),
70 Mediate::PrefixedArrayWithLength(ref mediates) => {
71 mediates.iter().fold(32, |acc, m| acc + m.head_len() + m.tail_len())
72 }
73 Mediate::PrefixedTuple(ref mediates) => mediates.iter().fold(0, |acc, m| acc + m.head_len() + m.tail_len()),
74 }
75 }
76
77 fn head(&self, suffix_offset: u32) -> Vec<Word> {
78 match *self {
79 Mediate::Raw(ref raw) => raw.clone(),
80 Mediate::RawTuple(ref raw) => raw.iter().map(|mediate| mediate.head(0)).flatten().collect(),
81 Mediate::Prefixed(_)
82 | Mediate::PrefixedArray(_)
83 | Mediate::PrefixedArrayWithLength(_)
84 | Mediate::PrefixedTuple(_) => vec![pad_u32(suffix_offset)],
85 }
86 }
87
88 fn tail(&self) -> Vec<Word> {
89 match *self {
90 Mediate::Raw(_) | Mediate::RawTuple(_) => vec![],
91 Mediate::PrefixedTuple(ref mediates) => encode_head_tail(mediates),
92 Mediate::Prefixed(ref raw) => raw.clone(),
93 Mediate::PrefixedArray(ref mediates) => encode_head_tail(mediates),
94 Mediate::PrefixedArrayWithLength(ref mediates) => {
95 let mut result = vec![pad_u32(mediates.len() as u32)];
97
98 let head_tail = encode_head_tail(mediates);
99
100 result.extend(head_tail);
101 result
102 }
103 }
104 }
105}
106
107fn encode_head_tail(mediates: &Vec<Mediate>) -> Vec<Word> {
108 let heads_len = mediates.iter().fold(0, |acc, m| acc + m.head_len());
109
110 let (mut result, len) =
111 mediates.iter().fold((Vec::with_capacity(heads_len as usize), heads_len), |(mut acc, offset), m| {
112 acc.extend(m.head(offset));
113 (acc, offset + m.tail_len())
114 });
115
116 let tails = mediates.iter().fold(Vec::with_capacity((len - heads_len) as usize), |mut acc, m| {
117 acc.extend(m.tail());
118 acc
119 });
120
121 result.extend(tails);
122 result
123}
124
125pub fn encode(tokens: &[Token]) -> Vec<u8> {
127 let mediates = &tokens.iter().map(encode_token).collect();
128
129 encode_head_tail(mediates).iter().flat_map(|word| word.to_vec()).collect()
130}
131
132pub fn encode_function(signature: &str, inputs: &[Token]) -> Vec<u8> {
133 let mut signed: [u8; 4] = [0; 4];
134 let mut sponge = Keccak::v256();
135 sponge.update(signature.as_ref());
136 sponge.finalize(&mut signed);
137 let encoded = encode(inputs);
138 signed.to_vec().into_iter().chain(encoded.into_iter()).collect()
139}
140
141fn encode_token(token: &Token) -> Mediate {
142 match *token {
143 Token::Address(ref address) => {
144 let mut padded = [0u8; 32];
145 padded[12..].copy_from_slice(address.as_ref());
146 Mediate::Raw(vec![padded])
147 }
148 Token::Bytes(ref bytes) => Mediate::Prefixed(pad_bytes(bytes)),
149 Token::String(ref s) => Mediate::Prefixed(pad_bytes(s.as_ref())),
150 Token::FixedBytes(ref bytes) => Mediate::Raw(pad_fixed_bytes(bytes)),
151 Token::Int(int) => Mediate::Raw(vec![int.to_big_endian()]),
152 Token::Uint(uint) => Mediate::Raw(vec![uint.to_big_endian()]),
153 Token::Bool(b) => {
154 let mut value = [0u8; 32];
155 if b {
156 value[31] = 1;
157 }
158 Mediate::Raw(vec![value])
159 }
160 Token::Array(ref tokens) => {
161 let mediates = tokens.iter().map(encode_token).collect();
162
163 Mediate::PrefixedArrayWithLength(mediates)
164 }
165 Token::FixedArray(ref tokens) => {
166 let mediates = tokens.iter().map(encode_token).collect();
167
168 if token.is_dynamic() {
169 Mediate::PrefixedArray(mediates)
170 } else {
171 Mediate::Raw(encode_head_tail(&mediates))
172 }
173 }
174 Token::Tuple(ref tokens) if token.is_dynamic() => {
175 let mediates = tokens.iter().map(encode_token).collect();
176
177 Mediate::PrefixedTuple(mediates)
178 }
179 Token::Tuple(ref tokens) => {
180 let mediates = tokens.iter().map(encode_token).collect();
181
182 Mediate::RawTuple(mediates)
183 }
184 }
185}
186
187#[cfg(test)]
188mod tests {
189 use crate::{encode, encode_function, util::pad_u32, Token, U256};
190 use hex_literal::hex;
191
192 #[test]
193 fn encode_address() {
194 let address = Token::Address([0x11u8; 20].into());
195 let encoded = encode(&vec![address]);
196 let expected = hex!("0000000000000000000000001111111111111111111111111111111111111111");
197 assert_eq!(encoded, expected);
198 }
199
200 #[test]
201 fn encode_dynamic_array_of_addresses() {
202 let address1 = Token::Address([0x11u8; 20].into());
203 let address2 = Token::Address([0x22u8; 20].into());
204 let addresses = Token::Array(vec![address1, address2]);
205 let encoded = encode(&vec![addresses]);
206 let expected = hex!(
207 "
208 0000000000000000000000000000000000000000000000000000000000000020
209 0000000000000000000000000000000000000000000000000000000000000002
210 0000000000000000000000001111111111111111111111111111111111111111
211 0000000000000000000000002222222222222222222222222222222222222222
212 "
213 )
214 .to_vec();
215 assert_eq!(encoded, expected);
216 }
217
218 #[test]
219 fn encode_fixed_array_of_addresses() {
220 let address1 = Token::Address([0x11u8; 20].into());
221 let address2 = Token::Address([0x22u8; 20].into());
222 let addresses = Token::FixedArray(vec![address1, address2]);
223 let encoded = encode(&vec![addresses]);
224 let expected = hex!(
225 "
226 0000000000000000000000001111111111111111111111111111111111111111
227 0000000000000000000000002222222222222222222222222222222222222222
228 "
229 )
230 .to_vec();
231 assert_eq!(encoded, expected);
232 }
233
234 #[test]
235 fn encode_two_addresses() {
236 let address1 = Token::Address([0x11u8; 20].into());
237 let address2 = Token::Address([0x22u8; 20].into());
238 let encoded = encode(&vec![address1, address2]);
239 let expected = hex!(
240 "
241 0000000000000000000000001111111111111111111111111111111111111111
242 0000000000000000000000002222222222222222222222222222222222222222
243 "
244 )
245 .to_vec();
246 assert_eq!(encoded, expected);
247 }
248
249 #[test]
250 fn encode_fixed_array_of_dynamic_array_of_addresses() {
251 let address1 = Token::Address([0x11u8; 20].into());
252 let address2 = Token::Address([0x22u8; 20].into());
253 let address3 = Token::Address([0x33u8; 20].into());
254 let address4 = Token::Address([0x44u8; 20].into());
255 let array0 = Token::Array(vec![address1, address2]);
256 let array1 = Token::Array(vec![address3, address4]);
257 let fixed = Token::FixedArray(vec![array0, array1]);
258 let encoded = encode(&vec![fixed]);
259 let expected = hex!(
260 "
261 0000000000000000000000000000000000000000000000000000000000000020
262 0000000000000000000000000000000000000000000000000000000000000040
263 00000000000000000000000000000000000000000000000000000000000000a0
264 0000000000000000000000000000000000000000000000000000000000000002
265 0000000000000000000000001111111111111111111111111111111111111111
266 0000000000000000000000002222222222222222222222222222222222222222
267 0000000000000000000000000000000000000000000000000000000000000002
268 0000000000000000000000003333333333333333333333333333333333333333
269 0000000000000000000000004444444444444444444444444444444444444444
270 "
271 )
272 .to_vec();
273 assert_eq!(encoded, expected);
274 }
275
276 #[test]
277 fn encode_dynamic_array_of_fixed_array_of_addresses() {
278 let address1 = Token::Address([0x11u8; 20].into());
279 let address2 = Token::Address([0x22u8; 20].into());
280 let address3 = Token::Address([0x33u8; 20].into());
281 let address4 = Token::Address([0x44u8; 20].into());
282 let array0 = Token::FixedArray(vec![address1, address2]);
283 let array1 = Token::FixedArray(vec![address3, address4]);
284 let dynamic = Token::Array(vec![array0, array1]);
285 let encoded = encode(&vec![dynamic]);
286 let expected = hex!(
287 "
288 0000000000000000000000000000000000000000000000000000000000000020
289 0000000000000000000000000000000000000000000000000000000000000002
290 0000000000000000000000001111111111111111111111111111111111111111
291 0000000000000000000000002222222222222222222222222222222222222222
292 0000000000000000000000003333333333333333333333333333333333333333
293 0000000000000000000000004444444444444444444444444444444444444444
294 "
295 )
296 .to_vec();
297 assert_eq!(encoded, expected);
298 }
299
300 #[test]
301 fn encode_dynamic_array_of_dynamic_arrays() {
302 let address1 = Token::Address([0x11u8; 20].into());
303 let address2 = Token::Address([0x22u8; 20].into());
304 let array0 = Token::Array(vec![address1]);
305 let array1 = Token::Array(vec![address2]);
306 let dynamic = Token::Array(vec![array0, array1]);
307 let encoded = encode(&vec![dynamic]);
308 let expected = hex!(
309 "
310 0000000000000000000000000000000000000000000000000000000000000020
311 0000000000000000000000000000000000000000000000000000000000000002
312 0000000000000000000000000000000000000000000000000000000000000040
313 0000000000000000000000000000000000000000000000000000000000000080
314 0000000000000000000000000000000000000000000000000000000000000001
315 0000000000000000000000001111111111111111111111111111111111111111
316 0000000000000000000000000000000000000000000000000000000000000001
317 0000000000000000000000002222222222222222222222222222222222222222
318 "
319 )
320 .to_vec();
321 assert_eq!(encoded, expected);
322 }
323
324 #[test]
325 fn encode_dynamic_array_of_dynamic_arrays2() {
326 let address1 = Token::Address([0x11u8; 20].into());
327 let address2 = Token::Address([0x22u8; 20].into());
328 let address3 = Token::Address([0x33u8; 20].into());
329 let address4 = Token::Address([0x44u8; 20].into());
330 let array0 = Token::Array(vec![address1, address2]);
331 let array1 = Token::Array(vec![address3, address4]);
332 let dynamic = Token::Array(vec![array0, array1]);
333 let encoded = encode(&vec![dynamic]);
334 let expected = hex!(
335 "
336 0000000000000000000000000000000000000000000000000000000000000020
337 0000000000000000000000000000000000000000000000000000000000000002
338 0000000000000000000000000000000000000000000000000000000000000040
339 00000000000000000000000000000000000000000000000000000000000000a0
340 0000000000000000000000000000000000000000000000000000000000000002
341 0000000000000000000000001111111111111111111111111111111111111111
342 0000000000000000000000002222222222222222222222222222222222222222
343 0000000000000000000000000000000000000000000000000000000000000002
344 0000000000000000000000003333333333333333333333333333333333333333
345 0000000000000000000000004444444444444444444444444444444444444444
346 "
347 )
348 .to_vec();
349 assert_eq!(encoded, expected);
350 }
351
352 #[test]
353 fn encode_fixed_array_of_fixed_arrays() {
354 let address1 = Token::Address([0x11u8; 20].into());
355 let address2 = Token::Address([0x22u8; 20].into());
356 let address3 = Token::Address([0x33u8; 20].into());
357 let address4 = Token::Address([0x44u8; 20].into());
358 let array0 = Token::FixedArray(vec![address1, address2]);
359 let array1 = Token::FixedArray(vec![address3, address4]);
360 let fixed = Token::FixedArray(vec![array0, array1]);
361 let encoded = encode(&vec![fixed]);
362 let expected = hex!(
363 "
364 0000000000000000000000001111111111111111111111111111111111111111
365 0000000000000000000000002222222222222222222222222222222222222222
366 0000000000000000000000003333333333333333333333333333333333333333
367 0000000000000000000000004444444444444444444444444444444444444444
368 "
369 )
370 .to_vec();
371 assert_eq!(encoded, expected);
372 }
373
374 #[test]
375 fn encode_empty_array() {
376 let encoded = encode(&vec![Token::Array(vec![]), Token::Array(vec![])]);
378 let expected = hex!(
379 "
380 0000000000000000000000000000000000000000000000000000000000000040
381 0000000000000000000000000000000000000000000000000000000000000060
382 0000000000000000000000000000000000000000000000000000000000000000
383 0000000000000000000000000000000000000000000000000000000000000000
384 "
385 )
386 .to_vec();
387 assert_eq!(encoded, expected);
388
389 let encoded = encode(&vec![Token::Array(vec![Token::Array(vec![])]), Token::Array(vec![Token::Array(vec![])])]);
391 let expected = hex!(
392 "
393 0000000000000000000000000000000000000000000000000000000000000040
394 00000000000000000000000000000000000000000000000000000000000000a0
395 0000000000000000000000000000000000000000000000000000000000000001
396 0000000000000000000000000000000000000000000000000000000000000020
397 0000000000000000000000000000000000000000000000000000000000000000
398 0000000000000000000000000000000000000000000000000000000000000001
399 0000000000000000000000000000000000000000000000000000000000000020
400 0000000000000000000000000000000000000000000000000000000000000000
401 "
402 )
403 .to_vec();
404 assert_eq!(encoded, expected);
405 }
406
407 #[test]
408 fn encode_bytes() {
409 let bytes = Token::Bytes(vec![0x12, 0x34]);
410 let encoded = encode(&vec![bytes]);
411 let expected = hex!(
412 "
413 0000000000000000000000000000000000000000000000000000000000000020
414 0000000000000000000000000000000000000000000000000000000000000002
415 1234000000000000000000000000000000000000000000000000000000000000
416 "
417 )
418 .to_vec();
419 assert_eq!(encoded, expected);
420 }
421
422 #[test]
423 fn encode_fixed_bytes() {
424 let bytes = Token::FixedBytes(vec![0x12, 0x34]);
425 let encoded = encode(&vec![bytes]);
426 let expected = hex!("1234000000000000000000000000000000000000000000000000000000000000");
427 assert_eq!(encoded, expected);
428 }
429
430 #[test]
431 fn encode_string() {
432 let s = Token::String("gavofyork".into());
433 let encoded = encode(&vec![s]);
434 let expected = hex!(
435 "
436 0000000000000000000000000000000000000000000000000000000000000020
437 0000000000000000000000000000000000000000000000000000000000000009
438 6761766f66796f726b0000000000000000000000000000000000000000000000
439 "
440 )
441 .to_vec();
442 assert_eq!(encoded, expected);
443 }
444
445 #[test]
446 fn encode_bytes2() {
447 let bytes = Token::Bytes(hex!("10000000000000000000000000000000000000000000000000000000000002").to_vec());
448 let encoded = encode(&vec![bytes]);
449 let expected = hex!(
450 "
451 0000000000000000000000000000000000000000000000000000000000000020
452 000000000000000000000000000000000000000000000000000000000000001f
453 1000000000000000000000000000000000000000000000000000000000000200
454 "
455 )
456 .to_vec();
457 assert_eq!(encoded, expected);
458 }
459
460 #[test]
461 fn encode_bytes3() {
462 let bytes = Token::Bytes(
463 hex!(
464 "
465 1000000000000000000000000000000000000000000000000000000000000000
466 1000000000000000000000000000000000000000000000000000000000000000
467 "
468 )
469 .to_vec(),
470 );
471 let encoded = encode(&vec![bytes]);
472 let expected = hex!(
473 "
474 0000000000000000000000000000000000000000000000000000000000000020
475 0000000000000000000000000000000000000000000000000000000000000040
476 1000000000000000000000000000000000000000000000000000000000000000
477 1000000000000000000000000000000000000000000000000000000000000000
478 "
479 )
480 .to_vec();
481 assert_eq!(encoded, expected);
482 }
483
484 #[test]
485 fn encode_two_bytes() {
486 let bytes1 = Token::Bytes(hex!("10000000000000000000000000000000000000000000000000000000000002").to_vec());
487 let bytes2 = Token::Bytes(hex!("0010000000000000000000000000000000000000000000000000000000000002").to_vec());
488 let encoded = encode(&vec![bytes1, bytes2]);
489 let expected = hex!(
490 "
491 0000000000000000000000000000000000000000000000000000000000000040
492 0000000000000000000000000000000000000000000000000000000000000080
493 000000000000000000000000000000000000000000000000000000000000001f
494 1000000000000000000000000000000000000000000000000000000000000200
495 0000000000000000000000000000000000000000000000000000000000000020
496 0010000000000000000000000000000000000000000000000000000000000002
497 "
498 )
499 .to_vec();
500 assert_eq!(encoded, expected);
501 }
502
503 #[test]
504 fn encode_uint() {
505 let mut uint = [0u8; 32];
506 uint[31] = 4;
507 let encoded = encode(&vec![Token::Uint(U256::from_big_endian(&uint))]);
508 let expected = hex!("0000000000000000000000000000000000000000000000000000000000000004");
509 assert_eq!(encoded, expected);
510 }
511
512 #[test]
513 fn encode_int() {
514 let mut int = [0u8; 32];
515 int[31] = 4;
516 let encoded = encode(&vec![Token::Int(U256::from_big_endian(&int))]);
517 let expected = hex!("0000000000000000000000000000000000000000000000000000000000000004");
518 assert_eq!(encoded, expected);
519 }
520
521 #[test]
522 fn encode_bool() {
523 let encoded = encode(&vec![Token::Bool(true)]);
524 let expected = hex!("0000000000000000000000000000000000000000000000000000000000000001");
525 assert_eq!(encoded, expected);
526 }
527
528 #[test]
529 fn encode_bool2() {
530 let encoded = encode(&vec![Token::Bool(false)]);
531 let expected = hex!("0000000000000000000000000000000000000000000000000000000000000000");
532 assert_eq!(encoded, expected);
533 }
534
535 #[test]
536 fn comprehensive_test() {
537 let bytes = hex!(
538 "
539 131a3afc00d1b1e3461b955e53fc866dcf303b3eb9f4c16f89e388930f48134b
540 131a3afc00d1b1e3461b955e53fc866dcf303b3eb9f4c16f89e388930f48134b
541 "
542 )
543 .to_vec();
544 let encoded =
545 encode(&vec![Token::Int(5.into()), Token::Bytes(bytes.clone()), Token::Int(3.into()), Token::Bytes(bytes)]);
546
547 let expected = hex!(
548 "
549 0000000000000000000000000000000000000000000000000000000000000005
550 0000000000000000000000000000000000000000000000000000000000000080
551 0000000000000000000000000000000000000000000000000000000000000003
552 00000000000000000000000000000000000000000000000000000000000000e0
553 0000000000000000000000000000000000000000000000000000000000000040
554 131a3afc00d1b1e3461b955e53fc866dcf303b3eb9f4c16f89e388930f48134b
555 131a3afc00d1b1e3461b955e53fc866dcf303b3eb9f4c16f89e388930f48134b
556 0000000000000000000000000000000000000000000000000000000000000040
557 131a3afc00d1b1e3461b955e53fc866dcf303b3eb9f4c16f89e388930f48134b
558 131a3afc00d1b1e3461b955e53fc866dcf303b3eb9f4c16f89e388930f48134b
559 "
560 )
561 .to_vec();
562 assert_eq!(encoded, expected);
563 }
564
565 #[test]
566 fn test_pad_u32() {
567 assert_eq!(pad_u32(0x1)[31], 1);
569 assert_eq!(pad_u32(0x100)[30], 1);
570 }
571
572 #[test]
573 fn comprehensive_test2() {
574 let encoded = encode(&vec![
575 Token::Int(1.into()),
576 Token::String("gavofyork".into()),
577 Token::Int(2.into()),
578 Token::Int(3.into()),
579 Token::Int(4.into()),
580 Token::Array(vec![Token::Int(5.into()), Token::Int(6.into()), Token::Int(7.into())]),
581 ]);
582
583 let expected = hex!(
584 "
585 0000000000000000000000000000000000000000000000000000000000000001
586 00000000000000000000000000000000000000000000000000000000000000c0
587 0000000000000000000000000000000000000000000000000000000000000002
588 0000000000000000000000000000000000000000000000000000000000000003
589 0000000000000000000000000000000000000000000000000000000000000004
590 0000000000000000000000000000000000000000000000000000000000000100
591 0000000000000000000000000000000000000000000000000000000000000009
592 6761766f66796f726b0000000000000000000000000000000000000000000000
593 0000000000000000000000000000000000000000000000000000000000000003
594 0000000000000000000000000000000000000000000000000000000000000005
595 0000000000000000000000000000000000000000000000000000000000000006
596 0000000000000000000000000000000000000000000000000000000000000007
597 "
598 )
599 .to_vec();
600 assert_eq!(encoded, expected);
601 }
602
603 #[test]
604 fn encode_dynamic_array_of_bytes() {
605 let bytes = hex!("019c80031b20d5e69c8093a571162299032018d913930d93ab320ae5ea44a4218a274f00d607");
606 let encoded = encode(&vec![Token::Array(vec![Token::Bytes(bytes.to_vec())])]);
607
608 let expected = hex!(
609 "
610 0000000000000000000000000000000000000000000000000000000000000020
611 0000000000000000000000000000000000000000000000000000000000000001
612 0000000000000000000000000000000000000000000000000000000000000020
613 0000000000000000000000000000000000000000000000000000000000000026
614 019c80031b20d5e69c8093a571162299032018d913930d93ab320ae5ea44a421
615 8a274f00d6070000000000000000000000000000000000000000000000000000
616 "
617 )
618 .to_vec();
619 assert_eq!(encoded, expected);
620 }
621
622 #[test]
623 fn encode_dynamic_array_of_bytes2() {
624 let bytes = hex!("4444444444444444444444444444444444444444444444444444444444444444444444444444");
625 let bytes2 = hex!("6666666666666666666666666666666666666666666666666666666666666666666666666666");
626 let encoded = encode(&vec![Token::Array(vec![Token::Bytes(bytes.to_vec()), Token::Bytes(bytes2.to_vec())])]);
627
628 let expected = hex!(
629 "
630 0000000000000000000000000000000000000000000000000000000000000020
631 0000000000000000000000000000000000000000000000000000000000000002
632 0000000000000000000000000000000000000000000000000000000000000040
633 00000000000000000000000000000000000000000000000000000000000000a0
634 0000000000000000000000000000000000000000000000000000000000000026
635 4444444444444444444444444444444444444444444444444444444444444444
636 4444444444440000000000000000000000000000000000000000000000000000
637 0000000000000000000000000000000000000000000000000000000000000026
638 6666666666666666666666666666666666666666666666666666666666666666
639 6666666666660000000000000000000000000000000000000000000000000000
640 "
641 )
642 .to_vec();
643 assert_eq!(encoded, expected);
644 }
645
646 #[test]
647 fn encode_static_tuple_of_addresses() {
648 let address1 = Token::Address([0x11u8; 20].into());
649 let address2 = Token::Address([0x22u8; 20].into());
650 let encoded = encode(&vec![Token::Tuple(vec![address1, address2])]);
651
652 let expected = hex!(
653 "
654 0000000000000000000000001111111111111111111111111111111111111111
655 0000000000000000000000002222222222222222222222222222222222222222
656 "
657 )
658 .to_vec();
659 assert_eq!(encoded, expected);
660 }
661
662 #[test]
663 fn encode_dynamic_tuple() {
664 let string1 = Token::String("gavofyork".into());
665 let string2 = Token::String("gavofyork".into());
666 let tuple = Token::Tuple(vec![string1, string2]);
667 let encoded = encode(&vec![tuple]);
668 let expected = hex!(
669 "
670 0000000000000000000000000000000000000000000000000000000000000020
671 0000000000000000000000000000000000000000000000000000000000000040
672 0000000000000000000000000000000000000000000000000000000000000080
673 0000000000000000000000000000000000000000000000000000000000000009
674 6761766f66796f726b0000000000000000000000000000000000000000000000
675 0000000000000000000000000000000000000000000000000000000000000009
676 6761766f66796f726b0000000000000000000000000000000000000000000000
677 "
678 )
679 .to_vec();
680 assert_eq!(encoded, expected);
681 }
682
683 #[test]
684 fn encode_dynamic_tuple_of_bytes2() {
685 let bytes = hex!("4444444444444444444444444444444444444444444444444444444444444444444444444444");
686 let bytes2 = hex!("6666666666666666666666666666666666666666666666666666666666666666666666666666");
687 let encoded = encode(&vec![Token::Tuple(vec![Token::Bytes(bytes.to_vec()), Token::Bytes(bytes2.to_vec())])]);
688
689 let expected = hex!(
690 "
691 0000000000000000000000000000000000000000000000000000000000000020
692 0000000000000000000000000000000000000000000000000000000000000040
693 00000000000000000000000000000000000000000000000000000000000000a0
694 0000000000000000000000000000000000000000000000000000000000000026
695 4444444444444444444444444444444444444444444444444444444444444444
696 4444444444440000000000000000000000000000000000000000000000000000
697 0000000000000000000000000000000000000000000000000000000000000026
698 6666666666666666666666666666666666666666666666666666666666666666
699 6666666666660000000000000000000000000000000000000000000000000000
700 "
701 )
702 .to_vec();
703 assert_eq!(encoded, expected);
704 }
705
706 #[test]
707 fn encode_complex_tuple() {
708 let uint = Token::Uint(U256::from_big_endian(&[0x11u8; 32]));
709 let string = Token::String("gavofyork".into());
710 let address1 = Token::Address([0x11u8; 20].into());
711 let address2 = Token::Address([0x22u8; 20].into());
712 let tuple = Token::Tuple(vec![uint, string, address1, address2]);
713 let encoded = encode(&vec![tuple]);
714 let expected = hex!(
715 "
716 0000000000000000000000000000000000000000000000000000000000000020
717 1111111111111111111111111111111111111111111111111111111111111111
718 0000000000000000000000000000000000000000000000000000000000000080
719 0000000000000000000000001111111111111111111111111111111111111111
720 0000000000000000000000002222222222222222222222222222222222222222
721 0000000000000000000000000000000000000000000000000000000000000009
722 6761766f66796f726b0000000000000000000000000000000000000000000000
723 "
724 )
725 .to_vec();
726 assert_eq!(encoded, expected);
727 }
728
729 #[test]
730 fn encode_nested_tuple() {
731 let string1 = Token::String("test".into());
732 let string2 = Token::String("cyborg".into());
733 let string3 = Token::String("night".into());
734 let string4 = Token::String("day".into());
735 let string5 = Token::String("weee".into());
736 let string6 = Token::String("funtests".into());
737 let bool = Token::Bool(true);
738 let deep_tuple = Token::Tuple(vec![string5, string6]);
739 let inner_tuple = Token::Tuple(vec![string3, string4, deep_tuple]);
740 let outer_tuple = Token::Tuple(vec![string1, bool, string2, inner_tuple]);
741 let encoded = encode(&vec![outer_tuple]);
742 let expected = hex!(
743 "
744 0000000000000000000000000000000000000000000000000000000000000020
745 0000000000000000000000000000000000000000000000000000000000000080
746 0000000000000000000000000000000000000000000000000000000000000001
747 00000000000000000000000000000000000000000000000000000000000000c0
748 0000000000000000000000000000000000000000000000000000000000000100
749 0000000000000000000000000000000000000000000000000000000000000004
750 7465737400000000000000000000000000000000000000000000000000000000
751 0000000000000000000000000000000000000000000000000000000000000006
752 6379626f72670000000000000000000000000000000000000000000000000000
753 0000000000000000000000000000000000000000000000000000000000000060
754 00000000000000000000000000000000000000000000000000000000000000a0
755 00000000000000000000000000000000000000000000000000000000000000e0
756 0000000000000000000000000000000000000000000000000000000000000005
757 6e69676874000000000000000000000000000000000000000000000000000000
758 0000000000000000000000000000000000000000000000000000000000000003
759 6461790000000000000000000000000000000000000000000000000000000000
760 0000000000000000000000000000000000000000000000000000000000000040
761 0000000000000000000000000000000000000000000000000000000000000080
762 0000000000000000000000000000000000000000000000000000000000000004
763 7765656500000000000000000000000000000000000000000000000000000000
764 0000000000000000000000000000000000000000000000000000000000000008
765 66756e7465737473000000000000000000000000000000000000000000000000
766 "
767 )
768 .to_vec();
769 assert_eq!(encoded, expected);
770 }
771
772 #[test]
773 fn encode_params_containing_dynamic_tuple() {
774 let address1 = Token::Address([0x22u8; 20].into());
775 let bool1 = Token::Bool(true);
776 let string1 = Token::String("spaceship".into());
777 let string2 = Token::String("cyborg".into());
778 let tuple = Token::Tuple(vec![bool1, string1, string2]);
779 let address2 = Token::Address([0x33u8; 20].into());
780 let address3 = Token::Address([0x44u8; 20].into());
781 let bool2 = Token::Bool(false);
782 let encoded = encode(&vec![address1, tuple, address2, address3, bool2]);
783 let expected = hex!(
784 "
785 0000000000000000000000002222222222222222222222222222222222222222
786 00000000000000000000000000000000000000000000000000000000000000a0
787 0000000000000000000000003333333333333333333333333333333333333333
788 0000000000000000000000004444444444444444444444444444444444444444
789 0000000000000000000000000000000000000000000000000000000000000000
790 0000000000000000000000000000000000000000000000000000000000000001
791 0000000000000000000000000000000000000000000000000000000000000060
792 00000000000000000000000000000000000000000000000000000000000000a0
793 0000000000000000000000000000000000000000000000000000000000000009
794 7370616365736869700000000000000000000000000000000000000000000000
795 0000000000000000000000000000000000000000000000000000000000000006
796 6379626f72670000000000000000000000000000000000000000000000000000
797 "
798 )
799 .to_vec();
800 assert_eq!(encoded, expected);
801 }
802
803 #[test]
804 fn encode_params_containing_static_tuple() {
805 let address1 = Token::Address([0x11u8; 20].into());
806 let address2 = Token::Address([0x22u8; 20].into());
807 let bool1 = Token::Bool(true);
808 let bool2 = Token::Bool(false);
809 let tuple = Token::Tuple(vec![address2, bool1, bool2]);
810 let address3 = Token::Address([0x33u8; 20].into());
811 let address4 = Token::Address([0x44u8; 20].into());
812 let encoded = encode(&vec![address1, tuple, address3, address4]);
813 let expected = hex!(
814 "
815 0000000000000000000000001111111111111111111111111111111111111111
816 0000000000000000000000002222222222222222222222222222222222222222
817 0000000000000000000000000000000000000000000000000000000000000001
818 0000000000000000000000000000000000000000000000000000000000000000
819 0000000000000000000000003333333333333333333333333333333333333333
820 0000000000000000000000004444444444444444444444444444444444444444
821 "
822 )
823 .to_vec();
824 assert_eq!(encoded, expected);
825 }
826
827 #[test]
828 fn test_function_encode_call() {
829 let signature = "baz(uint32,bool)";
830
831 let mut uint = [0u8; 32];
832 uint[31] = 69;
833
834 let encoded = encode_function(signature, &[Token::Uint(U256::from_big_endian(&uint)), Token::Bool(true)]);
835 let expected = hex!(
836 "
837 cdcd77c000000000000000000000000000000000000000000000000000000000
838 0000004500000000000000000000000000000000000000000000000000000000
839 00000001
840 "
841 )
842 .to_vec();
843 assert_eq!(encoded, expected);
844 }
845}