fix for golint

diff --git a/account/accounts.go b/account/accounts.go
index 81f1f3a..0c39011 100644 (file)
--- a/account/accounts.go
+++ b/account/accounts.go
@@ -25,16 +25,16 @@ import (
 )
 
 const (
-       maxAccountCache     = 1000
-       aliasPrefix         = "ALI:"
-       accountCPPrefix     = "ACP:"
-       contractIndexPrefix = "ACPI:"
+       maxAccountCache = 1000
 )
 
 var (
-       miningAddressKey = []byte("miningAddress")
-       accountIndexKey  = []byte("accountIndex")
-       accountPrefix    = []byte("ACC:")
+       accountIndexKey     = []byte("AccountIndex")
+       accountPrefix       = []byte("Account:")
+       aliasPrefix         = []byte("AccountAlias:")
+       contractIndexPrefix = []byte("ContractIndex")
+       contractPrefix      = []byte("Contract:")
+       miningAddressKey    = []byte("MiningAddress")
 )
 
 // pre-define errors for supporting bytom errorFormatter
@@ -45,21 +45,21 @@ var (
 )
 
 func aliasKey(name string) []byte {
-       return []byte(aliasPrefix + name)
+       return append(aliasPrefix, []byte(name)...)
 }
 
-//Key account store prefix
+// Key account store prefix
 func Key(name string) []byte {
        return append(accountPrefix, []byte(name)...)
 }
 
