GET /api/v1/mev/wrap/info

const API_KEY = process.env.UNIKRON_API_KEY;
const API_URL = "https://api.unikron.ch";
 
async function getWrapInfo(userAddress: string) {
  const url = `${API_URL}/api/v1/mev/wrap/info?userAddress=${userAddress}`;
 
  const response = await fetch(url, {
    method: "GET",
    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 usage
const userAddress = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb";
 
try {
  const info = await getWrapInfo(userAddress);
 
  console.log("=== WETH Information ===");
  console.log(`Contract:   ${info.weth.address}`);
  console.log(`Symbol:     ${info.weth.symbol}`);
  console.log(`Decimals:   ${info.weth.decimals}`);
 
  console.log("\n=== User Balances ===");
  console.log(`ETH:        ${info.balances.eth.ether} ETH`);
  console.log(`            (${info.balances.eth.wei} wei)`);
  console.log(`WETH:       ${info.balances.weth.ether} WETH`);
  console.log(`            (${info.balances.weth.wei} wei)`);
 
  console.log("\n=== Available Operations ===");
  console.log(`Max Wrap:   ${info.operations.wrap.maxAmount} ETH`);
  console.log(`Max Unwrap: ${info.operations.unwrap.maxAmount} WETH`);
} catch (error) {
  console.error("Failed to get wrap info:", error);
}

import os
import requests
from typing import Dict, Any
 
API_KEY = os.environ.get("UNIKRON_API_KEY")
API_URL = "https://api.unikron.ch"
 
def get_wrap_info(user_address: str) -> Dict[str, Any]:
    """
    Get WETH contract information and user balances.
 
    Args:
        user_address: User's wallet address
 
    Returns:
        WETH info and balances
 
    Raises:
        requests.HTTPError: If API request fails
        Exception: If API returns error response
    """
    url = f"{API_URL}/api/v1/mev/wrap/info"
 
    params = {
        "userAddress": user_address
    }
 
    headers = {
        "X-API-Key": API_KEY,
    }
 
    response = requests.get(
        url,
        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 usage
user_address = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
 
try:
    info = get_wrap_info(user_address)
 
    print("=== WETH Information ===")
    print(f"Contract:   {info['weth']['address']}")
    print(f"Symbol:     {info['weth']['symbol']}")
    print(f"Decimals:   {info['weth']['decimals']}")
 
    print("\n=== User Balances ===")
    print(f"ETH:        {info['balances']['eth']['ether']} ETH")
    print(f"            ({info['balances']['eth']['wei']} wei)")
    print(f"WETH:       {info['balances']['weth']['ether']} WETH")
    print(f"            ({info['balances']['weth']['wei']} wei)")
 
    print("\n=== Available Operations ===")
    print(f"Max Wrap:   {info['operations']['wrap']['maxAmount']} ETH")
    print(f"Max Unwrap: {info['operations']['unwrap']['maxAmount']} WETH")
 
except requests.exceptions.RequestException as e:
    print(f"Request failed: {e}")
except Exception as e:
    print(f"Failed to get wrap info: {e}")

package main
 
import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)
 
type WrapInfoResponse struct {
    OK   bool `json:"ok"`
    Data struct {
        WETH struct {
            Address  string `json:"address"`
            Name     string `json:"name"`
            Symbol   string `json:"symbol"`
            Decimals int    `json:"decimals"`
            ChainID  int    `json:"chainId"`
        } `json:"weth"`
        Balances struct {
            ETH struct {
                Wei   string `json:"wei"`
                Ether string `json:"ether"`
            } `json:"eth"`
            WETH struct {
                Wei   string `json:"wei"`
                Ether string `json:"ether"`
            } `json:"weth"`
        } `json:"balances"`
        Operations struct {
            Wrap struct {
                Description string `json:"description"`
                MaxAmount   string `json:"maxAmount"`
            } `json:"wrap"`
            Unwrap struct {
                Description string `json:"description"`
                MaxAmount   string `json:"maxAmount"`
            } `json:"unwrap"`
        } `json:"operations"`
    } `json:"data"`
}
 
func getWrapInfo(userAddress string) (*WrapInfoResponse, error) {
    baseURL := "https://api.unikron.ch/api/v1/mev/wrap/info"
 
    params := url.Values{}
    params.Add("userAddress", userAddress)
 
    fullURL := fmt.Sprintf("%s?%s", baseURL, params.Encode())
 
    req, err := http.NewRequest("GET", fullURL, nil)
    if err != nil {
        return nil, err
    }
 
    req.Header.Set("X-API-Key", os.Getenv("UNIKRON_API_KEY"))
 
    client := &http.Client{Timeout: 10 * time.Second}
    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 infoResp WrapInfoResponse
    if err := json.Unmarshal(body, &infoResp); err != nil {
        return nil, err
    }
 
    if !infoResp.OK {
        return nil, fmt.Errorf("request failed")
    }
 
    return &infoResp, nil
}
 
func main() {
    userAddress := "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
 
    info, err := getWrapInfo(userAddress)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
 
    fmt.Println("=== WETH Information ===")
    fmt.Printf("Contract:   %s\n", info.Data.WETH.Address)
    fmt.Printf("Symbol:     %s\n", info.Data.WETH.Symbol)
    fmt.Printf("Decimals:   %d\n", info.Data.WETH.Decimals)
 
    fmt.Println("\n=== User Balances ===")
    fmt.Printf("ETH:        %s ETH\n", info.Data.Balances.ETH.Ether)
    fmt.Printf("            (%s wei)\n", info.Data.Balances.ETH.Wei)
    fmt.Printf("WETH:       %s WETH\n", info.Data.Balances.WETH.Ether)
    fmt.Printf("            (%s wei)\n", info.Data.Balances.WETH.Wei)
 
    fmt.Println("\n=== Available Operations ===")
    fmt.Printf("Max Wrap:   %s ETH\n", info.Data.Operations.Wrap.MaxAmount)
    fmt.Printf("Max Unwrap: %s WETH\n", info.Data.Operations.Unwrap.MaxAmount)
}

curl -X GET "https://api.unikron.ch/api/v1/mev/wrap/info?userAddress=0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb" \
  -H "X-API-Key: YOUR_API_KEY"