Update code style

diff --git a/blockchain/account/accounts.go b/blockchain/account/accounts.go
index 9ba6a56..be08601 100644 (file)
--- a/blockchain/account/accounts.go
+++ b/blockchain/account/accounts.go
@@ -100,7 +100,7 @@ func (m *Manager) Create(ctx context.Context, xpubs []chainkd.XPub, quorum int,
                return nil, errors.Wrap(err)
        }
 
-       account_id := json.RawMessage(accountSigner.ID)
+       accountID := json.RawMessage(accountSigner.ID)
        account := &Account{
                Signer: accountSigner,
                Alias:  alias,
@@ -112,8 +112,8 @@ func (m *Manager) Create(ctx context.Context, xpubs []chainkd.XPub, quorum int,
                return nil, errors.Wrap(err, "failed marshal account")
        }
        if len(acc) > 0 {
-               m.db.Set(account_id, acc)
-               m.db.Set(json.RawMessage("ali"+alias), account_id)
+               m.db.Set(accountID, acc)
+               m.db.Set(json.RawMessage("ali"+alias), accountID)
        }
 
        err = m.indexAnnotatedAccount(ctx, account)
@@ -132,14 +132,14 @@ func (m *Manager) UpdateTags(ctx context.Context, id, alias *string, tags map[st
                return errors.Wrap(ErrBadIdentifier)
        }
 
-       var key_id []byte
+       var keyID []byte
        if alias != nil {
-               key_id = m.db.Get([]byte("ali" + *alias))
+               keyID = m.db.Get(json.RawMessage("ali" + *alias))
        } else {
-               key_id = json.RawMessage(*id)
+               keyID = json.RawMessage(*id)
        }
 
-       bytes := m.db.Get(key_id)
+       bytes := m.db.Get(keyID)
        if bytes == nil {
                return errors.New("no exit this account")
        }
@@ -171,7 +171,7 @@ func (m *Manager) UpdateTags(ctx context.Context, id, alias *string, tags map[st
 
        } else {
 
-               m.db.Set(key_id, acc)
+               m.db.Set(keyID, acc)
                return nil
        }
 
@@ -187,14 +187,6 @@ func (m *Manager) FindByAlias(ctx context.Context, alias string) (*signers.Signe
        if ok {
                accountID = cachedID.(string)
        } else {
-               /*const q = `SELECT account_id FROM accounts WHERE alias=$1`
-               err := m.db.QueryRowContext(ctx, q, alias).Scan(&accountID)
-               if err == stdsql.ErrNoRows {
-                       return nil, errors.WithDetailf(pg.ErrUserInputNotFound, "alias: %s", alias)
-               }
-               if err != nil {
-                       return nil, errors.Wrap(err)
-               }*/
                bytez := m.db.Get([]byte("ali" + alias))
                accountID = string(bytez[:])
                m.cacheMu.Lock()

diff --git a/blockchain/account/reserve.go b/blockchain/account/reserve.go
index 35d447f..00a4f66 100644 (file)
--- a/blockchain/account/reserve.go
+++ b/blockchain/account/reserve.go
@@ -394,9 +394,13 @@ func (sr *sourceReserver) refillCache(ctx context.Context) error {
 
 func findMatchingUTXOs(ctx context.Context, db dbm.DB, src source, height uint64) ([]*utxo, error) {
 
-       var utxos []*utxo
-       var au AccountUTXOs
-       var b32 [3][32]byte
+       var (
+               utxos       []*utxo
+               au          AccountUTXOs
+               rawOutputID [32]byte
+               rawSourceID [32]byte
+               rawRefData  [32]byte
+       )
 
        iter := db.Iterator()
        for iter.Next() {
@@ -414,18 +418,18 @@ func findMatchingUTXOs(ctx context.Context, db dbm.DB, src source, height uint64
                        (bytes.Equal(au.AssetID, src.AssetID.Bytes())) &&
                        (au.InBlock > height) {
 
-                       copy(b32[0][:], au.OutputID)
-                       copy(b32[1][:], au.SourceID)
-                       copy(b32[2][:], au.RefData)
+                       copy(rawOutputID[:], au.OutputID)
+                       copy(rawSourceID[:], au.SourceID)
+                       copy(rawRefData[:], au.RefData)
 
                        utxos = append(utxos, &utxo{
-                               OutputID:            bc.NewHash(b32[0]),
-                               SourceID:            bc.NewHash(b32[1]),
+                               OutputID:            bc.NewHash(rawOutputID),
+                               SourceID:            bc.NewHash(rawSourceID),
                                AssetID:             src.AssetID,
                                Amount:              au.Amount,
                                SourcePos:           au.SourcePos,
                                ControlProgram:      au.Program,
-                               RefDataHash:         bc.NewHash(b32[2]),
+                               RefDataHash:         bc.NewHash(rawRefData),
                                AccountID:           src.AccountID,
                                ControlProgramIndex: au.CpIndex,
                        })
@@ -442,40 +446,49 @@ func findMatchingUTXOs(ctx context.Context, db dbm.DB, src source, height uint64
 }
 
 func findSpecificUTXO(ctx context.Context, db dbm.DB, outHash bc.Hash) (*utxo, error) {
-
        u := new(utxo)
        au := new(AccountUTXOs)
-       b32 := new([4][32]byte)
 
+       //temp fix for coinbase UTXO isn't add to accountUTXO db, will be remove later
+       if outHash.String() == "73d1e97c7bcf2b084f936a40f4f2a72e909417f2b46699e8659fa4c4feddb98d" {
+               return genesisBlockUTXO(), nil
+       }
+
+       // make sure accountUTXO existed in the db
        accUTXOValue := db.Get(json.RawMessage("acu" + string(outHash.Bytes())))
-       if accUTXOValue != nil {
-               err := json.Unmarshal(accUTXOValue, &au)
-               if err != nil {
-                       return nil, errors.Wrap(err)
-               }
+       if accUTXOValue == nil {
+               return u, errors.New(fmt.Sprintf("can't find utxo: %s", outHash.String()))
+       }
+       if err := json.Unmarshal(accUTXOValue, &au); err != nil {
+               return nil, errors.Wrap(err)
+       }
 
-               copy(b32[0][:], au.OutputID)
-               copy(b32[1][:], au.AssetID)
-               copy(b32[2][:], au.SourceID)
-               copy(b32[3][:], au.RefData)
+       rawOutputID := new([32]byte)
+       rawAssetID := new([32]byte)
+       rawSourceID := new([32]byte)
+       rawRefData := new([32]byte)
 
-               u.OutputID = bc.NewHash(b32[0])
-               u.AccountID = au.AccountID
-               u.AssetID = bc.NewAssetID(b32[1])
-               u.Amount = au.Amount
-               u.ControlProgramIndex = au.CpIndex
-               u.ControlProgram = au.Program
-               u.SourceID = bc.NewHash(b32[2])
-               u.SourcePos = au.SourcePos
-               u.RefDataHash = bc.NewHash(b32[3])
+       copy(rawOutputID[:], au.OutputID)
+       copy(rawAssetID[:], au.AssetID)
+       copy(rawSourceID[:], au.SourceID)
+       copy(rawRefData[:], au.RefData)
 
-               return u, nil
-       }
+       u.OutputID = bc.NewHash(*rawOutputID)
+       u.AccountID = au.AccountID
+       u.AssetID = bc.NewAssetID(*rawAssetID)
+       u.Amount = au.Amount
+       u.ControlProgramIndex = au.CpIndex
+       u.ControlProgram = au.Program
+       u.SourceID = bc.NewHash(*rawSourceID)
+       u.SourcePos = au.SourcePos
+       u.RefDataHash = bc.NewHash(*rawRefData)
 
-       if outHash.String() != "73d1e97c7bcf2b084f936a40f4f2a72e909417f2b46699e8659fa4c4feddb98d" {
-               return u, errors.New(fmt.Sprintf("can't find utxo: %s", outHash.String()))
-       }
+       return u, nil
+}
 
+//temp fix for coinbase UTXO isn't add to accountUTXO db, will be remove later
+func genesisBlockUTXO() *utxo {
+       u := new(utxo)
        genesisBlock := &legacy.Block{
                BlockHeader:  legacy.BlockHeader{},
                Transactions: []*legacy.Tx{},
@@ -495,6 +508,5 @@ func findSpecificUTXO(ctx context.Context, db dbm.DB, outHash bc.Hash) (*utxo, e
        u.SourceID = *resOut.Source.Ref
        u.SourcePos = resOut.Source.Position
        u.RefDataHash = *resOut.Data
-
-       return u, nil
+       return u
 }

diff --git a/node/node.go b/node/node.go
index ea26d3e..d87832d 100644 (file)
--- a/node/node.go
+++ b/node/node.go
@@ -156,8 +156,8 @@ func NewNode(config *cfg.Config) *Node {
        ctx := context.Background()
 
        // Get store
-       tx_db := dbm.NewDB("txdb", config.DBBackend, config.DBDir())
-       store := txdb.NewStore(tx_db)
+       txDB := dbm.NewDB("txdb", config.DBBackend, config.DBDir())
+       store := txdb.NewStore(txDB)
 
        privKey := crypto.GenPrivKeyEd25519()
 
@@ -192,9 +192,9 @@ func NewNode(config *cfg.Config) *Node {
        var pinStore *pin.Store = nil
 
        if config.Wallet.Enable {
-               accounts_db := dbm.NewDB("account", config.DBBackend, config.DBDir())
-               acc_utxos_db := dbm.NewDB("accountutxos", config.DBBackend, config.DBDir())
-               pinStore = pin.NewStore(acc_utxos_db)
+               accountsDB := dbm.NewDB("account", config.DBBackend, config.DBDir())
+               accUTXODB := dbm.NewDB("accountutxos", config.DBBackend, config.DBDir())
+               pinStore = pin.NewStore(accUTXODB)
                err = pinStore.LoadAll(ctx)
                if err != nil {
                        bytomlog.Error(ctx, err)
@@ -214,11 +214,11 @@ func NewNode(config *cfg.Config) *Node {
                        }
                }
 
-               accounts = account.NewManager(accounts_db, chain, pinStore)
+               accounts = account.NewManager(accountsDB, chain, pinStore)
                go accounts.ProcessBlocks(ctx)
 
-               assets_db := dbm.NewDB("asset", config.DBBackend, config.DBDir())
-               assets = asset.NewRegistry(assets_db, chain)
+               assetsDB := dbm.NewDB("asset", config.DBBackend, config.DBDir())
+               assets = asset.NewRegistry(assetsDB, chain)
        }
        //Todo HSM
        /*