-//CPKey account control promgram store prefix
-func CPKey(hash common.Hash) []byte {
-       return append([]byte(accountCPPrefix), hash[:]...)
+// ContractKey account control promgram store prefix
+func ContractKey(hash common.Hash) []byte {
+       return append(contractPrefix, hash[:]...)
 }
 
 func contractIndexKey(accountID string) []byte {
-       return append([]byte(contractIndexPrefix), []byte(accountID)...)
+       return append(contractIndexPrefix, []byte(accountID)...)
 }
 
 // NewManager creates a new account manager
@@ -232,11 +232,6 @@ func (m *Manager) GetAliasByID(id string) string {
        return account.Alias
 }
 
-// CreateAddressForChange generate an address for the UTXO change
-func (m *Manager) CreateCtrlProgramForChange(ctx context.Context, accountID string) (cp *CtrlProgram, err error) {
-       return m.CreateAddress(ctx, accountID, true)
-}
-
 // CreateAddress generate an address for the select account
 func (m *Manager) CreateAddress(ctx context.Context, accountID string, change bool) (cp *CtrlProgram, err error) {
        account, err := m.FindByID(ctx, accountID)
@@ -263,23 +258,6 @@ func (m *Manager) createAddress(ctx context.Context, account *Account, change bo
        return cp, nil
 }
 
-// ListCtrlProgramsByAccountId
-func (m *Manager) ListCtrlProgramsByAccountId(ctx context.Context, accountId string) ([]*CtrlProgram, error) {
-       cps, err := m.ListControlProgram()
-       if err != nil {
-               return nil, err
-       }
-
-       var result []*CtrlProgram
-       for _, cp := range cps {
-               if cp.Address == "" || cp.AccountID != accountId {
-                       continue
-               }
-               result = append(result, cp)
-       }
-       return result, nil
-}
-
 func (m *Manager) createP2PKH(ctx context.Context, account *Account, change bool) (*CtrlProgram, error) {
        idx := m.getNextContractIndex(account.ID)
        path := signers.Path(account.Signer, signers.AccountKeySpace, idx)
@@ -356,22 +334,16 @@ func (m *Manager) insertAccountControlProgram(ctx context.Context, progs ...*Ctr
                }
 
                sha3pool.Sum256(hash[:], prog.ControlProgram)
-               m.db.Set(CPKey(hash), accountCP)
+               m.db.Set(ContractKey(hash), accountCP)
        }
        return nil
 }
 
-func (m *Manager) DeleteAccountControlProgram(prog []byte) {
-       var hash common.Hash
-       sha3pool.Sum256(hash[:], prog)
-       m.db.Delete(CPKey(hash))
-}
-
 // IsLocalControlProgram check is the input control program belong to local
 func (m *Manager) IsLocalControlProgram(prog []byte) bool {
        var hash common.Hash
        sha3pool.Sum256(hash[:], prog)
-       bytes := m.db.Get(CPKey(hash))
+       bytes := m.db.Get(ContractKey(hash))
        return bytes != nil
 }
 
@@ -408,16 +380,11 @@ func (m *Manager) GetCoinbaseControlProgram() ([]byte, error) {
        return program.ControlProgram, nil
 }
 
-// AccountInfo
-type Info struct {
-       AccountInfo string `json:"account_info"`
-}
-
 // DeleteAccount deletes the account's ID or alias matching accountInfo.
-func (m *Manager) DeleteAccount(aliasOrId string) (err error) {
+func (m *Manager) DeleteAccount(aliasOrID string) (err error) {
        account := &Account{}
-       if account, err = m.FindByAlias(nil, aliasOrId); err != nil {
-               if account, err = m.FindByID(nil, aliasOrId); err != nil {
+       if account, err = m.FindByAlias(nil, aliasOrID); err != nil {
+               if account, err = m.FindByID(nil, aliasOrID); err != nil {
                        return err
                }
        }
@@ -455,7 +422,7 @@ func (m *Manager) ListAccounts() ([]*Account, error) {
 // ListControlProgram return all the local control program
 func (m *Manager) ListControlProgram() ([]*CtrlProgram, error) {
        var cps []*CtrlProgram
-       cpIter := m.db.IteratorPrefix([]byte(accountCPPrefix))
+       cpIter := m.db.IteratorPrefix(contractPrefix)
        defer cpIter.Release()
 
        for cpIter.Next() {

diff --git a/account/builder.go b/account/builder.go
index 693e8f8..95a191d 100644 (file)
--- a/account/builder.go
+++ b/account/builder.go
@@ -72,7 +72,7 @@ func (a *spendAction) Build(ctx context.Context, b *txbuilder.TemplateBuilder) e
        }
 
        if res.Change > 0 {
-               acp, err := a.accounts.CreateCtrlProgramForChange(ctx, a.AccountID)
+               acp, err := a.accounts.CreateAddress(ctx, a.AccountID, true)
                if err != nil {
                        return errors.Wrap(err, "creating control program")
                }

diff --git a/api/accounts.go b/api/accounts.go
index 87a39e0..5b0e212 100644 (file)
--- a/api/accounts.go
+++ b/api/accounts.go
@@ -106,13 +106,16 @@ func (a *API) listAddresses(ctx context.Context, ins struct {
                target = acc
        }
 
-       cps, err := a.wallet.AccountMgr.ListCtrlProgramsByAccountId(ctx, target.ID)
+       cps, err := a.wallet.AccountMgr.ListControlProgram()
        if err != nil {
                return NewErrorResponse(err)
        }
 
        addresses := []*addressResp{}
        for _, cp := range cps {
+               if cp.Address == "" || cp.AccountID != target.ID {
+                       continue
+               }
                addresses = append(addresses, &addressResp{
                        AccountAlias: target.Alias,
                        AccountID:    cp.AccountID,

diff --git a/asset/asset.go b/asset/asset.go
index 76d2bf2..03a037e 100644 (file)
--- a/asset/asset.go
+++ b/asset/asset.go
@@ -27,15 +27,13 @@ var DefaultNativeAsset *Asset
 
 const (
        maxAssetCache = 1000
-       //AliasPrefix is asset alias prefix
-       AliasPrefix = "ALS:"
-       //ExternalAssetPrefix is external definition assets prefix
-       ExternalAssetPrefix = "EXA"
 )
 
 var (
-       assetIndexKey = []byte("assetIndex")
-       assetPrefix   = []byte("ASS:")
+       assetIndexKey  = []byte("AssetIndex")
+       assetPrefix    = []byte("Asset:")
+       aliasPrefix    = []byte("AssetAlias:")
+       extAssetPrefix = []byte("EXA:")
 )
 
 func initNativeAsset() {
@@ -55,18 +53,17 @@ func initNativeAsset() {
 
 // AliasKey store asset alias prefix
 func AliasKey(name string) []byte {
-       return []byte(AliasPrefix + name)
+       return append(aliasPrefix, []byte(name)...)
 }
 
-//Key asset store prefix
+// AssetKey asset store prefix
 func Key(id *bc.AssetID) []byte {
        return append(assetPrefix, id.Bytes()...)
 }
 
-//CalcExtAssetKey return store external assets key
-func CalcExtAssetKey(id *bc.AssetID) []byte {
-       name := id.String()
-       return []byte(ExternalAssetPrefix + name)
+// ExtAssetKey return store external assets key
+func ExtAssetKey(id *bc.AssetID) []byte {
+       return append(extAssetPrefix, id.Bytes()...)
 }
 
 // pre-define errors for supporting bytom errorFormatter
@@ -287,7 +284,7 @@ func (reg *Registry) GetAsset(id *bc.AssetID) (*Asset, error) {
                return asset, nil
        }
 
-       if extAsset := reg.db.Get(CalcExtAssetKey(id)); extAsset != nil {
+       if extAsset := reg.db.Get(ExtAssetKey(id)); extAsset != nil {
                if err := json.Unmarshal(extAsset, asset); err != nil {
                        return nil, err
                }

diff --git a/test/tx_test_util.go b/test/tx_test_util.go
index 997c904..a434a5a 100644 (file)
--- a/test/tx_test_util.go
+++ b/test/tx_test_util.go
@@ -296,7 +296,7 @@ func SignInstructionFor(input *types.SpendInput, db db.DB, signer *signers.Signe
        cp := account.CtrlProgram{}
        var hash [32]byte
        sha3pool.Sum256(hash[:], input.ControlProgram)
-       bytes := db.Get(account.CPKey(hash))
+       bytes := db.Get(account.ContractKey(hash))
        if bytes == nil {
                return nil, fmt.Errorf("can't find CtrlProgram for the SpendInput")
        }

diff --git a/wallet/annotated.go b/wallet/annotated.go
index a2c674b..05cfe5c 100644 (file)
--- a/wallet/annotated.go
+++ b/wallet/annotated.go
@@ -35,7 +35,7 @@ func annotateTxsAsset(w *Wallet, txs []*query.AnnotatedTx) {
 }
 
 func (w *Wallet) getExternalDefinition(assetID *bc.AssetID) json.RawMessage {
-       definitionByte := w.DB.Get(asset.CalcExtAssetKey(assetID))
+       definitionByte := w.DB.Get(asset.ExtAssetKey(assetID))
        if definitionByte == nil {
                return nil
        }
@@ -147,7 +147,7 @@ func getAccountFromACP(program []byte, walletDB db.DB) (*account.Account, error)
 
        sha3pool.Sum256(hash[:], program)
 
-       rawProgram := walletDB.Get(account.CPKey(hash))
+       rawProgram := walletDB.Get(account.ContractKey(hash))
        if rawProgram == nil {
                return nil, fmt.Errorf("failed get account control program:%x ", hash)
        }

diff --git a/wallet/indexer.go b/wallet/indexer.go
index 9552117..db91d27 100644 (file)
--- a/wallet/indexer.go
+++ b/wallet/indexer.go
@@ -21,7 +21,7 @@ import (
 )
 
 type rawOutput struct {
-       OutputID       bc.Hash
+       OutputID bc.Hash
        bc.AssetAmount
        ControlProgram []byte
        txHash         bc.Hash
@@ -156,8 +156,8 @@ func saveExternalAssetDefinition(b *types.Block, walletDB db.DB) {
                        if ii, ok := orig.TypedInput.(*types.IssuanceInput); ok {
                                if isValidJSON(ii.AssetDefinition) {
                                        assetID := ii.AssetID()
-                                       if assetExist := walletDB.Get(asset.CalcExtAssetKey(&assetID)); assetExist == nil {
-                                               storeBatch.Set(asset.CalcExtAssetKey(&assetID), ii.AssetDefinition)
+                                       if assetExist := walletDB.Get(asset.ExtAssetKey(&assetID)); assetExist == nil {
+                                               storeBatch.Set(asset.ExtAssetKey(&assetID), ii.AssetDefinition)
                                        }
                                }
                        }
@@ -307,7 +307,7 @@ func loadAccountInfo(outs []*rawOutput, w *Wallet) []*accountOutput {
                }
 
                sha3pool.Sum256(hash[:], []byte(s))
-               bytes := w.DB.Get(account.CPKey(hash))
+               bytes := w.DB.Get(account.ContractKey(hash))
                if bytes == nil {
                        continue
                }
@@ -385,7 +385,7 @@ transactionLoop:
                for _, v := range tx.Outputs {
                        var hash [32]byte
                        sha3pool.Sum256(hash[:], v.ControlProgram)
-                       if bytes := w.DB.Get(account.CPKey(hash)); bytes != nil {
+                       if bytes := w.DB.Get(account.ContractKey(hash)); bytes != nil {
                                annotatedTxs = append(annotatedTxs, w.buildAnnotatedTransaction(tx, b, statusFail, pos))
                                continue transactionLoop
                        }