curl -X POST "https://api.fibrous.finance/{network}/execute" \
  -H "Content-Type: application/json" \
  -d '{
    "route": {
      "success": true,
      "inputToken": {
        "name": "Wrapped Ether",
        "address": "0x4200000000000000000000000000000000000006",
        "decimals": 18,
        "price": 3171.37
      },
      "outputToken": {
        "name": "USD Coin",
        "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
        "decimals": 6,
        "price": 0.99971
      },
      "inputAmount": "1000000000000000000",
      "outputAmount": "3165007379",
      "route": [...]
    },
    "slippage": 0.5,
    "destination": "0x1234567890123456789012345678901234567890"
  }'

const axios = require('axios');

const executeSwap = async () => {
  const response = await axios.post(
    'https://api.fibrous.finance/{network}/execute',
    {
      route: {
        inputToken: {
          address: '0x0000000000000000000000000000000000000000',
          decimals: 18,
          symbol: 'ETH'
        },
        outputToken: {
          address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
          decimals: 6,
          symbol: 'USDC'
        },
        inputAmount: '1000000000000000000',
        outputAmount: '2500000000'
      },
      slippage: 0.5,
      destination: '0x1234567890123456789012345678901234567890'
    },
    {
      headers: {
        'Content-Type': 'application/json'
      }
    }
  );
  
  return response.data;
};

import requests
import json

url = "https://api.fibrous.finance/{network}/execute"

payload = {
    "route": {
        "inputToken": {
            "address": "0x0000000000000000000000000000000000000000",
            "decimals": 18,
            "symbol": "ETH"
        },
        "outputToken": {
            "address": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
            "decimals": 6,
            "symbol": "USDC"
        },
        "inputAmount": "1000000000000000000",
        "outputAmount": "2500000000"
    },
    "slippage": 0.5,
    "destination": "0x1234567890123456789012345678901234567890"
}

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;

public class FibrousExecute {
    public static void main(String[] args) throws Exception {
        String url = "https://api.fibrous.finance/{network}/execute";
        
        Map<String, Object> route = new HashMap<>();
        Map<String, Object> inputToken = new HashMap<>();
        inputToken.put("address", "0x0000000000000000000000000000000000000000");
        inputToken.put("decimals", 18);
        inputToken.put("symbol", "ETH");
        route.put("inputToken", inputToken);
        
        Map<String, Object> outputToken = new HashMap<>();
        outputToken.put("address", "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913");
        outputToken.put("decimals", 6);
        outputToken.put("symbol", "USDC");
        route.put("outputToken", outputToken);
        route.put("inputAmount", "1000000000000000000");
        route.put("outputAmount", "2500000000");
        
        Map<String, Object> payload = new HashMap<>();
        payload.put("route", route);
        payload.put("slippage", 0.5);
        payload.put("destination", "0x1234567890123456789012345678901234567890");
        
        ObjectMapper mapper = new ObjectMapper();
        String jsonBody = mapper.writeValueAsString(payload);
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();
        
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Response: " + response.body());
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

type Route struct {
    InputToken  map[string]interface{} `json:"inputToken"`
    OutputToken map[string]interface{} `json:"outputToken"`
    InputAmount string                 `json:"inputAmount"`
    OutputAmount string                `json:"outputAmount"`
}

type Payload struct {
    Route       Route   `json:"route"`
    Slippage    float64 `json:"slippage"`
    Destination string  `json:"destination"`
}

func main() {
    url := "https://api.fibrous.finance/{network}/execute"
    
    route := Route{
        InputToken: map[string]interface{}{
            "address":  "0x0000000000000000000000000000000000000000",
            "decimals": 18,
            "symbol":   "ETH",
        },
        OutputToken: map[string]interface{}{
            "address":  "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
            "decimals": 6,
            "symbol":   "USDC",
        },
        InputAmount:  "1000000000000000000",
        OutputAmount: "2500000000",
    }
    
    payload := Payload{
        Route:       route,
        Slippage:    0.5,
        Destination: "0x1234567890123456789012345678901234567890",
    }
    
    jsonData, err := json.Marshal(payload)
    if err != nil {
        panic(err)
    }
    
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        panic(err)
    }
    
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }
    
    fmt.Println("Response:", string(body))
}