ethabi/
encoder.rs

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

ethabi/
encoder.rs
