granthe 0.5.0

# Granthe Rust SDK

Official Rust SDK for [Granthe](https://granthe.io) — institutional liquidity rail for crypto settlement.

## Installation

```toml
[dependencies]
granthe = "0.1"
tokio = { version = "1", features = ["full"] }
```

## Quick Start

```rust,no_run
use granthe::Granthe;

#[tokio::main]
async fn main() {
    let client = Granthe::new("vf_live_...");

    let invoice = client.invoices().create(granthe::CreateInvoiceParams {
        amount: 100.0,
        currency: "USDT".into(),
        network: "tron".into(),
        ..Default::default()
    }).await.unwrap();

    println!("Invoice: {} -> {}", invoice.id, invoice.payment_url);
}
```

## Resources

### Invoices

```rust,no_run
# use granthe::*;
# async fn example(client: &Granthe) -> GrantheResult<()> {
// Create
let inv = client.invoices().create(CreateInvoiceParams {
    amount: 100.0,
    currency: "USDT".into(),
    network: "tron".into(),
    description: Some("Order #123".into()),
    ..Default::default()
}).await?;

// Get
let inv = client.invoices().get("inv_123").await?;

// List
let list = client.invoices().list(Some(&ListParams {
    page: Some(1), limit: Some(20), ..Default::default()
})).await?;

// Cancel
let inv = client.invoices().cancel("inv_123").await?;
# Ok(())
# }
```

### Payouts

```rust,no_run
# use granthe::*;
# async fn example(client: &Granthe) -> GrantheResult<()> {
let payout = client.payouts().create(CreatePayoutParams {
    amount: 50.0,
    currency: "USDT".into(),
    network: "tron".into(),
    destination_address: "TXyz...".into(),
    ..Default::default()
}).await?;

// Batch
let payouts = client.payouts().create_batch(&[
    CreatePayoutParams { amount: 50.0, currency: "USDT".into(), network: "tron".into(), destination_address: "TXyz...".into(), ..Default::default() },
]).await?;
# Ok(())
# }
```

### Wallets

```rust,no_run
# use granthe::*;
# async fn example(client: &Granthe) -> GrantheResult<()> {
let wallet = client.wallets().generate(GenerateWalletParams {
    network: "tron".into(),
    currency: "USDT".into(),
    label: Some("deposits".into()),
}).await?;

let balance = client.wallets().balance("w_123").await?;
# Ok(())
# }
```

### Swaps

```rust,no_run
# use granthe::*;
# async fn example(client: &Granthe) -> GrantheResult<()> {
let quote = client.swaps().quote(SwapParams {
    from_currency: "USDT".into(),
    to_currency: "BTC".into(),
    amount: 1000.0,
}).await?;
println!("Rate: {}", quote.rate);
# Ok(())
# }
```

### Webhooks

```rust,no_run
# use granthe::*;
let client = Granthe::builder("vf_live_...")
    .webhook_secret("whsec_...")
    .build();

if let Some(verifier) = client.webhooks() {
    let event = verifier.verify(payload, signature).unwrap();
    match event.event_type.as_str() {
        "invoice.paid" => { /* handle */ }
        "payout.completed" => { /* handle */ }
        _ => {}
    }
}
```

## Error Handling

```rust,no_run
# use granthe::*;
# async fn example(client: &Granthe) {
match client.invoices().get("inv_123").await {
    Ok(inv) => println!("Got invoice: {}", inv.id),
    Err(GrantheError::Authentication { .. }) => eprintln!("Invalid API key"),
    Err(GrantheError::NotFound { .. }) => eprintln!("Not found"),
    Err(GrantheError::Validation { errors, .. }) => eprintln!("Invalid: {:?}", errors),
    Err(GrantheError::RateLimit { retry_after, .. }) => eprintln!("Retry after {}s", retry_after),
    Err(GrantheError::Server { .. }) => eprintln!("Server error"),
    Err(e) => eprintln!("Error: {}", e),
}
# }
```

## Configuration

```rust,no_run
use granthe::Granthe;
use std::time::Duration;

let client = Granthe::builder("vf_live_...")
    .base_url("https://custom-api.example.com")
    .timeout(Duration::from_secs(60))
    .webhook_secret("whsec_...")
    .build();
```

## License

MIT