Go SDK

go get github.com/crylabsorg/suward-sdk-go

package main
 
import (
  "context"
  "os"
 
  "github.com/crylabsorg/suward-sdk-go/client"
  "github.com/crylabsorg/suward-sdk-go/option"
)
 
func main() {
  suward := client.NewClient(option.WithAPIKey(os.Getenv("SUWARD_API_KEY")))
  ctx := context.Background()
  _ = ctx
  _ = suward
}

// The root package is named api, so alias it on import.
import suwardsdkgo "github.com/crylabsorg/suward-sdk-go"
 
// ptr returns a pointer to v — the SDK takes *T for every optional field.
func ptr[T any](v T) *T { return &v }
 
payment, err := suward.Payments.CreatePayment(ctx, &suwardsdkgo.CryptopayCreatePaymentRequest{
  Amount:     "100000000",                                          // integer string, smallest unit
  Asset:      ptr(suwardsdkgo.CryptopayAssetIDTeststablecoinOptimism),
  ExternalID: ptr(order.ID),                                          // makes the call idempotent
})
if err != nil {
  return err
}
 
// Projects with an activation flow start the payment in pending/created, with no
// address and no way into accepted until it is activated.
if payment.SubStatus == suwardsdkgo.CryptopayPaymentSubStatusEnumCreated {
  if _, err = suward.Payments.ActivatePayment(ctx, &suwardsdkgo.PostV1PaymentsPaymentIDActivateRequest{
    PaymentID: payment.ID,
  }); err != nil {
    return err
  }
}
 
// send the customer to payment.PaymentPageURL
 
// drive the lifecycle while you write the handler (test assets only)
_, err = suward.Payments.SimulatePayment(ctx, &suwardsdkgo.CryptopaySimulatePaymentRequest{
  PaymentID: payment.ID,
  Status:    suwardsdkgo.CryptopayPaymentStatusEnumAccepted,
  SubStatus: suwardsdkgo.CryptopayPaymentSubStatusEnumCompleted,
})

quote, err := suward.Payments.QuotePaymentFees(ctx, &suwardsdkgo.CryptopayQuotePaymentRequest{
  Asset:           suwardsdkgo.CryptopayAssetIDUsdtArbitrum,
  Amount:          "100000000",
  ServiceFeePayer: ptr(suwardsdkgo.CryptopayFeePayerCustomer),
  NetworkFeePayer: ptr(suwardsdkgo.CryptopayFeePayerCustomer),
  ComplianceLevel: ptr(suwardsdkgo.CryptopayComplianceLevelBasic),
})

wallet, err := suward.StaticWallets.CreateStaticWallet(ctx, &suwardsdkgo.CryptopayCreateStaticWalletRequest{
  ExternalID:    ptr("customer-99"),
  AllowedAssets: []suwardsdkgo.CryptopayAssetID{suwardsdkgo.CryptopayAssetIDUsdtEthereum, suwardsdkgo.CryptopayAssetIDUsdtArbitrum},
})
 
deposits, err := suward.StaticWallets.ListStaticWalletDeposits(ctx, &suwardsdkgo.GetV1StaticWalletsStaticWalletIDDepositsRequest{
  StaticWalletID: wallet.ID,
  Limit:          ptr(100),
})

import (
  "errors"
 
  "github.com/crylabsorg/suward-sdk-go/core"
)
 
payment, err := suward.Payments.CreatePayment(ctx, req)
if err != nil {
  var apiErr *core.APIError
  if errors.As(err, &apiErr) {
    // branch on the stable HTTP status, not the message
    if apiErr.StatusCode == 409 {
      // externalId already used — fetch the existing payment
    }
  }
  return err
}