tester

go.mod

module main

go 1.14

replace github.com/thrasher-corp/gocryptotrader => ./../../gocryptotrader

require github.com/thrasher-corp/gocryptotrader v0.0.0-00010101000000-000000000000

main.go

package main

import (
	"context"
	"fmt"
	"io"
	"os"
	"os/signal"
	"strconv"
	"strings"
	"syscall"
	"time"

	"github.com/thrasher-corp/gocryptotrader/currency"
	"github.com/thrasher-corp/gocryptotrader/engine"
	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
	"github.com/thrasher-corp/gocryptotrader/exchanges/binance"
	"github.com/thrasher-corp/gocryptotrader/exchanges/orderbook"
)

func main() {
	s := make(chan os.Signal, 1)
	signal.Notify(s, syscall.SIGINT, syscall.SIGTERM)
	defer signal.Stop(s)
	ctx, shutdown := context.WithCancel(context.Background())
	go func() {
		<-s
		shutdown()
	}()

	if err := run(ctx); err != nil {
		mustFPrintf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
}

func run(ctx context.Context) error {
	eng, err := engine.New()
	if err != nil {
		return fmt.Errorf("failed to create GoCrypto engine %w", err)
	}
	eng.Settings.DataDir = "data"
	eng.Settings.EnableDispatcher = true
	eng.Settings.EnableExchangeSyncManager = true
	eng.Settings.EnableOrderbookSyncing = true
	eng.Settings.SyncContinuously = true
	eng.Settings.SyncWorkers = 4
	eng.Settings.EnableExchangeHTTPRateLimiter = true

	binancePairs := currency.NewPairsFromStrings([]string{
		"BTC-USDT",
	})
	for _, e := range eng.Config.Exchanges {
		if e.Name == "Binance" {
			e.CurrencyPairs.Pairs[asset.Spot].Enabled = binancePairs
			eng.Config.UpdateExchangeConfig(&e)
		}
	}

	engine.Bot = eng
	if err := eng.Start(); err != nil {
		return fmt.Errorf("failed to start GoCrypto engine %w", err)
	}
	for {
		time.Sleep(100 * time.Millisecond)
		s := engine.GetSubsystemsStatus()
		if s["dispatch"] && s["exchange_syncer"] {
			break
		}
	}

	exch := engine.GetExchangeByName("binance").(*binance.Binance)

	for {
		if !exch.Websocket.IsEnabled() {
			return fmt.Errorf("websocket is not enabled for Binance")
		}

		if exch.Websocket.IsConnecting() {
			time.Sleep(100 * time.Millisecond)
			continue
		}

		if !exch.Websocket.IsConnected() {
			return fmt.Errorf("websocket is not connected for Binance")
		}

		break
	}

	cp := currency.NewPairFromString("BTC-USDT")
	p, err := orderbook.SubscribeOrderbook(exch.GetName(), cp, asset.Spot)
	if err != nil {
		return fmt.Errorf("failed to subscribe to orderbooks for exchange %s: %w", exch.Name, err)
	}

WatchBooks:
	for {
		select {
		case <-ctx.Done():
			break WatchBooks
		case v := <-p.C:
			b := (*v.(*interface{})).(orderbook.Base)
			if b.Asks[0].Price > b.Bids[0].Price {
				fmt.Printf("Orderbook %s: In Sync\n", b.Pair)
				continue
			}

			fmt.Printf("Orderbook %s: Out of Sync\n", b.Pair)
			asks := strings.Split(stringifyItems(b.Asks), "\n")
			for left, right := 0, len(asks)-1; left < right; left, right = left+1, right-1 {
				asks[left], asks[right] = asks[right], asks[left]
			}
			fmt.Println(strings.Join(asks, "\n"))
			fmt.Println("---------------------------")
			fmt.Println(stringifyItems(b.Bids))
		}
	}

	return nil
}

func stringifyItems(items []orderbook.Item) string {
	var b strings.Builder
	max := 10
	if l := len(items); l < max {
		max = l
	}
	for i, item := range items[:max] {
		b.WriteString(strconv.FormatInt(int64(i), 10))
		b.WriteString("| ")
		b.WriteString(strconv.FormatFloat(item.Amount, 'f', 8, 64))
		b.WriteString(" @ ")
		b.WriteString(strconv.FormatFloat(item.Price, 'f', 8, 64))
		b.WriteRune('\n')
	}
	return b.String()
}

func mustFPrintf(w io.Writer, format string, a ...interface{}) {
	if _, err := fmt.Fprintf(w, format, a...); err != nil {
		panic(err)
	}
}