service

package
v0.0.0-...-a7cd9b2 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 10, 2021 License: MIT Imports: 28 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source
var ErrExchangeRewardServiceNotImplemented = errors.New("exchange does not implement ExchangeRewardService interface")
View Source
var ErrNotImplemented = errors.New("not implemented")
View Source
var ErrPersistenceNotExists = errors.New("persistent data does not exists")
View Source
var ErrTradeNotFound = errors.New("trade not found")

Functions

func NewDefaultTotpKey

func NewDefaultTotpKey() (*otp.Key, error)

func ReformatMysqlDSN

func ReformatMysqlDSN(dsn string) (string, error)

Types

type AggOrder

type AggOrder struct {
	types.Order
	AveragePrice *float64 `json:"averagePrice" db:"average_price"`
}

type BacktestService

type BacktestService struct {
	DB *sqlx.DB
}

func (*BacktestService) Insert

func (s *BacktestService) Insert(kline types.KLine) error

func (*BacktestService) QueryKLinesBackward

func (s *BacktestService) QueryKLinesBackward(exchange types.ExchangeName, symbol string, interval types.Interval, endTime time.Time) ([]types.KLine, error)

func (*BacktestService) QueryKLinesCh

func (s *BacktestService) QueryKLinesCh(since, until time.Time, exchange types.Exchange, symbols []string, intervals []types.Interval) (chan types.KLine, chan error)

func (*BacktestService) QueryKLinesForward

func (s *BacktestService) QueryKLinesForward(exchange types.ExchangeName, symbol string, interval types.Interval, startTime time.Time) ([]types.KLine, error)

func (*BacktestService) QueryLast

func (s *BacktestService) QueryLast(ex types.ExchangeName, symbol string, interval types.Interval) (*types.KLine, error)

QueryLast queries the last order from the database

func (*BacktestService) Sync

func (s *BacktestService) Sync(ctx context.Context, exchange types.Exchange, symbol string, startTime time.Time) error

func (*BacktestService) SyncKLineByInterval

func (s *BacktestService) SyncKLineByInterval(ctx context.Context, exchange types.Exchange, symbol string, interval types.Interval, startTime, endTime time.Time) error

type CurrencyPositionMap

type CurrencyPositionMap map[string]fixedpoint.Value

type DatabaseService

type DatabaseService struct {
	Driver string
	DSN    string
	DB     *sqlx.DB
}

func NewDatabaseService

func NewDatabaseService(driver, dsn string) *DatabaseService

func (*DatabaseService) Close

func (s *DatabaseService) Close() error

func (*DatabaseService) Connect

func (s *DatabaseService) Connect() error

func (*DatabaseService) Upgrade

func (s *DatabaseService) Upgrade(ctx context.Context) error

type DepositService

type DepositService struct {
	DB *sqlx.DB
}

func (*DepositService) Insert

func (s *DepositService) Insert(deposit types.Deposit) error

func (*DepositService) Query

func (s *DepositService) Query(exchangeName types.ExchangeName) ([]types.Deposit, error)

func (*DepositService) QueryLast

func (s *DepositService) QueryLast(ex types.ExchangeName, limit int) ([]types.Deposit, error)

func (*DepositService) Sync

func (s *DepositService) Sync(ctx context.Context, ex types.Exchange) error

Sync syncs the withdraw records into db

type JsonPersistenceConfig

type JsonPersistenceConfig struct {
	Directory string `json:"directory"`
}

type JsonPersistenceService

type JsonPersistenceService struct {
	Directory string
}

func (*JsonPersistenceService) NewStore

func (s *JsonPersistenceService) NewStore(id string, subIDs ...string) Store

type JsonStore

type JsonStore struct {
	ID        string
	Directory string
}

func (JsonStore) Load

func (store JsonStore) Load(val interface{}) error

func (JsonStore) Reset

func (store JsonStore) Reset() error

func (JsonStore) Save

func (store JsonStore) Save(val interface{}) error

type MemoryService

type MemoryService struct {
	Slots map[string]interface{}
}

func NewMemoryService

func NewMemoryService() *MemoryService

func (*MemoryService) NewStore

func (s *MemoryService) NewStore(id string, subIDs ...string) Store

type MemoryStore

type MemoryStore struct {
	Key string
	// contains filtered or unexported fields
}

func (*MemoryStore) Load

func (store *MemoryStore) Load(val interface{}) error

func (*MemoryStore) Reset

func (store *MemoryStore) Reset() error

func (*MemoryStore) Save

func (store *MemoryStore) Save(val interface{}) error

type OrderService

