test binance roundtrip

main.go

package main

import (
	"context"
	"encoding/json"
	"log"
	"os"
	"sort"
	"time"

	"github.com/adshao/go-binance/v2"
	"github.com/adshao/go-binance/v2/futures"
)

const (
	binanceAPIKey    = ""
	binanceSecretKey = ""
)

var (
	result []int64
)

func main() {
	binanceClient := binance.NewClient(binanceAPIKey, binanceSecretKey)
	binanceFutureClient := futures.NewClient(binanceAPIKey, binanceSecretKey)
	for i := 0; i < 10; i++ {
		startTime := time.Now().UnixMilli()
		order, err := binanceClient.NewCreateOrderService().
			Symbol("KNCUSDT").
			Price("0.5").
			Quantity("100").
			Side(binance.SideTypeBuy).
			Type(binance.OrderTypeLimit).
			TimeInForce(binance.TimeInForceTypeGTC).
			Do(context.Background())
		if err != nil {
			log.Printf("there is something wrong creating new order: %s", err)
		}
		endTime := time.Now().UnixMilli()
		result = append(result, endTime-startTime)

		startCancelTime := time.Now().UnixMilli()
		_, err = binanceClient.NewCancelOrderService().
			Symbol("KNCUSDT").
			OrderID(order.OrderID).
			Do(context.Background())
		if err != nil {
			log.Printf("there is error cancel order: %s", err)
		}
		endCancelTime := time.Now().UnixMilli()
		result = append(result, endCancelTime-startCancelTime)

		start := time.Now().UnixMilli()
		forder, err := binanceFutureClient.NewCreateOrderService().
			Symbol("KNCUSDT").
			Price("0.5").
			Quantity("100").
			Side(futures.SideTypeBuy).
			Type(futures.OrderTypeLimit).
			TimeInForce(futures.TimeInForceTypeGTC).
			Do(context.Background())
		if err != nil {
			log.Println(err)
		}
		end := time.Now().UnixMilli()
		result = append(result, end-start)

		startCancel := time.Now().UnixMilli()
		_, err = binanceFutureClient.NewCancelOrderService().
			Symbol("KNCUSDT").
			OrderID(forder.OrderID).
			Do(context.Background())
		if err != nil {
			log.Println(err)
		}
		endCancel := time.Now().UnixMilli()
		result = append(result, endCancel-startCancel)
	}
	exportResult(result)
}

// Result ...
type Result struct {
	Min     int64 `json:"min"`
	Max     int64 `json:"max"`
	Average int64 `json:"average"`
	Median  int64 `json:"median"`
}

// Result ...

func exportResult(result []int64) {
	// log to custom file
	LOG_FILE := "./binance.json"
	// open log file
	logFile, err := os.OpenFile(LOG_FILE, os.O_APPEND|os.O_RDWR|os.O_CREATE, 0644)
	if err != nil {
		log.Panic(err)
	}
	defer logFile.Close()

	// Set log out put and enjoy :)
	log.SetOutput(logFile)
	log.SetFlags(0)

	sort.Slice(result, func(i, j int) bool {
		return result[i] < result[j]
	})

	sum := int64(0)
	for _, e := range result {
		sum += e
	}

	r, err := json.Marshal(Result{
		Min:     result[0],
		Max:     result[len(result)-1],
		Average: sum / int64(len(result)),
		Median:  (result[(len(result)-1)/2] + result[(len(result)+1)/2]) / 2,
	})
	if err != nil {
		log.Println(err)
	}
	log.Printf("%s", r)
}