weiroll 0.1.1

Weiroll planner for EVM using ethers-rs
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

use crate::calls::FunctionCall;
use crate::Planner;
use bitflags::bitflags;
use ethers::abi::{AbiEncode, Tokenizable};
use ethers::prelude::*;
use slotmap::DefaultKey;
use std::fmt::Debug;
use std::hash::Hash;

bitflags! {
    #[derive(Debug, PartialEq, Clone, Copy)]
    #[repr(transparent)]
    pub struct CommandFlags: u8 {
        // Specifies that a call should be made using the DELEGATECALL opcode
        const DELEGATECALL = 0x00;
        // Specifies that a call should be made using the CALL opcode
        const CALL = 0x01;
        // Specifies that a call should be made using the STATICCALL opcode
        const STATICCALL = 0x02;
        // Specifies that a call should be made using the CALL opcode, and that the first argument will be the value to send
        const CALL_WITH_VALUE = 0x03;
        // A bitmask that selects calltype flags
        const CALLTYPE_MASK = 0x03;
        // Specifies that this is an extended command, with an additional command word for indices. Internal use only.
        const EXTENDED_COMMAND = 0x40;
        // Specifies that the return value of this call should be wrapped in a `bytes`. Internal use only.
        const TUPLE_RETURN = 0x80;
    }
}

#[derive(Debug, PartialEq)]
pub enum CommandType {
    Call,
    RawCall,
    SubPlan,
}

#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
pub struct Literal {
    dynamic: bool,
    bytes: Vec<u8>,
}

impl<T: Tokenizable + AbiEncode + Clone> From<T> for Literal {
    fn from(token: T) -> Self {
        Literal {
            dynamic: token.clone().into_token().is_dynamic(),
            bytes: token.encode(),
        }
    }
}

impl<T: Tokenizable + AbiEncode + Clone> From<T> for Value<'_> {
    fn from(token: T) -> Self {
        Value::Literal(token.into())
    }
}

impl Literal {
    pub fn bytes(&self) -> Bytes {
        self.bytes.clone().into()
    }
}

#[derive(Debug)]
pub enum Value<'a> {
    Literal(Literal),
    Return(ReturnValue),
    State(Vec<Bytes>),
    Subplan(&'a Planner<'a>),
}

impl From<ReturnValue> for Value<'_> {
    fn from(value: ReturnValue) -> Self {
        Self::Return(value)
    }
}

impl Value<'_> {
    pub fn is_dynamic_type(&self) -> bool {
        match self {
            Value::Literal(l) => l.dynamic,
            Value::Return(r) => r.dynamic,
            Value::State(_) => true,
            Value::Subplan(_) => true,
        }
    }
}

#[derive(Debug)]
pub struct Command<'a> {
    pub(crate) call: FunctionCall<'a>,
    pub(crate) kind: CommandType,
}

#[derive(Clone, Debug, PartialEq)]
pub struct ReturnValue {
    pub(crate) dynamic: bool,
    pub(crate) command: DefaultKey,
}