cow-rs 0.1.1

Rust SDK for the CoW Protocol: quoting, signing, posting and tracking orders, plus composable orders, on-chain reads and subgraph queries.
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

//! [`WeirollPlanner`] — builder for Weiroll scripts.
//!
//! Accumulates [`WeirollCommand`]s and state slots, then finalises them
//! into an executable [`WeirollScript`] via [`WeirollPlanner::plan`].

use super::types::{WeirollCommand, WeirollScript};

/// Builder that accumulates commands and state slots into a Weiroll script.
///
/// # Example
///
/// ```
/// use alloy_primitives::Address;
/// use cow_rs::weiroll::{WeirollCommand, WeirollPlanner};
///
/// let mut planner = WeirollPlanner::new();
/// planner.add_command(WeirollCommand {
///     flags: 0,
///     value: 0,
///     gas: 0,
///     target: Address::ZERO,
///     selector: [0; 4],
///     in_out: [0; 4],
/// });
/// let script = planner.plan();
/// assert_eq!(script.command_count(), 1);
/// ```
#[derive(Debug, Default)]
pub struct WeirollPlanner {
    commands: Vec<WeirollCommand>,
    state: Vec<Vec<u8>>,
}

impl WeirollPlanner {
    /// Create an empty [`WeirollPlanner`] with no commands or state slots.
    ///
    /// # Returns
    ///
    /// A new planner ready to receive commands via [`add_command`](Self::add_command).
    #[must_use]
    pub const fn new() -> Self {
        Self { commands: vec![], state: vec![] }
    }

    /// Append a raw [`WeirollCommand`] to the script.
    ///
    /// Commands are executed in the order they are added.
    ///
    /// # Parameters
    ///
    /// * `cmd` — the command to append.
    ///
    /// # Returns
    ///
    /// `&mut Self` for method chaining.
    pub fn add_command(&mut self, cmd: WeirollCommand) -> &mut Self {
        self.commands.push(cmd);
        self
    }

    /// Append a state slot (ABI-encoded value) and return its zero-based
    /// index.
    ///
    /// State slots hold the arguments and return values that flow between
    /// commands during Weiroll execution.
    ///
    /// # Parameters
    ///
    /// * `data` — the ABI-encoded bytes for this slot.
    ///
    /// # Returns
    ///
    /// The zero-based index of the newly added slot (use this index in
    /// [`WeirollCommand::in_out`] to wire commands together).
    pub fn add_state_slot(&mut self, data: Vec<u8>) -> usize {
        let idx = self.state.len();
        self.state.push(data);
        idx
    }

    /// Number of commands added so far.
    ///
    /// # Returns
    ///
    /// The count of commands in this planner.
    #[must_use]
    pub const fn command_count(&self) -> usize {
        self.commands.len()
    }

    /// Number of state slots added so far.
    ///
    /// # Returns
    ///
    /// The count of state slots in this planner.
    #[must_use]
    pub const fn state_slot_count(&self) -> usize {
        self.state.len()
    }

    /// Finalise the planner and produce an executable [`WeirollScript`].
    ///
    /// Each command is packed into a 32-byte word via
    /// [`WeirollCommand::pack`]. The planner is consumed.
    ///
    /// # Returns
    ///
    /// A [`WeirollScript`] containing the packed commands and state slots.
    #[must_use]
    pub fn plan(self) -> WeirollScript {
        WeirollScript {
            commands: self.commands.iter().map(WeirollCommand::pack).collect(),
            state: self.state,
        }
    }
}