Go SDK

go get github.com/solvela-ai/solvela/sdks/go

package main

import (
	"context"
	"fmt"
	"log"

	solvela "github.com/solvela-ai/solvela/sdks/go"
)

func main() {
	wallet, _, err := solvela.CreateWallet()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Wallet:", wallet.Address())

	client, err := solvela.NewClient(wallet, nil,
		solvela.WithGatewayURL("https://api.solvela.ai"),
	)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	models, err := client.Models(context.Background())
	if err != nil {
		log.Fatal(err)
	}
	for _, m := range models[:3] {
		fmt.Printf("%s — %s ($%.2f/M in)\n", m.ID, m.DisplayName, m.InputUsdcPerMillion)
	}
}

import (
	"time"

	solvela "github.com/solvela-ai/solvela/sdks/go"
)

client, err := solvela.NewClient(wallet, signer,
	solvela.WithGatewayURL("https://api.solvela.ai"),     // default: https://api.solvela.ai
	solvela.WithRPCURL("https://api.mainnet-beta.solana.com"),
	solvela.WithTimeout(60*time.Second),                  // default: 180s
	solvela.WithMaxPaymentAmount(10_000_000),             // per-call cap: 10 USDC atomic
	solvela.WithExpectedRecipient("recipient-wallet-pub"),// if set, gateway must pay-to this
	solvela.WithExpectedEscrowProgram(solvela.MainnetEscrowProgramID), // escrow program pin (this is the default)
	solvela.WithCache(true),                              // opt-in response caching
	solvela.WithSessions(true),                           // opt-in three-strike escalation
	solvela.WithSessionTTL(30*time.Minute),
	solvela.WithQualityCheck(true),                       // opt-in degraded-response retry
	solvela.WithMaxQualityRetries(2),
	solvela.WithFreeFallbackModel("openai/gpt-4o-mini"),  // swap on zero balance
)

ch, err := client.ChatStream(ctx, req)
if err != nil {
	log.Fatal(err)
}
for chunk := range ch {
	if chunk.Err != nil {
		log.Fatal(chunk.Err)
	}
	if len(chunk.Chunk.Choices) > 0 && chunk.Chunk.Choices[0].Delta.Content != nil {
		fmt.Print(*chunk.Chunk.Choices[0].Delta.Content)
	}
}
fmt.Println()

models, err := client.Models(ctx)
if err != nil {
	log.Fatal(err)
}
for _, m := range models {
	fmt.Printf("%-35s in=%5.2f  out=%5.2f  ctx=%7d  tools=%t vision=%t reasoning=%t\n",
		m.ID, m.InputUsdcPerMillion, m.OutputUsdcPerMillion, m.ContextWindow,
		m.SupportsTools, m.SupportsVision, m.Reasoning)
}

import "errors"

resp, err := client.Chat(ctx, req)
if err != nil {
	var prErr *solvela.PaymentRequiredError
	var rejErr *solvela.PaymentRejectedError
	var amtErr *solvela.AmountExceedsMaxError
	var gwErr *solvela.GatewayError
	var toErr *solvela.TimeoutError
	switch {
	case errors.As(err, &prErr):
		fmt.Printf("Payment needed: %s %s\n",
			prErr.PaymentRequired.CostBreakdown.Total,
			prErr.PaymentRequired.CostBreakdown.Currency)
	case errors.As(err, &rejErr):
		fmt.Printf("Rejected: %s\n", rejErr.Reason)
	case errors.As(err, &amtErr):
		fmt.Printf("Quote %d exceeds local cap %d\n", amtErr.Amount, amtErr.MaxAmount)
	case errors.As(err, &gwErr):
		fmt.Printf("Gateway HTTP %d: %s\n", gwErr.Status, gwErr.Message)
	case errors.As(err, &toErr):
		fmt.Printf("Timed out after %.1fs\n", toErr.TimeoutSecs)
	default:
		log.Fatal(err)
	}
}

fetcher := func() (float64, error) {
	// Query your Solana RPC for the wallet's USDC token-account balance.
	// Return the float USDC value (not atomic units).
	return queryUsdcBalance(wallet.Address())
}

client, err := solvela.NewClient(wallet, signer,
	solvela.WithGatewayURL("https://api.solvela.ai"),
	solvela.WithBalanceMonitor(30*time.Second, fetcher),
	solvela.WithFreeFallbackModel("openai/gpt-4o-mini"),
)
if err != nil {
	log.Fatal(err)
}
defer client.Close()

var wg sync.WaitGroup
for _, prompt := range prompts {
	wg.Add(1)
	go func(p string) {
		defer wg.Done()
		req := &solvela.ChatRequest{
			Model: "openai/gpt-4o-mini",
			Messages: []solvela.ChatMessage{{Role: solvela.RoleUser, Content: p}},
		}
		if _, err := client.Chat(ctx, req); err != nil {
			log.Println(err)
		}
	}(prompt)
}
wg.Wait()

type Signer interface {
	SignPayment(
		ctx context.Context,
		amountAtomic uint64,
		recipient string,
		resource solvela.Resource,
		accepted solvela.PaymentAccept,
	) (*solvela.PaymentPayload, error)
}

type myKeypairSigner struct {
	wallet *solvela.Wallet
	rpc    SolanaRPC // your client — e.g. gagliardetto/solana-go
}

func (s myKeypairSigner) SignPayment(
	ctx context.Context,
	amountAtomic uint64,
	recipient string,
	resource solvela.Resource,
	accepted solvela.PaymentAccept,
) (*solvela.PaymentPayload, error) {
	// 1. Build a USDC-SPL transfer to `recipient` for `amountAtomic`.
	// 2. Sign with s.wallet.Sign(...) or by passing the raw key into your RPC client.
	// 3. Return a PaymentPayload populated with the signed transaction.
	signedTxB64 := buildAndSignUsdcSplTransfer(ctx, s.rpc, s.wallet, recipient, amountAtomic)
	return &solvela.PaymentPayload{
		X402Version: solvela.X402Version,
		Resource:    resource,
		Accepted:    accepted,
		Payload:     solvela.SolanaPayload{Transaction: signedTxB64},
	}, nil
}

SOLVELA_GATEWAY_URL=https://staging.solvela.ai go run ./scripts/smoke