POST /api/v1/mev/orders

import { ethers } from "ethers";
 
const API_KEY = process.env.UNIKRON_API_KEY;
const API_URL = "https://api.unikron.ch";
 
async function submitOrder(quote: any, signer: ethers.Signer) {
  // 1. Sign transaction with exact parameters from quote
  const signedTx = await signer.signTransaction(
    quote.mevProtection.transactionParams
  );
 
  // 2. Build threat analysis from MEV analysis
  const threatAnalysis = {
    threatScore: quote.mevAnalysis?.threatLevel === "HIGH" ? 0.8 :
                 quote.mevAnalysis?.threatLevel === "MEDIUM" ? 0.5 : 0.2,
    threatLevel: quote.mevAnalysis?.threatLevel || "LOW",
    confidence: 0.8,
    riskFactors: [],
    estimatedSavings: {
      estimatedProtection: {
        amount: quote.mevAnalysis?.estimatedProtectionUsd || 0,
        currency: "USD"
      }
    },
    timestamp: Date.now()
  };
 
  // 3. Prepare order parameters
  const orderParams = {
    fromToken: quote.sellToken,
    toToken: quote.buyToken,
    amount: quote.sellAmount,
    minReturnAmount: quote.minBuyAmount,
    userAddress: await signer.getAddress(),
    chainId: quote.mevProtection.transactionParams.chainId,
    deadline: Math.floor(Date.now() / 1000) + 1800, // 30 min from now
    slippageBps: 50, // 0.5%
    selectedTier: 2, // MEV Blocker
    threatAnalysis: threatAnalysis,
    transactionValueUsd: quote.scoring.netValueUsd,
    dexRoute: {
      source: quote.source,
      target: quote.dexRoute.target,
      estimatedGas: quote.estimatedGas,
      data: quote.dexRoute.data,
    },
  };
 
  // 4. Submit order with providerMetadata
  const response = await fetch(`${API_URL}/api/v1/mev/orders`, {
    method: "POST",
    headers: {
      "X-API-Key": API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      orderParams,
      signedTransaction: signedTx,
      providerMetadata: quote.mevProtection.providerMetadata, // Required!
    }),
  });
 
  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 quote = await getQuote(...); // From previous step
const order = await submitOrder(quote, signer);
 
console.log("=== Order Submitted ===");
console.log(`Order ID:        ${order.order.orderId}`);
console.log(`Provider:        ${order.order.provider}`);
console.log(`Status:          ${order.order.status}`);
console.log(`Transaction:     ${order.order.txHash}`);
console.log(`Tracking:        ${order.order.trackingUrl}`);
console.log(`\nPoll status at:  ${order.tracking.statusEndpoint}`);
console.log(`Poll interval:   ${order.tracking.pollingInterval}s`);

import os
import time
import requests
from web3 import Web3
from eth_account import Account
from typing import Dict, Any
 
API_KEY = os.environ.get("UNIKRON_API_KEY")
API_URL = "https://api.unikron.ch"
 
def submit_order(quote: Dict[str, Any], private_key: str) -> Dict[str, Any]:
    """
    Submit signed transaction for MEV-protected execution.
 
    Args:
        quote: Quote data from GET /quote
        private_key: User's private key for signing
 
    Returns:
        Order submission response
 
    Raises:
        requests.HTTPError: If API request fails
        Exception: If API returns error response
    """
    account = Account.from_key(private_key)
 
    # 1. Sign transaction with exact parameters from quote
    tx_params = quote['mevProtection']['transactionParams']
    signed_tx = account.sign_transaction(tx_params)
 
    # 2. Build threat analysis from MEV analysis
    threat_level = quote['mevAnalysis'].get('threatLevel', 'LOW')
    threat_score = 0.8 if threat_level == "HIGH" else 0.5 if threat_level == "MEDIUM" else 0.2
 
    threat_analysis = {
        "threatScore": threat_score,
        "threatLevel": threat_level,
        "confidence": 0.8,
        "riskFactors": [],
        "estimatedSavings": {
            "estimatedProtection": {
                "amount": quote['mevAnalysis'].get('estimatedProtectionUsd', 0),
                "currency": "USD"
            }
        },
        "timestamp": int(time.time() * 1000)
    }
 
    # 3. Prepare order parameters
    order_params = {
        "fromToken": quote['sellToken'],
        "toToken": quote['buyToken'],
        "amount": quote['sellAmount'],
        "minReturnAmount": quote['minBuyAmount'],
        "userAddress": account.address,
        "chainId": tx_params['chainId'],
        "deadline": int(time.time()) + 1800,  # 30 min from now
        "slippageBps": 50,  # 0.5%
        "selectedTier": 2,  # MEV Blocker
        "threatAnalysis": threat_analysis,
        "transactionValueUsd": quote['scoring']['netValueUsd'],
        "dexRoute": {
            "source": quote['source'],
            "target": quote['dexRoute']['target'],
            "estimatedGas": quote['estimatedGas'],
            "data": quote['dexRoute']['data']
        }
    }
 
    # 4. Submit order with providerMetadata
    payload = {
        "orderParams": order_params,
        "signedTransaction": signed_tx.rawTransaction.hex(),
        "providerMetadata": quote['mevProtection']['providerMetadata']  # Required!
    }
 
    headers = {
        "X-API-Key": API_KEY,
        "Content-Type": "application/json",
    }
 
    response = requests.post(
        f"{API_URL}/api/v1/mev/orders",
        json=payload,
        headers=headers,
        timeout=30
    )
 
    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
