Error Handling

import { ExitApiError } from "@lasersell/lasersell-sdk";

try {
  const response = await client.buildSellTx(request);
} catch (error) {
  if (error instanceof ExitApiError) {
    console.log("Kind:", error.kind);
    console.log("Retryable:", error.isRetryable());
    console.log("HTTP status:", error.status);
    console.log("Body:", error.body);
  }
}

from lasersell_sdk.exit_api import ExitApiError

try:
    response = await client.build_sell_tx(request)
except ExitApiError as error:
    print("Kind:", error.kind)
    print("Retryable:", error.is_retryable())
    print("HTTP status:", error.status)
    print("Body:", error.body)

use lasersell_sdk::exit_api::ExitApiError;

match client.build_sell_tx(&request).await {
    Ok(response) => { /* use response */ }
    Err(error) => {
        eprintln!("Kind: {:?}", error.kind());
        eprintln!("Retryable: {}", error.is_retryable());
    }
}

import lasersell "github.com/lasersell/lasersell-sdk/go"

resp, err := client.BuildSellTx(ctx, request)
if err != nil {
    var apiErr *lasersell.ExitAPIError
    if errors.As(err, &apiErr) {
        fmt.Println("Kind:", apiErr.Kind)
        fmt.Println("Retryable:", apiErr.IsRetryable())
        fmt.Println("HTTP status:", apiErr.Status)
    }
}

const client = ExitApiClient.withOptions("YOUR_API_KEY", {
  attempt_timeout_ms: 2000,
  retry_policy: {
    max_attempts: 3,
    initial_backoff_ms: 50,
    max_backoff_ms: 200,
    jitter_ms: 50,
  },
});

from lasersell_sdk.exit_api import ExitApiClient, ExitApiClientOptions
from lasersell_sdk.retry import RetryPolicy

client = ExitApiClient.with_options(
    "YOUR_API_KEY",
    ExitApiClientOptions(
        attempt_timeout_s=2.0,
        retry_policy=RetryPolicy(
            max_attempts=3,
            initial_backoff_ms=50,
            max_backoff_ms=200,
            jitter_ms=50,
        ),
    ),
)

use std::time::Duration;
use lasersell_sdk::exit_api::{ExitApiClient, ExitApiClientOptions};
use lasersell_sdk::retry::RetryPolicy;
use secrecy::SecretString;

let client = ExitApiClient::with_options(
    Some(SecretString::new("YOUR_API_KEY".into())),
    ExitApiClientOptions {
        connect_timeout: Duration::from_millis(200),
        attempt_timeout: Duration::from_millis(2000),
        retry_policy: RetryPolicy {
            max_attempts: 3,
            initial_backoff: Duration::from_millis(50),
            max_backoff: Duration::from_millis(200),
            jitter: Duration::from_millis(50),
        },
    },
)?;

import (
    "time"
    lasersell "github.com/lasersell/lasersell-sdk/go"
)

client := lasersell.NewExitAPIClientWithOptions("YOUR_API_KEY", lasersell.ExitAPIClientOptions{
    ConnectTimeout: 200 * time.Millisecond,
    AttemptTimeout: 2000 * time.Millisecond,
    RetryPolicy: lasersell.RetryPolicy{
        MaxAttempts:    3,
        InitialBackoff: 50 * time.Millisecond,
        MaxBackoff:     200 * time.Millisecond,
        Jitter:         50 * time.Millisecond,
    },
})