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

const axios = require('axios');

const route = {
  success: true,
  routeSwapType: 0,
  inputToken: {
    name: "Wrapped Ether",
    address: "0x4200000000000000000000000000000000000006",
    decimals: 18,
    price: 2949.717076112869
  },
  inputAmount: "1000000000000000000",
  outputToken: {
    name: "USD Coin",
    address: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
    decimals: 6,
    price: 0.999597487941284
  },
  outputAmount: "2951108576",
  route: []
};

const data = {
  route,
  slippage: 0.5,
  destination: "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
};

axios.post('https://api.fibrous.finance/{network}/v2/calldata', data, {
  headers: {
    'Content-Type': 'application/json'
  }
})
  .then(response => {
    console.log(`API Version: ${response.data.meta.apiVersion}`);
    console.log(`Router: ${response.data.router_address}`);
    // Use response.data for transaction execution
  })
  .catch(error => console.error(error));

import requests
import json

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

route = {
    "success": True,
    "routeSwapType": 0,
    "inputToken": {
        "name": "Wrapped Ether",
        "address": "0x4200000000000000000000000000000000000006",
        "decimals": 18,
        "price": 2949.717076112869
    },
    "inputAmount": "1000000000000000000",
    "outputToken": {
        "name": "USD Coin",
        "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
        "decimals": 6,
        "price": 0.999597487941284
    },
    "outputAmount": "2951108576",
    "route": []
}

payload = {
    "route": route,
    "slippage": 0.5,
    "destination": "0x1234567890123456789012345678901234567890"
}

response = requests.post(url, json=payload)
data = response.json()

print(f"API Version: {data['meta']['apiVersion']}")
print(f"Router Address: {data['router_address']}")

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 FibrousCalldata {
    public static void main(String[] args) throws Exception {
        String url = "https://api.fibrous.finance/{network}/v2/calldata";
        
        Map<String, Object> route = new HashMap<>();
        route.put("success", true);
        route.put("routeSwapType", 0);
        
        Map<String, Object> inputToken = new HashMap<>();
        inputToken.put("name", "Wrapped Ether");
        inputToken.put("address", "0x4200000000000000000000000000000000000006");
        inputToken.put("decimals", 18);
        inputToken.put("price", 2949.717076112869);
        route.put("inputToken", inputToken);
        route.put("inputAmount", "1000000000000000000");
        
        Map<String, Object> outputToken = new HashMap<>();
        outputToken.put("name", "USD Coin");
        outputToken.put("address", "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913");
        outputToken.put("decimals", 6);
        outputToken.put("price", 0.999597487941284);
        route.put("outputToken", outputToken);
        route.put("outputAmount", "2951108576");
        route.put("route", new Object[0]);
        
        Map<String, Object> payload = new HashMap<>();
        payload.put("route", route);
        payload.put("slippage", 0.5);
        payload.put("destination", "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb");
        
        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 {
    Success      bool                   `json:"success"`
    RouteSwapType int                   `json:"routeSwapType"`
    InputToken   map[string]interface{} `json:"inputToken"`
    InputAmount  string                 `json:"inputAmount"`
    OutputToken  map[string]interface{} `json:"outputToken"`
    OutputAmount string                 `json:"outputAmount"`
    Route        []interface{}          `json:"route"`
}

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

func main() {
    url := "https://api.fibrous.finance/{network}/v2/calldata"
    
    route := Route{
        Success:      true,
        RouteSwapType: 0,
        InputToken: map[string]interface{}{
            "name":     "Wrapped Ether",
            "address":  "0x4200000000000000000000000000000000000006",
            "decimals": 18,
            "price":    2949.717076112869,
        },
        InputAmount: "1000000000000000000",
        OutputToken: map[string]interface{}{
            "name":     "USD Coin",
            "address":  "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
            "decimals": 6,
            "price":    0.999597487941284,
        },
        OutputAmount: "2951108576",
        Route:        []interface{}{},
    }
    
    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))
}