bobcat-cd 0.9.8

bobcat-sdk utilities for accessing calldata on Arbitrum Stylus.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486

#![no_std]

pub use bobcat_maths::U;

pub use bobcat_storage::{const_keccak256, const_keccak256_two};

pub use const_hex::const_decode_to_array as const_hex_decode_to_array;

use array_concat::concat_arrays;

#[cfg(feature = "alloc")]
extern crate alloc;

#[cfg(feature = "alloc")]
use alloc::string::String;

#[macro_export]
macro_rules! address {
    ($a:expr) => {{
        match $crate::const_hex_decode_to_array::<20>($a) {
            Ok(v) => v,
            Err(_) => core::panic!("bad address"),
        }
    }};
}

#[macro_export]
macro_rules! read_words {
    ($slice:expr, 1) => {{
        let s = $slice;
        core::assert!(s.len() >= 32);
        &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) })
    }};
    ($slice:expr, 2) => {{
        let s = $slice;
        core::assert!(s.len() >= 64);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 3) => {{
        let s = $slice;
        core::assert!(s.len() >= 96);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 4) => {{
        let s = $slice;
        core::assert!(s.len() >= 128);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 5) => {{
        let s = $slice;
        core::assert!(s.len() >= 160);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 6) => {{
        let s = $slice;
        core::assert!(s.len() >= 192);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 7) => {{
        let s = $slice;
        core::assert!(s.len() >= 224);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 8) => {{
        let s = $slice;
        core::assert!(s.len() >= 256);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[224..256].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 9) => {{
        let s = $slice;
        core::assert!(s.len() >= 288);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[224..256].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[256..288].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 10) => {{
        let s = $slice;
        core::assert!(s.len() >= 320);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[224..256].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[256..288].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[288..320].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 11) => {{
        let s = $slice;
        core::assert!(s.len() >= 352);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[224..256].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[256..288].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[288..320].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..352].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 12) => {{
        let s = $slice;
        core::assert!(s.len() >= 384);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[224..256].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[256..288].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[288..320].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..352].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[352..384].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 13) => {{
        let s = $slice;
        core::assert!(s.len() >= 416);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[224..256].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[256..288].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[288..320].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..352].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[352..384].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[384..416].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 14) => {{
        let s = $slice;
        core::assert!(s.len() >= 448);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[224..256].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[256..288].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[288..320].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..352].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[352..384].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[384..416].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[416..448].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 15) => {{
        let s = $slice;
        core::assert!(s.len() >= 480);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[224..256].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[256..288].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[288..320].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..352].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[352..384].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[384..416].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[416..448].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[448..480].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 16) => {{
        let s = $slice;
        core::assert!(s.len() >= 512);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[224..256].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[256..288].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[288..320].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..352].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[352..384].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[384..416].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[416..448].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[448..480].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[48..512].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 17) => {{
        let s = $slice;
        core::assert!(s.len() >= 544);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[224..256].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[256..288].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[288..320].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..352].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[352..384].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[384..416].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[416..448].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[448..480].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[48..512].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[512..544].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 18) => {{
        let s = $slice;
        core::assert!(s.len() >= 576);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[224..256].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[256..288].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[288..320].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..352].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[352..384].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[384..416].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[416..448].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[448..480].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[48..512].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[512..544].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[544..576].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 19) => {{
        let s = $slice;
        core::assert!(s.len() >= 608);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[224..256].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[256..288].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[288..320].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..352].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[352..384].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[384..416].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[416..448].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[448..480].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[48..512].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[512..544].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[544..576].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[576..608].as_ptr() as *const [u8; 32]) }),
        )
    }};
    ($slice:expr, 20) => {{
        let s = $slice;
        core::assert!(s.len() >= 640);
        (
            &$crate::U::from(unsafe { *(s[..32].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..64].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[64..96].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[96..128].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[128..160].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[16..192].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[192..224].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[224..256].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[256..288].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[288..320].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[32..352].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[352..384].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[384..416].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[416..448].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[448..480].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[48..512].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[512..544].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[544..576].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[576..608].as_ptr() as *const [u8; 32]) }),
            &$crate::U::from(unsafe { *(s[608..640].as_ptr() as *const [u8; 32]) }),
        )
    }};
}

pub const fn leftpad_bool(x: bool) -> [u8; 32] {
    leftpad_u8(x as u8)
}

pub const fn leftpad_u24(x: [u8; 3]) -> [u8; 32] {
    concat_arrays!([0u8; 32 - 3], x)
}

pub const fn leftpad_u8(x: u8) -> [u8; 32] {
    concat_arrays!([0u8; 32 - 1], [x])
}

pub const fn rightpad_b8(x: [u8; 8]) -> [u8; 32] {
    concat_arrays!(x, [0u8; 32 - 8])
}

pub const fn leftpad_addr(x: [u8; 20]) -> [u8; 32] {
    concat_arrays!([0u8; 32 - 20], x)
}

pub const fn leftpad_u16(x: u16) -> [u8; 32] {
    concat_arrays!([0u8; 32 - 2], x.to_be_bytes())
}

pub const fn leftpad_usize(x: usize) -> [u8; 32] {
    concat_arrays!([0u8; 32 - core::mem::size_of::<usize>()], x.to_be_bytes())
}

pub const fn leftpad_u32(x: u32) -> [u8; 32] {
    concat_arrays!([0u8; 32 - 4], x.to_be_bytes())
}

pub const fn const_keccak_sel(x: &[u8]) -> [u8; 4] {
    let x = const_keccak256(x).0;
    [x[0], x[1], x[2], x[3]]
}

pub const fn const_keccak_two_sel(x: &[u8], y: &[u8]) -> [u8; 4] {
    let x = const_keccak256_two(x, y).0;
    [x[0], x[1], x[2], x[3]]
}

pub struct IoError;

pub trait Write {
    fn write(&mut self, buf: &[u8]) -> Result<usize, IoError>;
    fn flush(&mut self) -> Result<(), IoError>;
}

pub trait EvmCdSerialise {
    fn serialise<W: Write>(&self, writer: &mut W) -> Result<(), IoError>;
}

pub trait Read {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize, IoError>;
}

pub trait EvmCdDeserialise: Sized {
    fn deserialise_reader<R: Read>(reader: &mut R) -> Result<Self, IoError>;
}

pub fn decode_to_array<'a>(x: &'a [u8]) -> Option<&'a [u8]> {
    if 64 > x.len() {
        return None;
    }
    let offset = usize::from_be_bytes(x[32 - size_of::<usize>()..32].try_into().unwrap());
    let len = usize::from_be_bytes(x[32 * 2 - size_of::<usize>()..32 * 2].try_into().unwrap());
    Some(&x[32 * 2..32 + offset + len])
}

