tycho-execution 0.300.3

Provides tools for encoding and executing swaps against Tycho router and protocol executors.
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

use std::{
    fs,
    io::{self, Read},
};

use clap::{Parser, Subcommand};
use tycho_common::{hex_bytes::Bytes, models::Chain};
use tycho_execution::encoding::{
    errors::EncodingError,
    evm::{
        encoder_builders::{TychoExecutorEncoderBuilder, TychoRouterEncoderBuilder},
        swap_encoder::swap_encoder_registry::SwapEncoderRegistry,
    },
    models::{Solution, UserTransferType},
    tycho_encoder::TychoEncoder,
};

#[derive(Parser)]
/// Encode swap transactions for the Tycho router
///
/// Reads a JSON object from stdin with the following structure:
/// ```json
/// {
///     "sender": "0x...",
///     "receiver": "0x...",
///     "given_token": "0x...",
///     "given_amount": "123...",
///     "checked_token": "0x...",
///     "exact_out": false,
///     "checked_amount": "123...",
///     "swaps": [{
///         "component": {
///             "id": "...",
///             "protocol_system": "...",
///             "protocol_type_name": "...",
///             "chain": "ethereum",
///             "tokens": ["0x..."],
///             "contract_ids": ["0x..."],
///             "static_attributes": {"key": "0x..."}
///         },
///         "token_in": "0x...",
///         "token_out": "0x...",
///         "split": 0.0
///     }],
/// }
/// ```
#[command(author, version, about, long_about = None)]
pub struct Cli {
    #[command(subcommand)]
    pub command: Commands,
    #[arg(short, long)]
    chain: Chain,
    #[arg(short, long)]
    executors_file_path: Option<String>,
    #[arg(short, long)]
    router_address: Option<Bytes>,
    #[arg(short, long)]
    user_transfer_type: Option<UserTransferType>,
}

#[derive(Subcommand)]
pub enum Commands {
    /// Use Tycho router encoding
    TychoRouter,
    /// Use direct execution encoding
    TychoExecutor,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let cli = Cli::parse();
    // Read from stdin until EOF
    let mut buffer = String::new();
    io::stdin()
        .read_to_string(&mut buffer)
        .map_err(|e| format!("Failed to read from stdin: {e}"))?;

    if buffer.trim().is_empty() {
        return Err("No input provided. Expected JSON input on stdin.".into());
    }
    let solution: Solution = serde_json::from_str(&buffer)?;

    let chain = cli.chain;
    let encoder: Box<dyn TychoEncoder> = match cli.command {
        Commands::TychoRouter => {
            let executors_addresses = if let Some(config_path) = cli.executors_file_path {
                Some(fs::read_to_string(&config_path).map_err(|e| {
                    EncodingError::FatalError(format!(
                        "Error reading executors file from {config_path:?}: {e}",
                    ))
                })?)
            } else {
                None
            };
            let swap_encoder_registry =
                SwapEncoderRegistry::new(chain).add_default_encoders(executors_addresses)?;
            let mut builder = TychoRouterEncoderBuilder::new()
                .chain(chain)
                .swap_encoder_registry(swap_encoder_registry);
            if let Some(router_address) = cli.router_address {
                builder = builder.router_address(router_address);
            }
            builder.build()?
        }
        Commands::TychoExecutor => {
            let swap_encoder_registry =
                SwapEncoderRegistry::new(chain).add_default_encoders(None)?;
            TychoExecutorEncoderBuilder::new()
                .swap_encoder_registry(swap_encoder_registry)
                .build()?
        }
    };

    let encoded_solutions = encoder.encode_solutions(vec![solution])?;
    let encoded = serde_json::json!({
        "swaps": format!("0x{}", hex::encode(encoded_solutions[0].swaps())),
        "interacting_with": format!("0x{}", hex::encode(encoded_solutions[0].interacting_with())),
        "function_signature": encoded_solutions[0].function_signature(),
        "n_tokens": encoded_solutions[0].n_tokens().to_string(),
    });
    // Output the encoded result as JSON to stdout
    println!(
        "{}",
        serde_json::to_string(&encoded).map_err(|e| format!("Failed to serialize output: {e}"))?
    );

    Ok(())
}