type OrderService struct {
	DB *sqlx.DB
}

func (*OrderService) Insert

func (s *OrderService) Insert(order types.Order) (err error)

func (*OrderService) Query

func (s *OrderService) Query(options QueryOrdersOptions) ([]AggOrder, error)

func (*OrderService) QueryLast

func (s *OrderService) QueryLast(ex types.ExchangeName, symbol string, isMargin, isIsolated bool, limit int) ([]types.Order, error)

QueryLast queries the last order from the database

func (*OrderService) Sync

func (s *OrderService) Sync(ctx context.Context, exchange types.Exchange, symbol string, startTime time.Time) error

type PersistenceService

type PersistenceService interface {
	NewStore(id string, subIDs ...string) Store
}

type PersistenceServiceFacade

type PersistenceServiceFacade struct {
	Redis  *RedisPersistenceService
	Json   *JsonPersistenceService
	Memory *MemoryService
}

func (*PersistenceServiceFacade) Get

Get returns the preferred persistence service by fallbacks Redis will be preferred at the first position.

type QueryOrdersOptions

type QueryOrdersOptions struct {
	Exchange types.ExchangeName
	Symbol   string
	LastGID  int64
	Ordering string
}

type QueryTradesOptions

type QueryTradesOptions struct {
	Exchange types.ExchangeName
	Symbol   string
	LastGID  int64

	// ASC or DESC
	Ordering string
	Limit    int
}

type RedisPersistenceConfig

type RedisPersistenceConfig struct {
	Host     string `json:"host" env:"REDIS_HOST"`
	Port     string `json:"port" env:"REDIS_PORT"`
	Password string `json:"password" env:"REDIS_PASSWORD"`
	DB       int    `json:"db" env:"REDIS_DB"`
}

type RedisPersistenceService

type RedisPersistenceService struct {
	// contains filtered or unexported fields
}

func NewRedisPersistenceService

func NewRedisPersistenceService(config *RedisPersistenceConfig) *RedisPersistenceService

func (*RedisPersistenceService) NewStore

func (s *RedisPersistenceService) NewStore(id string, subIDs ...string) Store

type RedisStore

type RedisStore struct {
	ID string
	// contains filtered or unexported fields
}

func (*RedisStore) Load

func (store *RedisStore) Load(val interface{}) error

func (*RedisStore) Reset

func (store *RedisStore) Reset() error

func (*RedisStore) Save

func (store *RedisStore) Save(val interface{}) error

type RewardService

type RewardService struct {
	DB *sqlx.DB
}

RewardService collects the reward records from the exchange, currently it's only available for MAX exchange. TODO: add summary query for calculating the reward amounts CREATE VIEW reward_summary_by_years AS SELECT YEAR(created_at) as year, reward_type, currency, SUM(quantity) FROM rewards WHERE reward_type != 'airdrop' GROUP BY YEAR(created_at), reward_type, currency ORDER BY year DESC;

func (*RewardService) AggregateUnspentCurrencyPosition

func (s *RewardService) AggregateUnspentCurrencyPosition(ctx context.Context, ex types.ExchangeName, since time.Time) (CurrencyPositionMap, error)

func (*RewardService) Insert

func (s *RewardService) Insert(reward types.Reward) error

func (*RewardService) MarkAsSpent

func (s *RewardService) MarkAsSpent(ctx context.Context, uuid string) error

func (*RewardService) MarkCurrencyAsSpent

func (s *RewardService) MarkCurrencyAsSpent(ctx context.Context, currency string) error

func (*RewardService) QueryLast

func (s *RewardService) QueryLast(ex types.ExchangeName, limit int) ([]types.Reward, error)

func (*RewardService) QueryUnspent

func (s *RewardService) QueryUnspent(ctx context.Context, ex types.ExchangeName, rewardTypes ...types.RewardType) ([]types.Reward, error)

func (*RewardService) QueryUnspentSince

func (s *RewardService) QueryUnspentSince(ctx context.Context, ex types.ExchangeName, since time.Time, rewardTypes ...types.RewardType) ([]types.Reward, error)

func (*RewardService) Sync

func (s *RewardService) Sync(ctx context.Context, exchange types.Exchange) error

type Store

type Store interface {
	Load(val interface{}) error
	Save(val interface{}) error
	Reset() error
}

type SyncService

type SyncService struct {
	TradeService    *TradeService
	OrderService    *OrderService
	RewardService   *RewardService
	WithdrawService *WithdrawService
	DepositService  *DepositService
}

func (*SyncService) SyncSessionSymbols

