contract_integration/
contract_integration.rs

1use alloy_primitives::Address;
2use alloy_primitives::{U256, aliases::U192};
3use circles_pathfinder::{FindPathParams, PathData, prepare_flow_for_contract};
4use std::str::FromStr;
5
6#[tokio::main]
7async fn main() -> Result<(), Box<dyn std::error::Error>> {
8    // Example addresses (replace with real addresses)
9    let sender = Address::from_str("0x52e14be00d5acff4424ad625662c6262b4fd1a58")?;
10    let receiver = Address::from_str("0xcf6dc192dc292d5f2789da2db02d6dd4f41f4214")?;
11    let amount = U192::from_str("1000000000000000000")?; // 1 CRC in wei
12    let rpc_url = "https://rpc.aboutcircles.com/";
13
14    println!("Finding path and preparing contract data...");
15    println!("From: {sender}");
16    println!("To: {receiver}");
17    println!("Amount: {amount} wei");
18
19    let params = FindPathParams {
20        from: sender,
21        to: receiver,
22        target_flow: U256::from(amount),
23        use_wrapped_balances: Some(true),
24        from_tokens: None,
25        to_tokens: None,
26        exclude_from_tokens: None,
27        exclude_to_tokens: None,
28        simulated_balances: None,
29        max_transfers: None,
30    };
31
32    // NEW API: One function call does everything
33    let path_data: PathData = prepare_flow_for_contract(rpc_url, params).await?;
34
35    println!("\nFlow matrix prepared for contract calls:");
36    println!("Flow vertices: {} addresses", path_data.flow_vertices.len());
37    println!("Flow edges: {} transfers", path_data.flow_edges.len());
38    println!("Streams: {} streams", path_data.streams.len());
39    println!(
40        "Packed coordinates: {} bytes",
41        path_data.packed_coordinates.len()
42    );
43    println!("Source coordinate: {}", path_data.source_coordinate);
44
45    // Demonstrate contract-ready data
46    println!("\nContract-ready data:");
47
48    // Flow vertices (already Address types)
49    println!(
50        "Vertices (first 3): {:?}",
51        &path_data.flow_vertices[..3.min(path_data.flow_vertices.len())]
52    );
53
54    // Flow edges (raw tuples - convert to contract types)
55    for (i, flow_edge) in path_data.flow_edges.iter().take(3).enumerate() {
56        println!(
57            "Edge {i}: stream_sink_id={}, amount={amount}",
58            flow_edge.streamSinkId
59        );
60    }
61
62    // Streams (raw tuples - convert to contract types)
63    for (i, stream) in path_data.streams.iter().enumerate() {
64        println!(
65            "Stream {i}: source_coordinate={}, flow_edge_ids={:?}",
66            stream.sourceCoordinate, stream.flowEdgeIds
67        );
68    }
69
70    // Packed coordinates (raw bytes - convert to Bytes for contracts)
71    println!(
72        "Packed coordinates length: {} bytes",
73        path_data.packed_coordinates.len()
74    );
75
76    // Example: How you would use this in a smart contract call
77    println!("\nExample smart contract usage:");
78    println!("```rust");
79    println!("let contract = MyContract::new(contract_address, provider);");
80    println!("let tx = contract");
81    println!("    .redeemPayment(");
82    println!("        module_address,");
83    println!("        subscription_id,");
84    println!("        path_data.flow_vertices,           // Vec<Address>");
85    println!("        path_data.to_flow_edges(),         // Vec<FlowEdge>");
86    println!("        path_data.to_streams(),            // Vec<Stream>");
87    println!("        path_data.to_packed_coordinates()  // Bytes");
88    println!("    )");
89    println!("    .send()");
90    println!("    .await?;");
91    println!("```");
92
93    // Demonstrate decomposition for tuple-based contract calls
94    let (vertices, edges, streams, packed_coords) = path_data.to_contract_params();
95    println!("\nFor tuple-based contract calls:");
96    println!("Decomposed into {} components ready for contract", 4);
97    println!("- {} vertices", vertices.len());
98    println!("- {} edges", edges.len());
99    println!("- {} streams", streams.len());
100    println!("- {} bytes of coordinates", packed_coords.len());
101
102    Ok(())
103}