Mini token (bnb-chain#130)

* add pending match flag

* support mini token feature
Co-authored-by: George <[email protected]>

CHANGELOG.md

@@ -1,4 +1,8 @@
 # Changelog
+## 1.2.3
+CHAIN UPGRADE
+* [\#110](https://github.com/binance-chain/go-sdk/pull/110) [RPC] [API] Add pending_match flag
+* [\#130](https://github.com/binance-chain/go-sdk/pull/130) [RPC] [API] Support Mini Token
 ## 1.2.2
 * [\#106](https://github.com/binance-chain/go-sdk/pull/106) [RPC] fix nil point error in getBalance rpc call
 * [\#103](https://github.com/binance-chain/go-sdk/pull/103) [RPC] change the default timeout of RPC client as 5 seconds

client/query/get_mini_closed_orders.go

@@ -0,0 +1,31 @@
+package query
+
+import (
+	"encoding/json"
+
+	"github.com/binance-chain/go-sdk/common"
+	"github.com/binance-chain/go-sdk/common/types"
+)
+
+// GetMiniClosedOrders returns array of mini closed orders
+func (c *client) GetMiniClosedOrders(query *types.ClosedOrdersQuery) (*types.CloseOrders, error) {
+	err := query.Check()
+	if err != nil {
+		return nil, err
+	}
+	qp, err := common.QueryParamToMap(*query)
+	if err != nil {
+		return nil, err
+	}
+	resp, _, err := c.baseClient.Get("/mini/orders/closed", qp)
+	if err != nil {
+		return nil, err
+	}
+
+	var orders types.CloseOrders
+	if err := json.Unmarshal(resp, &orders); err != nil {
+		return nil, err
+	}
+
+	return &orders, nil
+}

client/query/get_mini_kline.go

@@ -0,0 +1,60 @@
+package query
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/binance-chain/go-sdk/common"
+	"github.com/binance-chain/go-sdk/common/types"
+)
+
+// GetMiniKlines returns mini token klines
+func (c *client) GetMiniKlines(query *types.KlineQuery) ([]types.Kline, error) {
+	err := query.Check()
+	if err != nil {
+		return nil, err
+	}
+	qp, err := common.QueryParamToMap(*query)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, _, err := c.baseClient.Get("/mini/klines", qp)
+	if err != nil {
+		return nil, err
+	}
+
+	iklines := [][]interface{}{}
+	if err := json.Unmarshal(resp, &iklines); err != nil {
+		return nil, err
+	}
+	klines := make([]types.Kline, len(iklines))
+	// Todo
+	for index, ikline := range iklines {
+		kl := types.Kline{}
+		imap := make(map[string]interface{}, 9)
+		if len(ikline) >= 9 {
+			imap["openTime"] = ikline[0]
+			imap["open"] = ikline[1]
+			imap["high"] = ikline[2]
+			imap["low"] = ikline[3]
+			imap["close"] = ikline[4]
+			imap["volume"] = ikline[5]
+			imap["closeTime"] = ikline[6]
+			imap["quoteAssetVolume"] = ikline[7]
+			imap["NumberOfTrades"] = ikline[8]
+		} else {
+			return nil, fmt.Errorf("Receive kline scheme is unexpected ")
+		}
+		bz, err := json.Marshal(imap)
+		if err != nil {
+			return nil, err
+		}
+		err = json.Unmarshal(bz, &kl)
+		if err != nil {
+			return nil, err
+		}
+		klines[index] = kl
+	}
+	return klines, nil
+}

client/query/get_mini_markets.go

@@ -0,0 +1,30 @@
+package query
+
+import (
+	"encoding/json"
+
+	"github.com/binance-chain/go-sdk/common"
+	"github.com/binance-chain/go-sdk/common/types"
+)
+
+// GetMiniMarkets returns list of trading pairs
+func (c *client) GetMiniMarkets(query *types.MarketsQuery) ([]types.TradingPair, error) {
+	err := query.Check()
+	if err != nil {
+		return nil, err
+	}
+	qp, err := common.QueryParamToMap(*query)
+	if err != nil {
+		return nil, err
+	}
+	resp, _, err := c.baseClient.Get("/mini/markets", qp)
+	if err != nil {
+		return nil, err
+	}
+	var listOfPairs []types.TradingPair
+	if err := json.Unmarshal(resp, &listOfPairs); err != nil {
+		return nil, err
+	}
+
+	return listOfPairs, nil
+}

client/query/get_mini_order.go

@@ -0,0 +1,26 @@
+package query
+
+import (
+	"encoding/json"
+	"github.com/binance-chain/go-sdk/common/types"
+)
+
+// GetMiniOrder returns transaction details
+func (c *client) GetMiniOrder(orderID string) (*types.Order, error) {
+	if orderID == "" {
+		return nil, types.OrderIdMissingError
+	}
+
+	qp := map[string]string{}
+	resp, _, err := c.baseClient.Get("/mini/orders/"+orderID, qp)
+	if err != nil {
+		return nil, err
+	}
+
+	var order types.Order
+	if err := json.Unmarshal(resp, &order); err != nil {
+		return nil, err
+	}
+
+	return &order, nil
+}

client/query/get_mini_orders_open.go

@@ -0,0 +1,32 @@
+package query
+
+import (
+	"encoding/json"
+
+	"github.com/binance-chain/go-sdk/common"
+	"github.com/binance-chain/go-sdk/common/types"
+)
+
+// GetMiniOpenOrders returns array of mini open orders
+func (c *client) GetMiniOpenOrders(query *types.OpenOrdersQuery) (*types.OpenOrders, error) {
+	err := query.Check()
+	if err != nil {
+		return nil, err
+	}
+	qp, err := common.QueryParamToMap(*query)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, _, err := c.baseClient.Get("/mini/orders/open", qp)
+	if err != nil {
+		return nil, err
+	}
+
+	var openOrders types.OpenOrders
+	if err := json.Unmarshal(resp, &openOrders); err != nil {
+		return nil, err
+	}
+
+	return &openOrders, nil
+}

client/query/get_mini_ticker24h.go

@@ -0,0 +1,28 @@
+package query
+
+import (
+	"encoding/json"
+	"github.com/binance-chain/go-sdk/common/types"
+
+	"github.com/binance-chain/go-sdk/common"
+)
+
+// GetMiniTicker24h returns mini token ticker 24h
+func (c *client) GetMiniTicker24h(query *types.Ticker24hQuery) ([]types.Ticker24h, error) {
+	qp, err := common.QueryParamToMap(query)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, _, err := c.baseClient.Get("/mini/ticker/24hr", qp)
+	if err != nil {
+		return nil, err
+	}
+
+	tickers := []types.Ticker24h{}
+	if err := json.Unmarshal(resp, &tickers); err != nil {
+		return nil, err
+	}
+
+	return tickers, nil
+}

client/query/get_mini_tokens.go

@@ -0,0 +1,27 @@
+package query
+
+import (
+	"encoding/json"
+
+	"github.com/binance-chain/go-sdk/common"
+	"github.com/binance-chain/go-sdk/common/types"
+)
+
+// GetMiniTokens returns list of mini tokens
+func (c *client) GetMiniTokens(query *types.TokensQuery) ([]types.MiniToken, error) {
+	qp, err := common.QueryParamToMap(*query)
+	if err != nil {
+		return nil, err
+	}
+	resp, _, err := c.baseClient.Get("/mini/tokens", qp)
+	if err != nil {
+		return nil, err
+	}
+
+	var tokens []types.MiniToken
+	if err := json.Unmarshal(resp, &tokens); err != nil {
+		return nil, err
+	}
+
+	return tokens, nil
+}

client/query/get_mini_trades.go

@@ -0,0 +1,32 @@
+package query
+
+import (
+	"encoding/json"
+
+	"github.com/binance-chain/go-sdk/common"
+	"github.com/binance-chain/go-sdk/common/types"
+)
+
+// GetMiniTrades returns trade details
+func (c *client) GetMiniTrades(query *types.TradesQuery) (*types.Trades, error) {
+	err := query.Check()
+	if err != nil {
+		return nil, err
+	}
+	qp, err := common.QueryParamToMap(*query)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, _, err := c.baseClient.Get("/mini/trades", qp)
+	if err != nil {
+		return nil, err
+	}
+
+	var trades types.Trades
+	if err := json.Unmarshal(resp, &trades); err != nil {
+		return nil, err
+	}
+
+	return &trades, nil
+}

client/query/query.go

@@ -18,6 +18,14 @@ type QueryClient interface {
 	GetTime() (*types.Time, error)
 	GetTokens(query *types.TokensQuery) ([]types.Token, error)
 	GetNodeInfo() (*types.ResultStatus, error)
+	GetMiniTokens(query *types.TokensQuery) ([]types.MiniToken, error)
+	GetMiniMarkets(query *types.MarketsQuery) ([]types.TradingPair, error)
+	GetMiniOpenOrders(query *types.OpenOrdersQuery) (*types.OpenOrders, error)
+	GetMiniClosedOrders(query *types.ClosedOrdersQuery) (*types.CloseOrders, error)
+	GetMiniOrder(orderID string) (*types.Order, error)
+	GetMiniKlines(query *types.KlineQuery) ([]types.Kline, error)
+	GetMiniTicker24h(query *types.Ticker24hQuery) ([]types.Ticker24h, error)
+	GetMiniTrades(query *types.TradesQuery) (*types.Trades, error)
 }
 
 type client struct {

client/rpc/dex_client.go

@@ -51,6 +51,10 @@ type DexClient interface {
 	GetSwapByCreator(creatorAddr string, offset int64, limit int64) ([]types.SwapBytes, error)
 	GetSwapByRecipient(recipientAddr string, offset int64, limit int64) ([]types.SwapBytes, error)
 
+	ListAllMiniTokens(offset int, limit int) ([]types.MiniToken, error)
+	GetMiniTokenInfo(symbol string) (*types.MiniToken, error)
+	GetMiniTradingPairs(offset int, limit int) ([]types.TradingPair, error)
+
 	SetKeyManager(k keys.KeyManager)
 	SendToken(transfers []msg.Transfer, syncType SyncType, options ...tx.Option) (*core_types.ResultBroadcastTx, error)
 	CreateOrder(baseAssetSymbol, quoteAssetSymbol string, op int8, price, quantity int64, syncType SyncType, options ...tx.Option) (*core_types.ResultBroadcastTx, error)
@@ -532,6 +536,67 @@ func (c *HTTP) GetSwapByRecipient(recipientAddr string, offset int64, limit int6
 	return swapIDList, nil
 }
 
+func (c *HTTP) ListAllMiniTokens(offset int, limit int) ([]types.MiniToken, error) {
+	if err := ValidateOffset(offset); err != nil {
+		return nil, err
+	}
+	if err := ValidateLimit(limit); err != nil {
+		return nil, err
+	}
+	path := fmt.Sprintf("mini-tokens/list/%d/%d", offset, limit)
+	result, err := c.ABCIQuery(path, nil)
+	if err != nil {
+		return nil, err
+	}
+	if !result.Response.IsOK() {
+		return nil, fmt.Errorf(result.Response.Log)
+	}
+	bz := result.Response.GetValue()
+	tokens := make([]types.MiniToken, 0)
+	err = c.cdc.UnmarshalBinaryLengthPrefixed(bz, &tokens)
+	return tokens, err
+}
+
+func (c *HTTP) GetMiniTokenInfo(symbol string) (*types.MiniToken, error) {
+	if err := ValidateSymbol(symbol); err != nil {
+		return nil, err
+	}
+	path := fmt.Sprintf("mini-tokens/info/%s", symbol)
+	result, err := c.ABCIQuery(path, nil)
+	if err != nil {
+		return nil, err
+	}
+	if !result.Response.IsOK() {
+		return nil, fmt.Errorf(result.Response.Log)
+	}
+	bz := result.Response.GetValue()
+	token := new(types.MiniToken)
+	err = c.cdc.UnmarshalBinaryLengthPrefixed(bz, token)
+	return token, err
+}
+
+func (c *HTTP) GetMiniTradingPairs(offset int, limit int) ([]types.TradingPair, error) {
+	if err := ValidateLimit(limit); err != nil {
+		return nil, err
+	}
+	if err := ValidateOffset(offset); err != nil {
+		return nil, err
+	}
+	rawTradePairs, err := c.ABCIQuery(fmt.Sprintf("dex-mini/pairs/%d/%d", offset, limit), nil)
+	if err != nil {
+		return nil, err
+	}
+	if !rawTradePairs.Response.IsOK() {
+		return nil, fmt.Errorf(rawTradePairs.Response.Log)
+	}
+	pairs := make([]types.TradingPair, 0)
+	if rawTradePairs.Response.GetValue() == nil {
+		return pairs, nil
+	}
+	err = c.cdc.UnmarshalBinaryLengthPrefixed(rawTradePairs.Response.GetValue(), &pairs)
+	return pairs, err
+}
+
 func (c *HTTP) SendToken(transfers []msg.Transfer, syncType SyncType, options ...tx.Option) (*core_types.ResultBroadcastTx, error) {
 	if c.key == nil {
 		return nil, KeyMissingError

client/transaction/burn_token.go

@@ -13,7 +13,7 @@ type BurnTokenResult struct {
 
 func (c *client) BurnToken(symbol string, amount int64, sync bool, options ...Option) (*BurnTokenResult, error) {
 	if symbol == "" {
-		return nil, fmt.Errorf("Burn token symbol can'c be empty ")
+		return nil, fmt.Errorf("Burn token symbol can't be empty ")
 	}
 	fromAddr := c.keyManager.GetAddr()
 

client/transaction/freeze_token.go

@@ -13,7 +13,7 @@ type FreezeTokenResult struct {
 
 func (c *client) FreezeToken(symbol string, amount int64, sync bool, options ...Option) (*FreezeTokenResult, error) {
 	if symbol == "" {
-		return nil, fmt.Errorf("Freeze token symbol can'c be empty ")
+		return nil, fmt.Errorf("Freeze token symbol can't be empty ")
 	}
 	fromAddr := c.keyManager.GetAddr()