Swap SDK

npm install @defuse-protocol/one-click-sdk-typescript

go get github.com/defuse-protocol/one-click-sdk-go

# Clone the repo next to your project
git clone https://github.com/defuse-protocol/one-click-sdk-rs.git

# Add to your Cargo.toml under [dependencies]
# one-click-sdk-rs = { path = "./one-click-sdk-rs" }

import { OpenAPI } from '@defuse-protocol/one-click-sdk-typescript';

// The base URL defaults to https://1click.chaindefuser.com
OpenAPI.BASE = 'https://1click.chaindefuser.com';

// Required for getQuote, submitDepositTx, and getExecutionStatus
OpenAPI.TOKEN = 'YOUR_JWT_TOKEN';

import (
  "context"
  "fmt"
  openapiclient "github.com/defuse-protocol/one-click-sdk-go"
)

configuration := openapiclient.NewConfiguration()
apiClient := openapiclient.NewAPIClient(configuration)

authCtx := context.WithValue(
  context.Background(),
  openapiclient.ContextAccessToken,
  "YOUR_JWT_TOKEN",
)

use one_click_sdk_rs::apis::configuration::Configuration;

// base_path already defaults to https://1click.chaindefuser.com
let config = Configuration {
    bearer_access_token: Some("YOUR_JWT_TOKEN".to_string()),
    ..Default::default()
};

import { OneClickService } from '@defuse-protocol/one-click-sdk-typescript';

const tokens = await OneClickService.getTokens();
console.log(tokens);

// GetTokens does not require authentication
tokens, _, err := apiClient.OneClickAPI.GetTokens(context.Background()).Execute()
if err != nil {
  fmt.Fprintf(os.Stderr, "GetTokens error: %v\n", err)
  panic(err)
}
fmt.Printf("Supported tokens: %v\n", tokens)

use one_click_sdk_rs::apis::one_click_api;

// get_tokens does not require authentication
let tokens = one_click_api::get_tokens(&config).await?;
println!("{:?}", tokens);

import { OneClickService, QuoteRequest } from '@defuse-protocol/one-click-sdk-typescript';

// Example: swap USDC on Arbitrum for USDC on Solana
const quoteRequest: QuoteRequest = {
  dry: false,                                    // true = simulate only, no depositAddress returned
  swapType: QuoteRequest.swapType.EXACT_INPUT,
  slippageTolerance: 100,                        // basis points (100 = 1%)
  originAsset: 'nep141:arb-0xaf88d065e77c8cc2239327c5edb3a432268e5831.omft.near',
  depositType: QuoteRequest.depositType.ORIGIN_CHAIN,
  destinationAsset: 'nep141:sol-5ce3bf3a31af18be40ba30f721101b4341690186.omft.near',
  amount: '1000000',                             // 1 USDC in smallest units (6 decimals)
  refundTo: '0xYourArbitrumAddress',
  refundType: QuoteRequest.refundType.ORIGIN_CHAIN,
  recipient: 'YourSolanaAddress',
  recipientType: QuoteRequest.recipientType.DESTINATION_CHAIN,
  deadline: new Date(Date.now() + 3 * 60 * 1000).toISOString(),
};

const quote = await OneClickService.getQuote(quoteRequest);

import "time"

// Example: swap USDC on Arbitrum for USDC on Solana
quoteRequest := *openapiclient.NewQuoteRequest(
  false,                   // dry
  "EXACT_INPUT",           // swapType
  float32(100),            // slippageTolerance (basis points, 100 = 1%)
  "nep141:arb-0xaf88d065e77c8cc2239327c5edb3a432268e5831.omft.near", // originAsset
  "ORIGIN_CHAIN",          // depositType
  "nep141:sol-5ce3bf3a31af18be40ba30f721101b4341690186.omft.near",   // destinationAsset
  "1000000",               // amount (1 USDC, 6 decimals)
  "0xYourArbitrumAddress", // refundTo
  "ORIGIN_CHAIN",          // refundType
  "YourSolanaAddress",     // recipient
  "DESTINATION_CHAIN",     // recipientType
  time.Now().Add(3*time.Minute), // deadline
)

quote, _, err := apiClient.OneClickAPI.GetQuote(authCtx).QuoteRequest(quoteRequest).Execute()
if err != nil {
  fmt.Fprintf(os.Stderr, "GetQuote error: %v\n", err)
  panic(err)
}

use one_click_sdk_rs::apis::one_click_api;
use one_click_sdk_rs::models::{DepositType, QuoteRequest, RecipientType, RefundType, SwapType};

// Example: swap USDC on Arbitrum for USDC on Solana
let quote_request = QuoteRequest::new(
    false,                        // dry
    SwapType::ExactInput,
    100.0,                        // slippage_tolerance (basis points, 100 = 1%)
    "nep141:arb-0xaf88d065e77c8cc2239327c5edb3a432268e5831.omft.near".to_string(), // origin_asset
    DepositType::OriginChain,
    "nep141:sol-5ce3bf3a31af18be40ba30f721101b4341690186.omft.near".to_string(), // destination_asset
    "1000000".to_string(),        // amount (1 USDC, 6 decimals)
    "0xYourArbitrumAddress".to_string(), // refund_to
    RefundType::OriginChain,
    "YourSolanaAddress".to_string(), // recipient
    RecipientType::DestinationChain,
    "2025-12-31T23:59:59Z".to_string(), // deadline (ISO 8601)
);

let quote = one_click_api::get_quote(&config, quote_request).await?;

await OneClickService.submitDepositTx({
  depositAddress: quote.quote.depositAddress!,
  txHash: '0xYourTransactionHash',
});

submitRequest := *openapiclient.NewSubmitDepositTxRequest(
  "0xYourTransactionHash",
  *quote.Quote.DepositAddress,
)

_, _, err = apiClient.OneClickAPI.
  SubmitDepositTx(authCtx).
  SubmitDepositTxRequest(submitRequest).
  Execute()
if err != nil {
  fmt.Fprintf(os.Stderr, "SubmitDepositTx error: %v\n", err)
}

use one_click_sdk_rs::models::SubmitDepositTxRequest;

let submit_request = SubmitDepositTxRequest::new(
    "0xYourTransactionHash".to_string(),
    quote.quote.deposit_address.clone().unwrap_or_default(),
);

one_click_api::submit_deposit_tx(&config, submit_request).await?;

const status = await OneClickService.getExecutionStatus(quote.quote.depositAddress!);
console.log(status.status);

status, _, err := apiClient.OneClickAPI.
  GetExecutionStatus(authCtx).
  DepositAddress(*quote.Quote.DepositAddress).
  Execute()
if err != nil {
  fmt.Fprintf(os.Stderr, "GetExecutionStatus error: %v\n", err)
  panic(err)
}
fmt.Println(*status.Status)

let status = one_click_api::get_execution_status(
    &config,
    quote.quote.deposit_address.as_deref().unwrap_or_default(),
).await?;

println!("{:?}", status.status);