marketp: add marketcap strategy

This commit is contained in:
なるみ 2022-06-16 01:46:33 +08:00
parent df8918350e
commit 5799497a09
6 changed files with 311 additions and 2 deletions

20
config/marketcap.yaml Normal file
View File

@ -0,0 +1,20 @@
---
notifications:
slack:
defaultChannel: "bbgo"
errorChannel: "bbgo-error"
exchangeStrategies:
- on: max
marketcap:
interval: 1m
baseCurrency: TWD
baseWeight: 2%
targetCurrencies:
- BTC
- ETH
- MATIC
threshold: 2%
# max amount to buy or sell per order
maxAmount: 1_000
dryRun: true

View File

@ -15,6 +15,7 @@ import (
_ "github.com/c9s/bbgo/pkg/strategy/funding"
_ "github.com/c9s/bbgo/pkg/strategy/grid"
_ "github.com/c9s/bbgo/pkg/strategy/kline"
_ "github.com/c9s/bbgo/pkg/strategy/marketcap"
_ "github.com/c9s/bbgo/pkg/strategy/pivotshort"
_ "github.com/c9s/bbgo/pkg/strategy/pricealert"
_ "github.com/c9s/bbgo/pkg/strategy/pricedrop"

View File

@ -99,6 +99,7 @@ func Test_ValueMap_Sum(t *testing.T) {
func Test_ValueMap_Normalize(t *testing.T) {
a := NewFromFloat(3.0)
b := NewFromFloat(4.0)
c := a.Add(b)
m := ValueMap{
"A": a,
@ -106,8 +107,8 @@ func Test_ValueMap_Normalize(t *testing.T) {
}
n := ValueMap{
"A": a.Div(a.Add(b)),
"B": b.Div(a.Add(b)),
"A": a.Div(c),
"B": b.Div(c),
}
assert.True(t, m.Normalize().Eq(n))

View File

@ -0,0 +1,244 @@
package marketcap
import (
"context"
"fmt"
"os"
"github.com/sirupsen/logrus"
"github.com/c9s/bbgo/pkg/bbgo"
"github.com/c9s/bbgo/pkg/datasource/glassnode"
"github.com/c9s/bbgo/pkg/fixedpoint"
"github.com/c9s/bbgo/pkg/types"
)
const ID = "marketcap"
var log = logrus.WithField("strategy", ID)
func init() {
bbgo.RegisterStrategy(ID, &Strategy{})
}
type Strategy struct {
Notifiability *bbgo.Notifiability
glassnode *glassnode.DataSource
Interval types.Interval `json:"interval"`
BaseCurrency string `json:"baseCurrency"`
BaseWeight fixedpoint.Value `json:"baseWeight"`
TargetCurrencies []string `json:"targetCurrencies"`
Threshold fixedpoint.Value `json:"threshold"`
Verbose bool `json:"verbose"`
DryRun bool `json:"dryRun"`
// max amount to buy or sell per order
MaxAmount fixedpoint.Value `json:"maxAmount"`
activeOrderBook *bbgo.ActiveOrderBook
}
func (s *Strategy) Initialize() error {
apiKey := os.Getenv("GLASSNODE_API_KEY")
s.glassnode = glassnode.New(apiKey)
return nil
}
func (s *Strategy) ID() string {
return ID
}
func (s *Strategy) Validate() error {
if len(s.TargetCurrencies) == 0 {
return fmt.Errorf("taretCurrencies should not be empty")
}
for _, c := range s.TargetCurrencies {
if c == s.BaseCurrency {
return fmt.Errorf("targetCurrencies contain baseCurrency")
}
}
if s.Threshold.Sign() < 0 {
return fmt.Errorf("threshold should not less than 0")
}
if s.MaxAmount.Sign() < 0 {
return fmt.Errorf("maxAmount shoud not less than 0")
}
return nil
}
func (s *Strategy) Subscribe(session *bbgo.ExchangeSession) {
for _, symbol := range s.symbols() {
session.Subscribe(types.KLineChannel, symbol, types.SubscribeOptions{Interval: s.Interval})
}
}
func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) error {
s.activeOrderBook = bbgo.NewActiveOrderBook("")
s.activeOrderBook.BindStream(session.UserDataStream)
session.MarketDataStream.OnKLineClosed(func(kline types.KLine) {
s.rebalance(ctx, orderExecutor, session)
})
return nil
}
func (s *Strategy) rebalance(ctx context.Context, orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) {
if err := orderExecutor.CancelOrders(ctx, s.activeOrderBook.Orders()...); err != nil {
log.WithError(err).Error("failed to cancel orders")
}
submitOrders := s.generateSubmitOrders(ctx, session)
for _, submitOrder := range submitOrders {
log.Infof("generated submit order: %s", submitOrder.String())
}
if s.DryRun {
return
}
createdOrders, err := orderExecutor.SubmitOrders(ctx, submitOrders...)
if err != nil {
log.WithError(err).Error("failed to submit orders")
return
}
s.activeOrderBook.Add(createdOrders...)
}
func (s *Strategy) generateSubmitOrders(ctx context.Context, session *bbgo.ExchangeSession) (submitOrders []types.SubmitOrder) {
targetWeights := s.getTargetWeights(ctx)
prices := s.prices(ctx, session)
marketValues := prices.Mul(s.quantities(session))
currentWeights := marketValues.Normalize()
for currency, targetWeight := range targetWeights {
symbol := currency + s.BaseCurrency
currentWeight := currentWeights[currency]
currentPrice := prices[currency]
log.Infof("%s price: %v, current weight: %v, target weight: %v",
symbol,
currentPrice,
currentWeight,
targetWeight)
// calculate the difference between current weight and target weight
// if the difference is less than threshold, then we will not create the order
weightDifference := targetWeight.Sub(currentWeight)
if weightDifference.Abs().Compare(s.Threshold) < 0 {
log.Infof("%s weight distance |%v - %v| = |%v| less than the threshold: %v",
symbol,
currentWeight,
targetWeight,
weightDifference,
s.Threshold)
continue
}
quantity := weightDifference.Mul(marketValues.Sum()).Div(currentPrice)
side := types.SideTypeBuy
if quantity.Sign() < 0 {
side = types.SideTypeSell
quantity = quantity.Abs()
}
if s.MaxAmount.Sign() > 0 {
quantity = bbgo.AdjustQuantityByMaxAmount(quantity, currentPrice, s.MaxAmount)
log.Infof("adjust the quantity %v (%s %s @ %v) by max amount %v",
quantity,
symbol,
side.String(),
currentPrice,
s.MaxAmount)
}
order := types.SubmitOrder{
Symbol: symbol,
Side: side,
Type: types.OrderTypeLimit,
Quantity: quantity,
Price: currentPrice,
}
submitOrders = append(submitOrders, order)
}
return submitOrders
}
func (s *Strategy) getTargetWeights(ctx context.Context) fixedpoint.ValueMap {
m := FloatMap{}
// get market cap values
for _, currency := range s.TargetCurrencies {
marketCap, err := s.glassnode.QueryMarketCapInUSD(ctx, currency)
if err != nil {
log.WithError(err).Error("failed to query market cap")
return nil
}
m[currency] = marketCap
}
// normalize
m = m.Normalize()
// rescale by 1 - baseWeight
m = m.MulScalar(1.0 - s.BaseWeight.Float64())
// append base weight
m[s.BaseCurrency] = s.BaseWeight.Float64()
// convert to fixedpoint.ValueMap
targetWeights := fixedpoint.ValueMap{}
for currency, weight := range m {
targetWeights[currency] = fixedpoint.NewFromFloat(weight)
}
return targetWeights
}
func (s *Strategy) prices(ctx context.Context, session *bbgo.ExchangeSession) fixedpoint.ValueMap {
tickers, err := session.Exchange.QueryTickers(ctx, s.symbols()...)
if err != nil {
log.WithError(err).Error("failed to query tickers")
return nil
}
prices := fixedpoint.ValueMap{}
for _, currency := range s.TargetCurrencies {
prices[currency] = tickers[currency+s.BaseCurrency].Last
}
// append base currency price
prices[s.BaseCurrency] = fixedpoint.One
return prices
}
func (s *Strategy) quantities(session *bbgo.ExchangeSession) fixedpoint.ValueMap {
balances := session.Account.Balances()
quantities := fixedpoint.ValueMap{}
for _, currency := range s.currencies() {
quantities[currency] = balances[currency].Total()
}
return quantities
}
func (s *Strategy) symbols() (symbols []string) {
for _, currency := range s.TargetCurrencies {
symbols = append(symbols, currency+s.BaseCurrency)
}
return symbols
}
func (s *Strategy) currencies() (currencies []string) {
currencies = append(currencies, s.TargetCurrencies...)
currencies = append(currencies, s.BaseCurrency)
return currencies
}

View File

@ -0,0 +1,42 @@
package marketcap
type FloatMap map[string]float64
func (m FloatMap) Sum() float64 {
sum := 0.0
for _, v := range m {
sum += v
}
return sum
}
func (m FloatMap) MulScalar(x float64) FloatMap {
o := FloatMap{}
for k, v := range m {
o[k] = v * x
}
return o
}
func (m FloatMap) DivScalar(x float64) FloatMap {
o := FloatMap{}
for k, v := range m {
o[k] = v / x
}
return o
}
func (m FloatMap) Normalize() FloatMap {
sum := m.Sum()
if sum == 0 {
panic("zero sum")
}
o := FloatMap{}
for k, v := range m {
o[k] = v / sum
}
return o
}

View File

@ -88,6 +88,7 @@ func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, se
return nil
}
func (s *Strategy) rebalance(ctx context.Context, orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) {
// cancel active orders before rebalance
if err := session.Exchange.CancelOrders(ctx, s.activeOrderBook.Orders()...); err != nil {