GET /api/v1/quote

curl -X GET "https://api.unikron.ch/api/v1/quote?\
sellToken=0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2&\
buyToken=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&\
sellAmount=1000000000000000000&\
userAddress=0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb&\
chainId=1" \
  -H "X-API-Key: YOUR_API_KEY" \

import { ethers } from "ethers";
 
const API_KEY = process.env.UNIKRON_API_KEY;
const API_URL = "https://api.unikron.ch";
 
async function getQuote(
  sellToken: string,
  buyToken: string,
  amount: string,
  userAddress: string
) {
  // Convert human-readable amount to wei
  const sellAmount = ethers.parseEther(amount);
 
  const params = new URLSearchParams({
    sellToken,
    buyToken,
    sellAmount: sellAmount.toString(),
    userAddress,
    chainId: "1",
  });
 
  const response = await fetch(`${API_URL}/api/v1/quote?${params}`, {
    headers: {
      "X-API-Key": API_KEY,
    },
  });
 
  if (!response.ok) {
    const error = await response.text();
    throw new Error(`HTTP ${response.status}: ${error}`);
  }
 
  const { ok, data } = await response.json();
 
  if (!ok) {
    throw new Error(`API Error: ${data.error}`);
  }
 
  return data;
}
 
// Example: Swap 1 WETH for USDC
const WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
const USER_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb";
 
try {
  const quote = await getQuote(WETH, USDC, "1", USER_ADDRESS);
 
  console.log("=== Quote Results ===");
  console.log(`Best Route:      ${quote.source}`);
  console.log(
    `Expected Output: ${ethers.formatUnits(quote.buyAmount, 6)} USDC`
  );
  console.log(
    `Minimum Output:  ${ethers.formatUnits(quote.minBuyAmount, 6)} USDC`
  );
  console.log(`Price Impact:    ${quote.priceImpact}%`);
  console.log(`Estimated Gas:   ${quote.estimatedGas} units`);
  console.log(`Gas Cost:        $${quote.scoring.gasCostUsd}`);
 
  // Router address for token approval
  console.log(`\nApprove tokens to: ${quote.dexRoute.target}`);
} catch (error) {
  console.error("Quote failed:", error.message);
}

import os
import requests
from web3 import Web3
from typing import Dict, Any
 
API_KEY = os.environ.get("UNIKRON_API_KEY")
API_URL = "https://api.unikron.ch"
 
def get_quote(
    sell_token: str,
    buy_token: str,
    amount: str,
    user_address: str
) -> Dict[str, Any]:
    """
    Get swap quote from UNIKRON API.
 
    Args:
        sell_token: Token address to sell (checksummed)
        buy_token: Token address to buy (checksummed)
        amount: Amount in human-readable format (e.g., "1" for 1 WETH)
        user_address: User's wallet address
 
    Returns:
        Quote data dictionary
 
    Raises:
        requests.HTTPError: If API request fails
        Exception: If API returns error response
    """
    # Convert to wei (for 18-decimal tokens)
    sell_amount = Web3.to_wei(amount, 'ether')
 
    params = {
        "sellToken": sell_token,
        "buyToken": buy_token,
        "sellAmount": str(sell_amount),
        "userAddress": user_address,
        "chainId": "1",
    }
 
    headers = {
        "X-API-Key": API_KEY,
    }
 
    response = requests.get(
        f"{API_URL}/api/v1/quote",
        params=params,
        headers=headers,
        timeout=10
    )
 
    response.raise_for_status()
    data = response.json()
 
    if not data.get("ok"):
        error = data.get("error", "Unknown error")
        message = data.get("message", "")
        raise Exception(f"API Error: {error} - {message}")
 
    return data["data"]
 
 
# Example: Swap 1 WETH for USDC
WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
USER_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
 
try:
    quote = get_quote(WETH, USDC, "1", USER_ADDRESS)
 
    print("=== Quote Results ===")
    print(f"Best Route:      {quote['source']}")
    print(f"Expected Output: {int(quote['buyAmount']) / 1e6:.2f} USDC")
    print(f"Minimum Output:  {int(quote['minBuyAmount']) / 1e6:.2f} USDC")
    print(f"Price Impact:    {quote['priceImpact']}%")
    print(f"Estimated Gas:   {quote['estimatedGas']} units")
    print(f"Gas Cost:        ${quote['scoring']['gasCostUsd']:.2f}")
 
    # Router address for token approval
    print(f"\nApprove tokens to: {quote['dexRoute']['target']}")
 
    # Transaction parameters ready for signing
    tx_params = quote['mevProtection']['transactionParams']
    print(f"\nTransaction ready to sign:")
    print(f"  To:         {tx_params['to']}")
    print(f"  Gas Limit:  {tx_params['gasLimit']}")
    print(f"  Nonce:      {tx_params['nonce']}")
 
    # Provider metadata for order submission
    provider_metadata = quote['mevProtection']['providerMetadata']
    print(f"\nMEV Protection:")
    print(f"  Endpoint:   {provider_metadata['mevBlockerMetadata']['endpoint']}")
    print(f"  Share Mode: {provider_metadata['mevBlockerMetadata']['shareMode']}")
 
except requests.exceptions.RequestException as e:
    print(f"Request failed: {e}")
except Exception as e:
    print(f"Quote failed: {e}")

package main
 
import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
)
 
type QuoteResponse struct {
    OK        bool      `json:"ok"`
    Data      QuoteData `json:"data"`
    Timestamp int64     `json:"timestamp"`
}
 
type QuoteData struct {
    Source        string  `json:"source"`
    SellToken     string  `json:"sellToken"`
    BuyToken      string  `json:"buyToken"`
    SellAmount    string  `json:"sellAmount"`
    BuyAmount     string  `json:"buyAmount"`
    MinBuyAmount  string  `json:"minBuyAmount"`
    EstimatedGas  int     `json:"estimatedGas"`
    PriceImpact   float64 `json:"priceImpact"`
    DexRoute      DexRoute `json:"dexRoute"`
}
 
type DexRoute struct {
    Dex    string `json:"dex"`
    Target string `json:"target"`
}
 
func getQuote(sellToken, buyToken, sellAmount, userAddress string) (*QuoteData, error) {
    apiURL := "https://api.unikron.ch/api/v1/quote"
 
    // Build query parameters
    params := url.Values{}
    params.Add("sellToken", sellToken)
    params.Add("buyToken", buyToken)
    params.Add("sellAmount", sellAmount)
    params.Add("userAddress", userAddress)
    params.Add("chainId", "1")
 
    fullURL := fmt.Sprintf("%s?%s", apiURL, params.Encode())
 
    // Create request
    req, err := http.NewRequest("GET", fullURL, nil)
    if err != nil {
        return nil, err
    }
 
    req.Header.Set("X-API-Key", os.Getenv("UNIKRON_API_KEY"))
 
    // Execute request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
 
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
 
    var quoteResp QuoteResponse
    if err := json.Unmarshal(body, &quoteResp); err != nil {
        return nil, err
    }
 
    if !quoteResp.OK {
        return nil, fmt.Errorf("API error: quote request failed")
    }
 
    return &quoteResp.Data, nil
}
 
func main() {
    WETH := "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
    USDC := "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
    amount := "1000000000000000000" // 1 WETH
    user := "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
 
    quote, err := getQuote(WETH, USDC, amount, user)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
 
    fmt.Println("=== Quote Results ===")
    fmt.Printf("Best Route:     %s\n", quote.Source)
    fmt.Printf("Buy Amount:     %s\n", quote.BuyAmount)
    fmt.Printf("Min Buy Amount: %s\n", quote.MinBuyAmount)
    fmt.Printf("Price Impact:   %.2f%%\n", quote.PriceImpact)
    fmt.Printf("Estimated Gas:  %d units\n", quote.EstimatedGas)
    fmt.Printf("\nApprove tokens to: %s\n", quote.DexRoute.Target)
}