quote = get_quote(...)  # From previous step
private_key = os.environ.get("PRIVATE_KEY")
 
try:
    order = submit_order(quote, private_key)
 
    print("=== Order Submitted ===")
    print(f"Order ID:        {order['order']['orderId']}")
    print(f"Provider:        {order['order']['provider']}")
    print(f"Status:          {order['order']['status']}")
    print(f"Transaction:     {order['order']['txHash']}")
    print(f"Tracking:        {order['order']['trackingUrl']}")
    print(f"\nPoll status at:  {order['tracking']['statusEndpoint']}")
    print(f"Poll interval:   {order['tracking']['pollingInterval']}s")
 
except requests.exceptions.RequestException as e:
    print(f"Request failed: {e}")
except Exception as e:
    print(f"Order submission failed: {e}")

package main
 
import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "time"
)
 
type OrderSubmission struct {
    OrderParams        OrderParams        `json:"orderParams"`
    SignedTransaction  string             `json:"signedTransaction"`
    ProviderMetadata   ProviderMetadata   `json:"providerMetadata"`
}
 
type OrderParams struct {
    FromToken           string         `json:"fromToken"`
    ToToken             string         `json:"toToken"`
    Amount              string         `json:"amount"`
    MinReturnAmount     string         `json:"minReturnAmount"`
    UserAddress         string         `json:"userAddress"`
    ChainID             int            `json:"chainId"`
    Deadline            int64          `json:"deadline"`
    SlippageBps         int            `json:"slippageBps"`
    SelectedTier        int            `json:"selectedTier"`
    ThreatAnalysis      ThreatAnalysis `json:"threatAnalysis"`
    TransactionValueUsd float64        `json:"transactionValueUsd"`
    DexRoute            DexRouteSubmit `json:"dexRoute"`
}
 
type DexRouteSubmit struct {
    Source       string `json:"source"`
    Target       string `json:"target"`
    EstimatedGas int    `json:"estimatedGas"`
    Data         string `json:"data"`
}
 
type OrderResponse struct {
    OK   bool `json:"ok"`
    Data struct {
        Order struct {
            OrderID                 string `json:"orderId"`
            Provider                string `json:"provider"`
            Tier                    int    `json:"tier"`
            Status                  string `json:"status"`
            SubmittedAt             string `json:"submittedAt"`
            ExpiresAt               string `json:"expiresAt"`
            EstimatedExecutionTime  string `json:"estimatedExecutionTime"`
            TrackingURL             string `json:"trackingUrl"`
            ProviderOrderID         string `json:"providerOrderId"`
            TxHash                  string `json:"txHash"`
        } `json:"order"`
        Tracking struct {
            StatusEndpoint  string `json:"statusEndpoint"`
            PollingInterval int    `json:"pollingInterval"`
        } `json:"tracking"`
    } `json:"data"`
}
 
func submitOrder(quote *QuoteData, signedTx string) (*OrderResponse, error) {
    apiURL := "https://api.unikron.ch/api/v1/mev/orders"
 
    orderParams := OrderParams{
        FromToken:           quote.SellToken,
        ToToken:             quote.BuyToken,
        Amount:              quote.SellAmount,
        MinReturnAmount:     quote.MinBuyAmount,
        UserAddress:         "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
        ChainID:             1,
        Deadline:            time.Now().Unix() + 1800,
        SlippageBps:         50,
        SelectedTier:        2,
        ThreatAnalysis:      quote.MevAnalysis,
        TransactionValueUsd: quote.Scoring.NetValueUsd,
        DexRoute: DexRouteSubmit{
            Source:       quote.Source,
            Target:       quote.DexRoute.Target,
            EstimatedGas: quote.EstimatedGas,
            Data:         quote.DexRoute.Data,
        },
    }
 
    submission := OrderSubmission{
        OrderParams:       orderParams,
        SignedTransaction: signedTx,
        ProviderMetadata:  quote.MevProtection.ProviderMetadata,
    }
 
    jsonData, err := json.Marshal(submission)
    if err != nil {
        return nil, err
    }
 
    req, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }
 
    req.Header.Set("X-API-Key", os.Getenv("UNIKRON_API_KEY"))
    req.Header.Set("Content-Type", "application/json")
 
    client := &http.Client{Timeout: 30 * 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 orderResp OrderResponse
    if err := json.Unmarshal(body, &orderResp); err != nil {
        return nil, err
    }
 
    if !orderResp.OK {
        return nil, fmt.Errorf("order submission failed")
    }
 
    return &orderResp, nil
}
 
func main() {
    quote, _ := getQuote(...)  // From previous step
    signedTx := "0x02f8b30182..."  // Signed transaction
 
    order, err := submitOrder(quote, signedTx)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
 
    fmt.Println("=== Order Submitted ===")
    fmt.Printf("Order ID:    %s\n", order.Data.Order.OrderID)
    fmt.Printf("Provider:    %s\n", order.Data.Order.Provider)
    fmt.Printf("Status:      %s\n", order.Data.Order.Status)
    fmt.Printf("Transaction: %s\n", order.Data.Order.TxHash)
    fmt.Printf("\nPoll status at: %s\n", order.Data.Tracking.StatusEndpoint)
}