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