func (s *SyncService) SyncSessionSymbols(ctx context.Context, exchange types.Exchange, startTime time.Time, symbols ...string) error

SyncSessionSymbols syncs the trades from the given exchange session

type TradeService

type TradeService struct {
	DB *sqlx.DB
}

func NewTradeService

func NewTradeService(db *sqlx.DB) *TradeService

func (*TradeService) Insert

func (s *TradeService) Insert(trade types.Trade) error

func (*TradeService) Load

func (s *TradeService) Load(ctx context.Context, id int64) (*types.Trade, error)

func (*TradeService) Mark

func (s *TradeService) Mark(ctx context.Context, id int64, strategyID string) error

func (*TradeService) Query

func (s *TradeService) Query(options QueryTradesOptions) ([]types.Trade, error)

func (*TradeService) QueryForTradingFeeCurrency

func (s *TradeService) QueryForTradingFeeCurrency(ex types.ExchangeName, symbol string, feeCurrency string) ([]types.Trade, error)

func (*TradeService) QueryLast

func (s *TradeService) QueryLast(ex types.ExchangeName, symbol string, isMargin, isIsolated bool, limit int) ([]types.Trade, error)

QueryLast queries the last trade from the database

func (*TradeService) QueryTradingVolume

func (s *TradeService) QueryTradingVolume(startTime time.Time, options TradingVolumeQueryOptions) ([]TradingVolume, error)

func (*TradeService) Sync

func (s *TradeService) Sync(ctx context.Context, exchange types.Exchange, symbol string) error

func (*TradeService) UpdatePnL

func (s *TradeService) UpdatePnL(ctx context.Context, id int64, pnl float64) error

type TradingVolume

type TradingVolume struct {
	Year        int       `db:"year" json:"year"`
	Month       int       `db:"month" json:"month,omitempty"`
	Day         int       `db:"day" json:"day,omitempty"`
	Time        time.Time `json:"time,omitempty"`
	Exchange    string    `db:"exchange" json:"exchange,omitempty"`
	Symbol      string    `db:"symbol" json:"symbol,omitempty"`
	QuoteVolume float64   `db:"quote_volume" json:"quoteVolume"`
}

type TradingVolumeQueryOptions

type TradingVolumeQueryOptions struct {
	GroupByPeriod string
	SegmentBy     string
}

type WebsocketClientBase

type WebsocketClientBase struct {
	// contains filtered or unexported fields
}

func NewWebsocketClientBase

func NewWebsocketClientBase(baseURL string, reconnectDuration time.Duration) *WebsocketClientBase

func (*WebsocketClientBase) Conn

func (s *WebsocketClientBase) Conn() *websocket.Conn

func (*WebsocketClientBase) Connect

func (s *WebsocketClientBase) Connect(ctx context.Context) error

func (*WebsocketClientBase) EmitConnected

func (s *WebsocketClientBase) EmitConnected(conn *websocket.Conn)

func (*WebsocketClientBase) EmitDisconnected

func (s *WebsocketClientBase) EmitDisconnected(conn *websocket.Conn)

func (*WebsocketClientBase) EmitError

func (s *WebsocketClientBase) EmitError(err error)

func (*WebsocketClientBase) EmitMessage

func (s *WebsocketClientBase) EmitMessage(message []byte)

func (*WebsocketClientBase) Listen

func (s *WebsocketClientBase) Listen(ctx context.Context)

func (*WebsocketClientBase) OnConnected

func (s *WebsocketClientBase) OnConnected(cb func(conn *websocket.Conn))

func (*WebsocketClientBase) OnDisconnected

func (s *WebsocketClientBase) OnDisconnected(cb func(conn *websocket.Conn))

func (*WebsocketClientBase) OnError

func (s *WebsocketClientBase) OnError(cb func(err error))

func (*WebsocketClientBase) OnMessage

func (s *WebsocketClientBase) OnMessage(cb func(message []byte))

func (*WebsocketClientBase) Reconnect

func (s *WebsocketClientBase) Reconnect()

type WithdrawService

type WithdrawService struct {
	DB *sqlx.DB
}

func (*WithdrawService) Insert

func (s *WithdrawService) Insert(withdrawal types.Withdraw) error

func (*WithdrawService) Query

func (s *WithdrawService) Query(exchangeName types.ExchangeName) ([]types.Withdraw, error)

func (*WithdrawService) QueryLast

func (s *WithdrawService) QueryLast(ex types.ExchangeName, limit int) ([]types.Withdraw, error)

func (*WithdrawService) Sync

Sync syncs the withdraw records into db

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL