MOD: only handle 4swap lp / rings token;

.gitignore

@@ -15,3 +15,6 @@ ftoken
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+
+builds
+ftoken

cmd/deploy.go

@@ -14,17 +14,16 @@ var deployCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		ctx := context.Background()
 		exec, _ := cmd.Flags().GetBool("e")
-		receiver, _ := cmd.Flags().GetString("receiver")
 		tokenStr, _ := cmd.Flags().GetString("tokens")
 
-		var tokens core.Tokens
+		var tokens core.TokenItems
 		if err := json.Unmarshal([]byte(tokenStr), &tokens); err != nil {
 			cmd.PrintErr("unmarshal tokens failed: ", tokens)
 			return
 		}
 
 		factory := provideQuorumFactory()
-		tx, err := factory.CreateTransaction(ctx, tokens, &core.Address{Destination: receiver})
+		tx, err := factory.CreateTransaction(ctx, tokens, "")
 		if err != nil {
 			cmd.PrintErr("CreateTransaction failed:", err)
 			return

cmd/provide.go

@@ -5,7 +5,9 @@ import (
 
 	"github.com/fox-one/ftoken/core"
 	"github.com/fox-one/ftoken/quorum"
+	assetz "github.com/fox-one/ftoken/service/asset"
 	walletz "github.com/fox-one/ftoken/service/wallet"
+	"github.com/fox-one/ftoken/store/asset"
 	"github.com/fox-one/ftoken/store/order"
 	"github.com/fox-one/ftoken/store/transaction"
 	"github.com/fox-one/ftoken/store/wallet"
@@ -21,7 +23,6 @@ func provideSystem(ctx context.Context, client *mixin.Client, factories []core.F
 		ClientID:     cfg.Dapp.ClientID,
 		ClientSecret: cfg.Dapp.ClientSecret,
 		Version:      rootCmd.Version,
-		Addresses:    make(map[string]*core.Address, len(factories)),
 		Gas: core.Gas{
 			Mins:             make(number.Values, len(cfg.Gas.Mins)),
 			Multiplier:       cfg.Gas.Multiplier,
@@ -33,17 +34,6 @@ func provideSystem(ctx context.Context, client *mixin.Client, factories []core.F
 		system.Gas.Mins.Set(val.Platform, val.Min)
 	}
 
-	for _, factory := range factories {
-		asset, err := client.ReadAsset(ctx, factory.GasAsset())
-		if err != nil {
-			return system, err
-		}
-		system.Addresses[factory.GasAsset()] = &core.Address{
-			Destination: asset.Destination,
-			Tag:         asset.Tag,
-		}
-	}
-
 	return system, nil
 }
 
@@ -56,10 +46,6 @@ func provideMixinClient() *mixin.Client {
 	return c
 }
 
-func provideWalletService(c *mixin.Client) core.WalletService {
-	return walletz.New(walletz.Config{Pin: cfg.Dapp.Pin}, c)
-}
-
 func provideDatabase() (*db.DB, error) {
 	database, err := db.Open(cfg.DB)
 	if err != nil {
@@ -89,6 +75,18 @@ func provideTransactionStore(db *db.DB) core.TransactionStore {
 	return transaction.New(db)
 }
 
+func provideAssetStore(db *db.DB) core.AssetStore {
+	return asset.New(db)
+}
+
+func provideWalletService(c *mixin.Client) core.WalletService {
+	return walletz.New(walletz.Config{Pin: cfg.Dapp.Pin}, c)
+}
+
+func provideAssetService(c *mixin.Client) core.AssetService {
+	return assetz.New(c)
+}
+
 func provideAllFactories() []core.Factory {
 	return []core.Factory{
 		provideQuorumFactory(),

cmd/server.go

@@ -66,6 +66,7 @@ var serverCmd = &cobra.Command{
 
 			svr := handler.New(
 				system,
+				provideAssetStore(database),
 				provideOrderStore(database),
 				provideTransactionStore(database),
 				provideWalletService(client),

cmd/worker.go

@@ -33,6 +33,7 @@ var workerCmd = &cobra.Command{
 		defer database.Close()
 		client := provideMixinClient()
 
+		assets := provideAssetStore(database)
 		wallets := provideWalletStore(database)
 		walletz := provideWalletService(client)
 		orders := provideOrderStore(database)
@@ -51,6 +52,7 @@ var workerCmd = &cobra.Command{
 				payee.Config{ClientID: cfg.Dapp.ClientID},
 				system,
 				properties,
+				assets,
 				orders,
 				transactions,
 				wallets,

core/asset.go

@@ -0,0 +1,39 @@
+package core
+
+import (
+	"context"
+	"errors"
+	"time"
+)
+
+var (
+	ErrAssetNotExist = errors.New("asset not exist")
+)
+
+type (
+	Asset struct {
+		ID            uint64    `sql:"PRIMARY_KEY;" json:"id"`
+		AssetID       string    `sql:"size:36;" json:"asset_id,omitempty"`
+		CreatedAt     time.Time `json:"created_at,omitempty"`
+		UpdatedAt     time.Time `json:"updated_at,omitempty"`
+		Version       int64     `sql:"not null" json:"version,omitempty"`
+		Verified      bool      `json:"verified"`
+		Name          string    `sql:"size:64" json:"name,omitempty"`
+		Symbol        string    `sql:"size:32" json:"symbol,omitempty"`
+		DisplaySymbol string    `sql:"size:32;default:null;" json:"display_symbol,omitempty"`
+		ChainID       string    `sql:"size:36" json:"chain_id,omitempty"`
+	}
+
+	// AssetStore defines operations for working with assets on db.
+	AssetStore interface {
+		Save(ctx context.Context, asset *Asset) error
+		Find(ctx context.Context, assetIDs ...string) ([]*Asset, error)
+		ListAll(ctx context.Context) ([]*Asset, error)
+	}
+
+	// AssetService provides access to assets information
+	// in the remote system like mixin network.
+	AssetService interface {
+		Find(ctx context.Context, assetID string) (*Asset, error)
+	}
+)

core/factory.go

@@ -1,12 +1,7 @@
 package core
 
 import (
-	"bytes"
 	"context"
-	"database/sql/driver"
-	"encoding/binary"
-	"encoding/json"
-	"errors"
 	"time"
 
 	"github.com/shopspring/decimal"
@@ -22,16 +17,6 @@ const (
 type (
 	TransactionState int
 
-	Token struct {
-		Name        string `gorm:"size:255;" json:"name,omitempty"`
-		Symbol      string `gorm:"size:255;" json:"symbol,omitempty"`
-		TotalSupply uint64 `json:"total_supply,omitempty"`
-		AssetKey    string `gorm:"size:255;" json:"asset_key,omitempty"`
-		AssetID     string `gorm:"size:36;" json:"asset_id,omitempty"`
-	}
-
-	Tokens []*Token
-
 	Transaction struct {
 		ID        uint64           `sql:"PRIMARY_KEY;" json:"id"`
 		CreatedAt time.Time        `json:"created_at"`
@@ -41,14 +26,14 @@ type (
 		Hash      string           `sql:"size:127;" json:"hash,omitempty"`
 		Raw       string           `sql:"type:longtext;" json:"raw,omitempty"`
 		State     TransactionState `json:"state,omitempty"`
-		Tokens    Tokens           `sql:"type:longtext;" json:"tokens,omitempty"`
+		Tokens    TokenItems       `sql:"type:longtext;" json:"tokens,omitempty"`
 		Gas       decimal.Decimal  `sql:"type:decimal(64,8)" json:"gas,omitempty"`
 	}
 
 	Factory interface {
 		Platform() string
 		GasAsset() string
-		CreateTransaction(ctx context.Context, tokens []*Token, trace string) (*Transaction, error)
+		CreateTransaction(ctx context.Context, tokens TokenItems, trace string) (*Transaction, error)
 		SendTransaction(ctx context.Context, tx *Transaction) error
 		ReadTransaction(ctx context.Context, hash string) (*Transaction, error)
 	}
@@ -60,123 +45,3 @@ type (
 		FindTrace(ctx context.Context, traceID string) ([]*Transaction, error)
 	}
 )
-
-func EncodeTokens(tokens Tokens) ([]byte, error) {
-	enc := bytes.NewBuffer(nil)
-	for _, token := range tokens {
-		enc.WriteByte(byte(len(token.Name)))
-		enc.Write([]byte(token.Name))
-		enc.WriteByte(byte(len(token.Symbol)))
-		enc.Write([]byte(token.Symbol))
-		enc.Write(uint64ToByte(token.TotalSupply))
-	}
-	return enc.Bytes(), nil
-}
-
-func EncodeToken(token Token) ([]byte, error) {
-	enc := bytes.NewBuffer(nil)
-	enc.WriteByte(byte(len(token.Name)))
-	enc.Write([]byte(token.Name))
-	enc.WriteByte(byte(len(token.Symbol)))
-	enc.Write([]byte(token.Symbol))
-	enc.Write(uint64ToByte(token.TotalSupply))
-	return enc.Bytes(), nil
-}
-
-func DecodeTokens(data []byte) Tokens {
-	var (
-		token  *Token
-		tokens Tokens
-	)
-
-	for len(data) > 10 {
-		if token, data = DecodeToken(data); token != nil {
-			tokens = append(tokens, token)
-		}
-	}
-	return tokens
-}
-
-func DecodeToken(data []byte) (*Token, []byte) {
-	if len(data) <= 10 {
-		return nil, nil
-	}
-
-	var token Token
-	offset := 0
-	if size := int(data[offset]); len(data) > 10+size {
-		offset++
-		token.Name = string(data[offset : offset+size])
-		offset += size
-	} else {
-		return nil, nil
-	}
-
-	if size := int(data[offset]); len(data) >= offset+size+9 {
-		offset++
-		token.Symbol = string(data[offset : offset+size])
-		offset += size
-	} else {
-		return nil, nil
-	}
-
-	token.TotalSupply = binary.BigEndian.Uint64(data[offset : offset+8])
-	offset += 8
-	data = data[offset:]
-	if token.TotalSupply > 0 {
-		return &token, data
-	}
-	return nil, data
-}
-
-func uint64ToByte(d uint64) []byte {
-	b := make([]byte, 8)
-	binary.BigEndian.PutUint64(b, d)
-	return b
-}
-
-func (t Token) MarshalBinary() ([]byte, error) {
-	return EncodeToken(t)
-}
-
-func (t *Token) UnmarshalBinary(data []byte) error {
-	token, _ := DecodeToken(data)
-	if token == nil {
-		return errors.New("unmarshal Token failed")
-	}
-	*t = *token
-	return nil
-}
-
-func (t Tokens) MarshalBinary() ([]byte, error) {
-	return EncodeTokens(t)
-}
-
-func (t *Tokens) UnmarshalBinary(data []byte) error {
-	tokens := DecodeTokens(data)
-	*t = tokens
-	return nil
-}
-
-// Scan implements the sql.Scanner interface for database deserialization.
-func (s *Tokens) Scan(value interface{}) error {
-	var d []byte
-	switch v := value.(type) {
-	case string:
-		d = []byte(v)
-	case []byte:
-		d = v
-	}
-	var tokens Tokens
-	if err := json.Unmarshal(d, &tokens); err != nil {
-		return err
-	}
-	*s = tokens
-	return nil
-}
-
-// Value implements the driver.Valuer interface for database serialization.
-func (s Tokens) Value() (driver.Value, error) {
-	data, err := json.Marshal(s)
-	return data, err
-}