Go SDK

go get github.com/fyatu/fyatu-go

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/fyatu/fyatu-go"
)

func main() {
    client := fyatu.NewClient(
        fyatu.WithCredentials("your_app_id", "your_secret_key"),
    )

    // Create a collection
    collection, err := client.Collections.Create(context.Background(), &fyatu.CreateCollectionParams{
        Amount:      10.00,
        Currency:    "USD",
        Reference:   "order_123",
        Description: "Payment for Order #123",
        Customer: &fyatu.Customer{
            Email: "customer@example.com",
            Name:  "Alice Example",
        },
        RedirectURL: "https://yoursite.com/payment/success",
        WebhookURL:  "https://yoursite.com/webhooks/fyatu",
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(collection.CheckoutURL)
}

client := fyatu.NewClient(
    fyatu.WithCredentials("your_app_id", "your_secret_key"),

    // Optional configuration
    fyatu.WithBaseURL("https://api.fyatu.com/api/v3"),
    fyatu.WithTimeout(30 * time.Second),
    fyatu.WithRetries(3),
    fyatu.WithHTTPClient(customHTTPClient),
)

import (
    "errors"
    "github.com/fyatu/fyatu-go"
)

payout, err := client.Payouts.Create(ctx, &fyatu.CreatePayoutParams{
    Amount:      100,
    Currency:    "USD",
    RecipientID: "invalid_id",
})
if err != nil {
    var apiErr *fyatu.Error
    if errors.As(err, &apiErr) {
        switch apiErr.Code {
        case fyatu.ErrValidation:
            fmt.Printf("Validation failed: %v\n", apiErr.Details)
        case fyatu.ErrAuthentication:
            fmt.Printf("Authentication failed: %s\n", apiErr.Message)
        case fyatu.ErrInsufficientBalance:
            fmt.Printf("Insufficient balance: %s\n", apiErr.Message)
        default:
            fmt.Printf("API error [%s]: %s\n", apiErr.Code, apiErr.Message)
        }
    } else {
        fmt.Printf("Unexpected error: %v\n", err)
    }
    return
}

import (
    "net/http"
    "github.com/fyatu/fyatu-go/webhook"
)

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    signature := r.Header.Get("X-Fyatu-Signature")

    payload, err := io.ReadAll(r.Body)
    if err != nil {
        http.Error(w, "Failed to read body", http.StatusBadRequest)
        return
    }

    valid, err := webhook.VerifySignature(payload, signature, "your_webhook_secret")
    if err != nil || !valid {
        http.Error(w, "Invalid signature", http.StatusUnauthorized)
        return
    }

    var event webhook.Event
    if err := json.Unmarshal(payload, &event); err != nil {
        http.Error(w, "Invalid payload", http.StatusBadRequest)
        return
    }

    fmt.Printf("Received event: %s\n", event.Type)
    w.WriteHeader(http.StatusOK)
}

// List all collections with pagination
iter := client.Collections.List(ctx, &fyatu.ListCollectionsParams{
    Limit: 10,
})

for iter.Next() {
    collection := iter.Current()
    fmt.Printf("Collection: %s - %s\n", collection.ID, collection.Status)
}

if err := iter.Err(); err != nil {
    log.Fatal(err)
}