Use *chainjson.HexBytes instead of *json.RawMessage (#370)

diff --git a/blockchain/query/annotated.go b/blockchain/query/annotated.go
index d6eaf05..3694295 100755 (executable)
--- a/blockchain/query/annotated.go
+++ b/blockchain/query/annotated.go
@@ -11,48 +11,48 @@ import (
 
 //AnnotatedTx means an annotated transaction.
 type AnnotatedTx struct {
-       ID                     bc.Hash            `json:"id"`
-       Timestamp              time.Time          `json:"timestamp"`
-       BlockID                bc.Hash            `json:"block_id"`
-       BlockHeight            uint64             `json:"block_height"`
-       Position               uint32             `json:"position"`
-       BlockTransactionsCount uint32             `json:"block_transactions_count,omitempty"`
-       ReferenceData          *json.RawMessage   `json:"reference_data"`
-       Inputs                 []*AnnotatedInput  `json:"inputs"`
-       Outputs                []*AnnotatedOutput `json:"outputs"`
-       StatusFail             bool               `json:"status_fail"`
+       ID                     bc.Hash             `json:"id"`
+       Timestamp              time.Time           `json:"timestamp"`
+       BlockID                bc.Hash             `json:"block_id"`
+       BlockHeight            uint64              `json:"block_height"`
+       Position               uint32              `json:"position"`
+       BlockTransactionsCount uint32              `json:"block_transactions_count,omitempty"`
+       ReferenceData          *chainjson.HexBytes `json:"reference_data"`
+       Inputs                 []*AnnotatedInput   `json:"inputs"`
+       Outputs                []*AnnotatedOutput  `json:"outputs"`
+       StatusFail             bool                `json:"status_fail"`
 }
 
 //AnnotatedInput means an annotated transaction input.
 type AnnotatedInput struct {
-       Type            string             `json:"type"`
-       AssetID         bc.AssetID         `json:"asset_id"`
-       AssetAlias      string             `json:"asset_alias,omitempty"`
-       AssetDefinition *json.RawMessage   `json:"asset_definition"`
-       Amount          uint64             `json:"amount"`
-       IssuanceProgram chainjson.HexBytes `json:"issuance_program,omitempty"`
-       ControlProgram  chainjson.HexBytes `json:"-"`
-       SpentOutputID   *bc.Hash           `json:"spent_output_id,omitempty"`
-       AccountID       string             `json:"account_id,omitempty"`
-       AccountAlias    string             `json:"account_alias,omitempty"`
-       ReferenceData   *json.RawMessage   `json:"reference_data"`
-       Arbitrary       chainjson.HexBytes `json:"arbitrary,omitempty"`
+       Type            string              `json:"type"`
+       AssetID         bc.AssetID          `json:"asset_id"`
+       AssetAlias      string              `json:"asset_alias,omitempty"`
+       AssetDefinition *chainjson.HexBytes `json:"asset_definition"`
+       Amount          uint64              `json:"amount"`
+       IssuanceProgram chainjson.HexBytes  `json:"issuance_program,omitempty"`
+       ControlProgram  chainjson.HexBytes  `json:"-"`
+       SpentOutputID   *bc.Hash            `json:"spent_output_id,omitempty"`
+       AccountID       string              `json:"account_id,omitempty"`
+       AccountAlias    string              `json:"account_alias,omitempty"`
+       ReferenceData   *chainjson.HexBytes `json:"reference_data"`
+       Arbitrary       chainjson.HexBytes  `json:"arbitrary,omitempty"`
 }
 
 //AnnotatedOutput means an annotated transaction output.
 type AnnotatedOutput struct {
-       Type            string             `json:"type"`
-       OutputID        bc.Hash            `json:"id"`
-       TransactionID   *bc.Hash           `json:"transaction_id,omitempty"`
-       Position        int                `json:"position"`
-       AssetID         bc.AssetID         `json:"asset_id"`
-       AssetAlias      string             `json:"asset_alias,omitempty"`
-       AssetDefinition *json.RawMessage   `json:"asset_definition"`
-       Amount          uint64             `json:"amount"`
-       AccountID       string             `json:"account_id,omitempty"`
-       AccountAlias    string             `json:"account_alias,omitempty"`
-       ControlProgram  chainjson.HexBytes `json:"control_program"`
-       ReferenceData   *json.RawMessage   `json:"reference_data"`
+       Type            string              `json:"type"`
+       OutputID        bc.Hash             `json:"id"`
+       TransactionID   *bc.Hash            `json:"transaction_id,omitempty"`
+       Position        int                 `json:"position"`
+       AssetID         bc.AssetID          `json:"asset_id"`
+       AssetAlias      string              `json:"asset_alias,omitempty"`
+       AssetDefinition *chainjson.HexBytes `json:"asset_definition"`
+       Amount          uint64              `json:"amount"`
+       AccountID       string              `json:"account_id,omitempty"`
+       AccountAlias    string              `json:"account_alias,omitempty"`
+       ControlProgram  chainjson.HexBytes  `json:"control_program"`
+       ReferenceData   *chainjson.HexBytes `json:"reference_data"`
 }
 
 //AnnotatedAccount means an annotated account.

diff --git a/blockchain/txfeed/txfeed.go b/blockchain/txfeed/txfeed.go
index 6603da8..225687f 100755 (executable)
--- a/blockchain/txfeed/txfeed.go
+++ b/blockchain/txfeed/txfeed.go
@@ -10,6 +10,7 @@ import (
        dbm "github.com/tendermint/tmlibs/db"
 
        "github.com/bytom/blockchain/query"
+       chainjson "github.com/bytom/encoding/json"
        "github.com/bytom/errors"
        "github.com/bytom/protocol"
        "github.com/bytom/protocol/bc"
@@ -319,7 +320,7 @@ func (t *Tracker) TxFilter(tx *legacy.Tx) error {
        return nil
 }
 
-var emptyJSONObject = json.RawMessage(`{}`)
+var emptyJSONObject = chainjson.HexBytes(`{}`)
 
 func buildAnnotatedTransaction(orig *legacy.Tx) *query.AnnotatedTx {
        tx := &query.AnnotatedTx{

diff --git a/blockchain/wallet/annotated.go b/blockchain/wallet/annotated.go
index a532e4d..8f5f057 100755 (executable)
--- a/blockchain/wallet/annotated.go
+++ b/blockchain/wallet/annotated.go
@@ -14,6 +14,7 @@ import (
        "github.com/bytom/common"
        "github.com/bytom/consensus"
        "github.com/bytom/crypto/sha3pool"
+       chainjson "github.com/bytom/encoding/json"
        "github.com/bytom/protocol/bc"
        "github.com/bytom/protocol/bc/legacy"
        "github.com/bytom/protocol/vm/vmutil"
@@ -23,34 +24,26 @@ import (
 func annotateTxsAsset(w *Wallet, txs []*query.AnnotatedTx) {
        for i, tx := range txs {
                for j, input := range tx.Inputs {
-                       alias, definition, err := w.getAliasDefinition(input.AssetID)
-                       if err != nil {
-                               continue
-                       }
-                       txs[i].Inputs[j].AssetAlias = alias
-                       txs[i].Inputs[j].AssetDefinition = &definition
+                       txs[i].Inputs[j].AssetAlias, txs[i].Inputs[j].AssetDefinition =
+                               w.getAliasDefinition(input.AssetID)
                }
-               for j, output := range tx.Outputs {
-                       alias, definition, err := w.getAliasDefinition(output.AssetID)
-                       if err != nil {
-                               continue
-                       }
-                       txs[i].Outputs[j].AssetAlias = alias
-                       txs[i].Outputs[j].AssetDefinition = &definition
+               for k, output := range tx.Outputs {
+                       txs[i].Outputs[k].AssetAlias, txs[i].Outputs[k].AssetDefinition =
+                               w.getAliasDefinition(output.AssetID)
                }
        }
 }
 
-func (w *Wallet) getExternalDefinition(assetID *bc.AssetID) (json.RawMessage, error) {
+func (w *Wallet) getExternalDefinition(assetID *bc.AssetID) *chainjson.HexBytes {
 
        definitionByte := w.DB.Get(asset.CalcExtAssetKey(assetID))
        if definitionByte == nil {
-               return nil, nil
+               return nil
        }
 
        definitionMap := make(map[string]interface{})
        if err := json.Unmarshal(definitionByte, &definitionMap); err != nil {
-               return nil, err
+               return nil
        }
 
        saveAlias := assetID.String()
@@ -64,32 +57,33 @@ func (w *Wallet) getExternalDefinition(assetID *bc.AssetID) (json.RawMessage, er
        storeBatch.Set(asset.AliasKey(saveAlias), []byte(assetID.String()))
        storeBatch.Write()
 
-       return definitionByte, nil
+       d := chainjson.HexBytes(definitionByte)
+       return &d
 
 }
 
-func (w *Wallet) getAliasDefinition(assetID bc.AssetID) (string, json.RawMessage, error) {
+func (w *Wallet) getAliasDefinition(assetID bc.AssetID) (string, *chainjson.HexBytes) {
        //btm
        if assetID.String() == consensus.BTMAssetID.String() {
                alias := consensus.BTMAlias
-               definition := []byte(asset.DefaultNativeAsset.RawDefinitionByte)
+               definition := &asset.DefaultNativeAsset.RawDefinitionByte
 
-               return alias, definition, nil
+               return alias, definition
        }
 
        //local asset and saved external asset
        if localAsset, err := w.AssetReg.FindByID(nil, &assetID); err == nil {
                alias := *localAsset.Alias
-               definition := []byte(localAsset.RawDefinitionByte)
-               return alias, definition, nil
+               definition := &localAsset.RawDefinitionByte
+               return alias, definition
        }
 
        //external asset
-       if definition, err := w.getExternalDefinition(&assetID); definition != nil {
-               return assetID.String(), definition, err
+       if definition := w.getExternalDefinition(&assetID); definition != nil {
+               return assetID.String(), definition
        }
 
-       return "", nil, fmt.Errorf("look up asset %s :not found ", assetID.String())
+       return "", nil
 }
 
 // annotateTxs adds account data to transactions
@@ -170,7 +164,7 @@ func getAccountFromACP(program []byte, walletDB db.DB) (*account.Account, error)
        return &localAccount, nil
 }
 
-var emptyJSONObject = json.RawMessage(`{}`)
+var emptyJSONObject = chainjson.HexBytes(`{}`)
 
 func isValidJSON(b []byte) bool {
        var v interface{}
@@ -193,7 +187,7 @@ func buildAnnotatedTransaction(orig *legacy.Tx, b *legacy.Block, indexInBlock in
                StatusFail:             statusFail,
        }
        if isValidJSON(orig.ReferenceData) {
-               referenceData := json.RawMessage(orig.ReferenceData)
+               referenceData := chainjson.HexBytes(orig.ReferenceData)
                tx.ReferenceData = &referenceData
        }
        for i := range orig.Inputs {
@@ -216,7 +210,7 @@ func buildAnnotatedInput(tx *legacy.Tx, i uint32) *query.AnnotatedInput {
                in.Amount = orig.Amount()
        }
        if isValidJSON(orig.ReferenceData) {
-               referenceData := json.RawMessage(orig.ReferenceData)
+               referenceData := chainjson.HexBytes(orig.ReferenceData)
                in.ReferenceData = &referenceData
        }
 
@@ -250,7 +244,7 @@ func buildAnnotatedOutput(tx *legacy.Tx, idx int) *query.AnnotatedOutput {
                ReferenceData:   &emptyJSONObject,
        }
        if isValidJSON(orig.ReferenceData) {
-               referenceData := json.RawMessage(orig.ReferenceData)
+               referenceData := chainjson.HexBytes(orig.ReferenceData)
                out.ReferenceData = &referenceData
        }
        if vmutil.IsUnspendable(out.ControlProgram) {

diff --git a/blockchain/wallet/indexer.go b/blockchain/wallet/indexer.go
index 9c25ed2..815be77 100755 (executable)
--- a/blockchain/wallet/indexer.go
+++ b/blockchain/wallet/indexer.go
@@ -187,7 +187,8 @@ func (w *Wallet) indexTransactions(batch db.Batch, b *legacy.Block) error {
        for _, tx := range annotatedTxs {
                rawTx, err := json.Marshal(tx)
                if err != nil {
-                       return errors.Wrap(err, "inserting annotated_txs to db")
+                       log.WithField("err", err).Error("inserting annotated_txs to db")
+                       return err
                }
 
                batch.Set(calcAnnotatedKey(formatKey(b.Height, uint32(tx.Position))), rawTx)