sw4p-bridge

Official Rust SDK for sw4p - gasless cross-chain transfers for stablecoins and native tokens across any blockchain.

Installation

[dependencies]
sw4p-bridge = "0.1"
tokio = { version = "1", features = ["rt-multi-thread", "macros"] }

Quick Start

use sw4p_bridge::{Sw4pBridge, Chain, TransferParams};

#[tokio::main]
async fn main() -> Result<(), sw4p_bridge::Error> {
    let bridge = Sw4pBridge::new("sk_your_api_key");
    
    // Check supported routes
    let supported = bridge.supports_route(Chain::Base, Chain::Solana).await?;
    println!("BASE → SOLANA: {}", if supported { "✓" } else { "✗" });
    
    // Get transfer limits
    let limits = bridge.get_limits().await?;
    println!("Min: ${}, Max: ${}", limits.min_amount, limits.max_amount);
    
    // Estimate fees
    let estimate = bridge.estimate_fee(Chain::Base, Chain::Solana, "100.00").await?;
    println!("Fee: ${}, You receive: ${}", estimate.fee.total, estimate.net_receive);
    
    Ok(())
}

EVM → Any Transfer

use sw4p_bridge::{Sw4pBridge, Chain, TransferParams, Permit};

let bridge = Sw4pBridge::new("sk_...");

// Execute transfer with ERC-2612 permit
let result = bridge.transfer(TransferParams {
    from: Chain::Base,
    to: Chain::Solana,
    amount: "100.00".into(),
    recipient: "5abc123...".into(),
    permit: Some(Permit {
        owner: "0x...".into(),
        spender: "0x...".into(),
        value: "100000000".into(),
        deadline: "1735689600".into(),
        v: 27,
        r: "0x...".into(),
        s: "0x...".into(),
    }),
    speed: None,
    idempotency_key: None,
    webhook_url: None,
}).await?;

println!("Intent ID: {}", result.intent_id);

Solana → EVM Transfer

use sw4p_bridge::{Sw4pBridge, Chain, SolanaBuildParams};

let bridge = Sw4pBridge::new("sk_...");

// Step 1: Build transaction
let tx_data = bridge.build_solana_transfer(SolanaBuildParams {
    to: Chain::Base,
    amount: "100.00".into(),
    from_wallet: "5abc123...".into(),
    recipient: "0x...".into(),
    ..Default::default()
}).await?;

// Step 2: Sign with wallet (your signing logic)
let signed_tx = sign_with_wallet(&tx_data.transaction)?;

// Step 3: Submit
let result = bridge.submit_solana_transfer(SolanaSubmitParams {
    intent_id: tx_data.intent_id,
    signed_transaction: signed_tx,
}).await?;

Check Status

let status = bridge.get_status("intent_abc123").await?;

match status.status {
    TransferStatus::Pending => println!("Waiting..."),
    TransferStatus::Processing => println!("In progress..."),
    TransferStatus::Complete => println!("Done! TX: {:?}", status.destination_tx),
    TransferStatus::Failed => println!("Failed"),
}

Error Handling

use sw4p_bridge::Error;

match bridge.transfer(params).await {
    Ok(result) => println!("Success: {}", result.intent_id),
    Err(Error::Auth(msg)) => eprintln!("Auth failed: {}", msg),
    Err(Error::RateLimit { retry_after_ms }) => {
        println!("Rate limited, retry in {}ms", retry_after_ms);
    }
    Err(Error::Api { status, message }) => {
        eprintln!("API error {}: {}", status, message);
    }
    Err(e) => eprintln!("Error: {}", e),
}

Supported Chains (MVP)

sw4p is designed to support every blockchain. Current MVP:

Tokens: USDC (more tokens coming soon)

License

MIT