Struct PathData 

pub struct PathData {
    pub flow_vertices: Vec<Address>,
    pub flow_edges: Vec<FlowEdge>,
    pub streams: Vec<Stream>,
    pub packed_coordinates: Vec<u8>,
    pub source_coordinate: U256,
}

Simplified pathfinding result data structure

This struct contains the raw pathfinding results in a format that can be easily converted to contract-compatible types. It eliminates the need for manual field-by-field conversion between different type layers.

Fields

flow_vertices: Vec<Address>

Sorted list of all addresses involved in the flow

flow_edges: Vec<FlowEdge>

Flow edges as (stream_sink_id, amount) tuples

streams: Vec<Stream>

Streams as (source_coordinate, flow_edge_ids, data) tuples

packed_coordinates: Vec<u8>

Packed coordinates as raw bytes

source_coordinate: U256

Source coordinate index

Implementations

impl PathData

pub fn from_transfers( transfers: &[TransferStep], from: Address, to: Address, target_flow: U192, ) -> Result<Self, PathfinderError>

Create PathData from transfer steps

This is the main constructor that takes the output from pathfinding and creates a PathData structure ready for contract conversion.

Arguments

• transfers - Vector of transfer steps from pathfinding
• from - Source address
• to - Destination address
• target_flow - Target flow amount

Returns

A PathData structure ready for contract conversion

Errors

Returns PathfinderError if flow matrix creation fails

pub fn to_flow_edges(&self) -> Vec<FlowEdge>

Convert to standard Circles Hub FlowEdge types

Returns a vector of FlowEdge structs with the exact field names and types expected by the Circles Hub smart contract.

Example

let edges = path_data.to_flow_edges();
assert_eq!(edges[0].streamSinkId, 1);
assert_eq!(edges[0].amount, U192::from(1000u64));

pub fn to_streams(&self) -> Vec<Stream>

Convert to standard Circles Hub Stream types

Returns a vector of Stream structs with the exact field names and types expected by the Circles Hub smart contract.

Example

let streams = path_data.to_streams();
assert_eq!(streams[0].sourceCoordinate, 0);
assert_eq!(streams[0].flowEdgeIds, vec![1, 2]);

pub fn to_contract_params( &self, ) -> (Vec<Address>, Vec<FlowEdge>, Vec<Stream>, Bytes)

Get all contract call parameters in one tuple

This convenience method returns all the parameters needed for most Circles Hub contract calls in the correct order and format.

Returns

A tuple of (flow_vertices, flow_edges, streams, packed_coordinates) ready to use in contract function calls.

Example

let (vertices, edges, streams, coords) = path_data.to_contract_params();

// Ready for contract calls:
// contract.transferFlow(vertices, edges, streams, coords).send().await?;

Examples found in repository

examples/contract_integration.rs (line 94)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Example addresses (replace with real addresses)
    let sender = Address::from_str("0x52e14be00d5acff4424ad625662c6262b4fd1a58")?;
    let receiver = Address::from_str("0xcf6dc192dc292d5f2789da2db02d6dd4f41f4214")?;
    let amount = U192::from_str("1000000000000000000")?; // 1 CRC in wei
    let rpc_url = "https://rpc.aboutcircles.com/";

    println!("Finding path and preparing contract data...");
    println!("From: {sender}");
    println!("To: {receiver}");
    println!("Amount: {amount} wei");

    let params = FindPathParams {
        from: sender,
        to: receiver,
        target_flow: U256::from(amount),
        use_wrapped_balances: Some(true),
        from_tokens: None,
        to_tokens: None,
        exclude_from_tokens: None,
        exclude_to_tokens: None,
        simulated_balances: None,
        max_transfers: None,
    };

    // NEW API: One function call does everything
    let path_data: PathData = prepare_flow_for_contract(rpc_url, params).await?;

    println!("\nFlow matrix prepared for contract calls:");
    println!("Flow vertices: {} addresses", path_data.flow_vertices.len());
    println!("Flow edges: {} transfers", path_data.flow_edges.len());
    println!("Streams: {} streams", path_data.streams.len());
    println!(
        "Packed coordinates: {} bytes",
        path_data.packed_coordinates.len()
    );
    println!("Source coordinate: {}", path_data.source_coordinate);

    // Demonstrate contract-ready data
    println!("\nContract-ready data:");

    // Flow vertices (already Address types)
    println!(
        "Vertices (first 3): {:?}",
        &path_data.flow_vertices[..3.min(path_data.flow_vertices.len())]
    );

    // Flow edges (raw tuples - convert to contract types)
    for (i, flow_edge) in path_data.flow_edges.iter().take(3).enumerate() {
        println!(
            "Edge {i}: stream_sink_id={}, amount={amount}",
            flow_edge.streamSinkId
        );
    }

    // Streams (raw tuples - convert to contract types)
    for (i, stream) in path_data.streams.iter().enumerate() {
        println!(
            "Stream {i}: source_coordinate={}, flow_edge_ids={:?}",
            stream.sourceCoordinate, stream.flowEdgeIds
        );
    }

    // Packed coordinates (raw bytes - convert to Bytes for contracts)
    println!(
        "Packed coordinates length: {} bytes",
        path_data.packed_coordinates.len()
    );

    // Example: How you would use this in a smart contract call
    println!("\nExample smart contract usage:");
    println!("```rust");
    println!("let contract = MyContract::new(contract_address, provider);");
    println!("let tx = contract");
    println!("    .redeemPayment(");
    println!("        module_address,");
    println!("        subscription_id,");
    println!("        path_data.flow_vertices,           // Vec<Address>");
    println!("        path_data.to_flow_edges(),         // Vec<FlowEdge>");
    println!("        path_data.to_streams(),            // Vec<Stream>");
    println!("        path_data.to_packed_coordinates()  // Bytes");
    println!("    )");
    println!("    .send()");
    println!("    .await?;");
    println!("```");

    // Demonstrate decomposition for tuple-based contract calls
    let (vertices, edges, streams, packed_coords) = path_data.to_contract_params();
    println!("\nFor tuple-based contract calls:");
    println!("Decomposed into {} components ready for contract", 4);
    println!("- {} vertices", vertices.len());
    println!("- {} edges", edges.len());
    println!("- {} streams", streams.len());
    println!("- {} bytes of coordinates", packed_coords.len());

    Ok(())
}

pub fn to_packed_coordinates(&self) -> Bytes

Get packed coordinates as Bytes

Convenience method to get the packed coordinates in the Bytes format expected by contract calls.

Trait Implementations

impl Clone for PathData

fn clone(&self) -> PathData

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PathData

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.