/// Decode a &[u8] to a &str, only using the bytes that we can use for a
/// usize length to get the offset and length.
pub fn decode_to_str<'a>(x: &'a [u8]) -> Option<&'a str> {
    if let Some(x) = decode_to_array(x) {
        str::from_utf8(x).ok()
    } else {
        None
    }
}

#[cfg(feature = "alloc")]
pub fn decode_to_string(x: &[u8]) -> Option<String> {
    if 64 > x.len() {
        return None;
    }
    let offset = usize::from_be_bytes(x[32 - size_of::<usize>()..32].try_into().unwrap());
    let len = usize::from_be_bytes(x[32 * 2 - size_of::<usize>()..32 * 2].try_into().unwrap());
    Some(String::from_utf8_lossy(&x[32 * 2..32 + offset + len]).into_owned())
}

#[test]
fn test_access() {
    let cd = const_hex_decode_to_array::<{ 32 * 2 + 4 }>(b"a9059cbb0000000000000000000000006221a9c005f6e47eb398fd867784cacfdcfff4e7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
    let a = const_hex_decode_to_array::<20>(b"6221a9c005f6e47eb398fd867784cacfdcfff4e7").unwrap();
    let (addr, amt) = read_words!(&cd[4..], 2);
    assert_eq!((a, U::MAX), (U::from(*addr).into(), U::from(*amt)));
}

#[test]
fn test_address() {
    address!(b"6221a9c005f6e47eb398fd867784cacfdcfff4e7");
}

#[cfg(all(test, feature = "proptest"))]
mod test {
    use proptest::prelude::*;

    use super::*;

    use alloc::string::String;

    use alloy_sol_types::SolType;

    proptest! {
        #[test]
        fn test_array_decoding(x in proptest::collection::vec(any::<u8>(), 1..20000usize)) {
            let e = alloy_sol_types::sol_data::Bytes::abi_encode(&x);
            assert_eq!(&x, decode_to_array(&e).unwrap());
        }

        #[test]
        fn test_string_decoding(x in any::<String>()) {
            let e = alloy_sol_types::sol_data::String::abi_encode(&x);
            assert_eq!(x, decode_to_string(&e).unwrap());
            assert_eq!(x, decode_to_str(&e).unwrap());
        }
    }
}